Programar em C/Algoritmo de alocação

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

first fit[editar | editar código-fonte]

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[editar | editar código-fonte]

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[editar | editar código-fonte]

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.

 
#include<stdio.h>
#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[editar | editar código-fonte]

Buddy System[editar | editar código-fonte]

Nuvola apps konsole.png

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