Programar em C/Algoritmo de alocação
Aspeto
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]
Esta página é um esboço de informática. Ampliando-a você ajudará a melhorar o Wikilivros. |