Programar em C/Algoritmo de alocação: diferenças entre revisões

Origem: Wikilivros, livros abertos por um mundo aberto.
[revisão pendente][revisão pendente]
Conteúdo apagado Conteúdo adicionado
Linha 1: Linha 1:
==first fist==
==first fist==
Verifica se o processo é menor que a memória atual. Caso for menor, aloca a memória e volta para o início, após percorre toda a lista novamente, caso contrário, segue adiante. <syntaxhighlight lang="c">
#include<stdio.h>

int main()
{
int a[20],p[20],i,j,n,m;
printf("Entre o numero de blocos de memoria:\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("Entre o tamanho do bloco de memoria %d: ",i);
scanf("%d",&a[i]);
}
printf("Entre o numero de processos:\n");
scanf("%d",&m);
for(i=0;i<m;i++)
{
printf("Entre o tamanho do processo %d: ",i);
scanf("%d",&p[i]);
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
if(p[j]<=a[i]) {
printf("O processo %d esta alocado no bloco memoria %d\n",j,a[i]);
p[j]=10000;
break;
}
}
}
for(j=0;j<m;j++)
{
if(p[j]!=10000)
{
printf("O Processo %d nao esta alocado\n",j);
}
}
return 0;
}
</syntaxhighlight>


==best fit==
==best fit==

Revisão das 08h18min de 25 de novembro de 2015

first fist

Verifica se o processo é menor que a memória atual. Caso for menor, aloca a memória e volta para o início, após percorre toda a lista novamente, caso contrário, segue adiante.

#include<stdio.h>

int main()
{
int a[20],p[20],i,j,n,m;
printf("Entre o numero de blocos de memoria:\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("Entre o tamanho do bloco de memoria %d: ",i);
scanf("%d",&a[i]);
}
printf("Entre o numero de processos:\n");
scanf("%d",&m);
for(i=0;i<m;i++)
{
printf("Entre o tamanho do processo %d: ",i);
scanf("%d",&p[i]);
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
if(p[j]<=a[i]) {
printf("O processo %d esta alocado no bloco memoria %d\n",j,a[i]);
p[j]=10000;
break;
}
}
}
for(j=0;j<m;j++)
{
if(p[j]!=10000)
{
printf("O Processo %d nao esta alocado\n",j);
}
}
return 0;
}

best fit

Varre toda a memória e escolhe a página mais ajustada ao tamanho do processo.

#include <stdio.h>
#include <windows.h> 
 
int main(){  
   int p,m;  
   printf("Entre o numero de processos:");
   scanf("%d",&p);
   printf("Entre o numero de blocos de memoria:");
   scanf("%d",&m); 
 
   int parr[p];
   struct memoria{
          int id;  // identificador
          int tamanho;
   }marr[m];
 
   int i;
 
   for(i=0;i<p;i++)
   {
     printf("Entre o tamanho do processo %d:",i+1);
     scanf("%d",&parr[i]);      
   }
   for(i=0;i<m;i++)
   {
     printf("Entre o tamanho do bloco de memoria %d:",i+1);
     scanf("%d",&marr[i].tamanho);   
     marr[i].id=i+1;   
   }
   int j; 
   int tamanho = 0;
 
   for(i; tamanho <= marr[i].tamanho;  i++ )
           tamanho = marr[i].tamanho;
   int tamanho_velho = tamanho ;
    int im ;
    bool marcador = false ;
 
     for(i=0;i<p;i++){                  
       for(j=0;j<m;j++){
         if((marr[j].tamanho>=parr[i]) && (marr[j].tamanho < tamanho) ){
 
         im = j;
         tamanho = marr[j].tamanho;
         marcador = true ;
 
    }  
 
     }  
 
     if(marcador){
          marcador = false ;
          marr[im].tamanho-=parr[i];
           tamanho = tamanho_velho ;
              printf("\n\nAloca o processo %d no bloco memoria %d\n Tamanho restante apos alocar %d\n",i+1,marr[im].id,marr[im].tamanho); 
 
              }else {printf("Memoria insuficiente para o processo %d",i);break;} 
 
 
   }
  system ("pause");
 
          return 0;
}

worst fit

O algoritmo worst fit aloca o bloco de memória na região que tem o maior espaço livre.

Está técnica por procurar ocupar primeiro as partições maiores termina por deixar espaços livres que poderiam ser utilizados para que outros blocos de outros programas as utilizassem, diminuindo e/ou retardando a fragmentação.

<syntaxhighlight lang="c">

  1. include<stdio.h>
  2. include<stdlib.h>

typedef struct best_choice{ int start, end, total; }b_choice; void worst_fit(int *memory, int space, int total_space, b_choice *bc){ bool valid = false;//flag int size_bc=0;// variável usada para armazenar o tamanho do vetor bc, com os dados de onde começa cada lacuna int bigger = 0;// variável usada para armazenar o maior espaço encontrado for(int i=0; i<total_space; i++){//percorremos toda memória armazenando as lacunas livres if(memory[i]==0){ if(valid==false){ bc[size_bc].start = i;//armazenamos onde começa uma lacuna livre

} valid = true; } else{ if(valid==true){//armazenamos onde a lacuna livre termina bc[size_bc].end = i; bc[size_bc].total = bc[size_bc].end - bc[size_bc].start; size_bc++; } valid = false; } } valid = false; for(int i=0; i<size_bc; i++){//agora percorremos o vetor que possui os dados sobre as lacunas livres if(bc[i].total>=space){//procuramos pela maior lacuna if(bc[i].total>bigger){

bigger = bc[i].start;//caso o elemento atual seja maior, bigger recebe esse elemento valid = true; } } } if(valid==true){//se a flag é true, quer dizer que existe espaço para essa alocação printf("\nposição: %d\n", bigger); for(int i=bigger; i<(bigger+space); i++)//preenchemos as posições do vetor memória, dada a maior lacuna memory[i] = 1; printf("\n************Espaço alocado com SUCESSO**************\n"); } else//caso false, não existe espaço para esta alocação printf("\n************Espaço insuficiente**************\n"); } //AMNC

Next Fit

Buddy System

Esta página é um esboço de informática. Ampliando-a você ajudará a melhorar o Wikilivros.