Matheus Silverio Oliveira RA: 11201720810

Jonnathas Henrique Ludovico Carvalho RA: 11123915

MCTA026 – Sistemas operacionais

Profs. Joao Marcelo Borovina Josko

Questão 1

Realizando uma reflexão a respeito das diferenças do sistema baseado nos

códigos apresentados a seguir utilizando a tecnica proporcional e a técnica de
equidade e em suas saídas, fica evidente que na primeira (Proporcional)
ponderamos a disponibilização dos recursos utilizando o tamanho do processo
como critério e disponibilizamos mais recursos para processos maiores, enquanto
na segunda (equidade) não existe nenhum um tipo de priorização e os recursos são
distribuídos igualitariamente como o próprio nome da técnica sugere.

Uma vantagem da técnica proporcional ao tamanho é que ela permite uma

utilização mais eficiente da memória, pois alocar mais frames para processos
maiores pode reduzir a fragmentação de memória e aumentar a chance de que um
processo possa executar sem precisar fazer swap frequentemente. Como
desvantagem essa técnica pode sofrer com uma sobrecarga de processos maiores,
o que pode prejudicar o desempenho do sistema se muitos processos grandes
estiverem sendo executados ao mesmo tempo.

A técnica de equidade pode ser vantajosa em ambientes onde a priorização

de processos é importante. Como os frames são alocados de forma igualitária entre
todos os processos, nenhum processo terá uma vantagem em termos de recursos
de memória, o que pode ser importante em sistemas com muitos usuários ou onde a
estabilidade é um fator crítico. Ao mesmo tempo que distribuir os recursos
igualitariamente gera fragmentação da memória e necessidade de mais swaps em
processos grandes.

Por fim, pensando que o objetivo principal da empresa seria minorar as

operações de page in e page out (swaps), o sistema com técnica de alocação
proporcional inicialmente se mostra melhor para esta finalidade, pela priorização dos
processos maiores disponibilizando mais recursos.
Matheus Silverio Oliveira RA: 11201720810
Jonnathas Henrique Ludovico Carvalho RA: 11123915

Códigos:

EQUIDADE:

#include <stdio.h>
#include <stdlib.h>

#define NUMBER_OF_FRAMES 64
#define NUMBER_OF_PROCESSES 4

int frames[NUMBER_OF_FRAMES];

// Função para alocar um frame para um processo

int allocate_frame(int process_number, int page_number) {
int i, frame_number;

// Procura por um frame livre

for (i = 0; i < NUMBER_OF_FRAMES; i++) {
if (frames[i] == -1) {
// Encontrou um frame livre, aloca para o processo em
questão
frames[i] = process_number;
return i;
}
}

// Não encontrou nenhum frame livre, retorna -1

return -1;
}

// Função para liberar um frame usado por um processo

void free_frame(int frame_number) {
frames[frame_number] = -1;
}

