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 165: Linha 165:
}
}
//AMNC
//AMNC
</syntaxhighlight>


==Next Fit==
==Next Fit==

Revisão das 03h36min de 20 de junho de 2017

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.

 
#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

Buddy System

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