int main() {
int i, j, time, process_number, page_number, frame_number;

// Inicializa todos os frames como livres

for (i = 0; i < NUMBER_OF_FRAMES; i++) {
frames[i] = -1;
}
Matheus Silverio Oliveira RA: 11201720810
Jonnathas Henrique Ludovico Carvalho RA: 11123915

// Matriz de 25 linhas e 3 colunas que indica as requisições de

páginas de cada processo
int page_requests[25][3] = {
{1, 3, 50}, {2, 3, 51}, {3, 2, 17}, {4, 2, 18}, {5, 1, 6},
{6, 4, 15}, {7, 4, 16}, {8, 2, 1}, {9, 4, 17}, {10, 3, 2},
{11, 3, 3}, {12, 1, 7}, {13, 2, 2}, {14, 4, 18}, {15, 2, 31},
{16, 2, 32}, {17, 2, 33}, {18, 4, 2}, {19, 4, 3}, {20, 3, 16},
{21, 3, 17}, {22, 1, 15}, {23, 1, 16}, {24, 4, 19}, {25, 2, 20}
};

// Itera pelas requisições de páginas

for (i = 0; i < 25; i++) {
time = page_requests[i][0];
process_number = page_requests[i][1];
page_number = page_requests[i][2];

// Verifica se o processo já está alocado em algum frame

frame_number = -1;
for (j = 0; j < NUMBER_OF_FRAMES; j++) {
if (frames[j] == process_number) {
frame_number = j;
break;
}
}

// Se o processo já está alocado, basta acessar a página

requisitada
if (frame_number != -1) {
printf("Tempo %d: Processo %d pagina acessada %d (frame
%d)\n", time, process_number, page_number, frame_number);
} else {
// O processo não está alocado, então é preciso alocar um
frame
frame_number = allocate_frame(process_number, page_number);
if (frame_number == -1) {
// Não foi possível alocar um frame para o processo,
imprime mensagem de erro
printf("Tempo %d: ERRO: NAO existem frames livres para o
processo %d!\n", time, process_number);
} else {
printf("Tempo %d: Processo %d Frame alocado %d para
pagina %d\n", time, process_number, frame_number, page_number);
}
Matheus Silverio Oliveira RA: 11201720810
Jonnathas Henrique Ludovico Carvalho RA: 11123915

}
}

return 0;
}

SAÍDAS:

PROPORCIONAL AO TAMANHO:

#include <stdio.h>
#include <stdlib.h>

#define NUM_FRAMES 64
#define NUM_PROCESSES 4

int main() {
int process_sizes[NUM_PROCESSES] = {16, 128, 64, 48}; // tamanhos
dos processos
int num_frames_allocated[NUM_PROCESSES] = {0}; // número de frames
alocados para cada processo
int frames[NUM_FRAMES] = {0}; // indicação de quais frames estão
alocados

// matriz com as requisições de alocação de frames

int allocation_requests[25][3] = {
Matheus Silverio Oliveira RA: 11201720810
Jonnathas Henrique Ludovico Carvalho RA: 11123915

{1, 3, 50}, {2, 3, 51}, {3, 2, 17}, {4, 2, 18}, {5, 1, 6},
{6, 4, 15}, {7, 4, 16}, {8, 2, 1}, {9, 4, 17}, {10, 3, 2},
{11, 3, 3}, {12, 1, 7}, {13, 2, 2}, {14, 4, 18}, {15, 2, 31},
{16, 2, 32}, {17, 2, 33}, {18, 4, 2}, {19, 4, 3}, {20, 3, 16},
{21, 3, 17}, {22, 1, 15}, {23, 1, 16}, {24, 4, 19}, {25, 2, 20}
};

// processamento das requisições

for (int i = 0; i < 25; i++) {
int timestamp = allocation_requests[i][0];
int process_id = allocation_requests[i][1] - 1; // o processo é
indexado a partir de 1
int page_num = allocation_requests[i][2];

// cálculo da proporção de frames alocados para cada processo

int total_size = 0;
for (int j = 0; j < NUM_PROCESSES; j++) {
total_size += process_sizes[j];
}
float proportions[NUM_PROCESSES];
for (int j = 0; j < NUM_PROCESSES; j++) {
proportions[j] = (float) process_sizes[j] / (float)
total_size;
}

// alocação de frames proporcional ao tamanho

int num_frames_requested = 1; // cada requisição aloca apenas um
frame
int num_frames_available = NUM_FRAMES - i; // número de frames
disponíveis na iteração atual
int num_frames_to_allocate = (int) (proportions[process_id] *
num_frames_available);
if (num_frames_allocated[process_id] + num_frames_to_allocate >
process_sizes[process_id]) {
num_frames_to_allocate = process_sizes[process_id] -
num_frames_allocated[process_id];
}
num_frames_allocated[process_id] += num_frames_to_allocate;
for (int j = 0; j < num_frames_to_allocate; j++) {
for (int k = 0; k < NUM_FRAMES; k++) {
if (frames[k] == 0) {
frames[k] = process_id + 1; // marca o frame como
alocado para o processo correspondente
Matheus Silverio Oliveira RA: 11201720810
Jonnathas Henrique Ludovico Carvalho RA: 11123915

break;
}
}
}

// impressão do estado atual da alocação de frames

printf("Tempo %d: ", timestamp);
printf("Processo %d alocou %d frames para a página %d\n",
process_id + 1, num_frames_to_allocate, page_num);
}

return 0;
}

SAÍDAS: