Trabalho Gerencia de Memoria Swap

bielmaster
(usa Outra)

Enviado em 19/12/2018 - 12:07h

Galera estou fazendo um trabalho para a facul sobre gerencia de memoria swap, estou com dificuldade em 2 funções, quem puder ajudar agradeceria muito.

int gera_processo_e_inicia(queue_t** memoria_principal, queue_t** memoria_secundaria, int tamanho_bloco,

		int tamanho_max_memoria_secundaria, queue_t* func(queue_t*, int)) {



		queue_t* processo;

		processo.cria_no(tamanho_bloco, 1);



		queue_t* no = func(no, tamanho_bloco);



		if (!no) {

			//swap

		} else {



		}

}



// ideia é trazer um processo da memoria secundaria para executar, muda processo de um lado para o outro, não tem retorno.



/**

 * - simula a execução de um processo que estava na memória secundaria

 *   + traz o próximo processo da memória secundária

 *   + localiza o próximo espaço disponível, utilizando a estratégia passada como parâmetro

 *   + se não tiver espaço disponível, realiza swap do primeiro bloco grande o bastante para alocação

 * - Caso o bloco livre seja maior que o novo processo, deve-se fazer o ajuste do espaço disponível,

 *   eventualmente aglutinando áreas livres

 *

 * PARÂMETROS:

 *   - Ponteiro de ponteiro para memória principal

 *   - Ponteiro de ponteiro para memória secundária

 *   - Função com estratégia recuperação de espaço disponível (first-fit, best-fit e worst-fit)

 *

 */



void executa_proximo_processo_memoria_secundaria(queue_t** memoria_principal, queue_t** memoria_secundaria, queue_t* func(queue_t*, int)) {



}



/**

 * - localiza o próximo bloco utilizado na memória principal e o libera

 * - Realiza a devida aglutinação de memória nos espaços livres

 * RETORNA:

 *    - 1 se conseguiu remover

 *    - 0 se ocorreu algum problema caso o processo não esteja na memória principal

 */



int remove_processo_memoria_principal(queue_t** memoria_principal, queue_t* processo_memoria) {



}



/**

 * Procura na fila um espaço disponível para reserva a fim de comportar o bloco passado como parâmetro.

 * Faz uso do algoritmo worst_fit.

 *

 * RETORNO:

 * 	- ponteiro para o bloco de memória disponível

 * 	- NULL caso nenhum bloco disponível comporte a reserva

 *

 *

 */



 queue_t* worst_fit(queue_t* fila, int tamanho_bloco)

{

	queue_t* atual = fila;

	queue_t* maior = cria_no(0, 0);



	while(atual->prox) {

		if (atual->qtd_memoria > maior->qtd_memoria && atual->qtd_memoria >= tamanho_bloco && !atual->usado) {

			maior = atual;

		}

		atual = atual->prox;

	}



	if (!maior->qtd_memoria) {

		return NULL;

	}



	return maior;

}



/**

 * Procura na fila um espaço disponível para reserva a fim de comportar o bloco passado como parâmetro.

 * Faz uso do algoritmo first_fit.

 *

 * RETORNO:

 * 	- ponteiro para o bloco de memória disponível

 * 	- NULL caso nenhum bloco disponível comporte a reserva

 *

 *

 */



queue_t* first_fit(queue_t* fila, int tamanho_bloco)

{

	queue_t* atual = fila;

	queue_t* primeiro;



	while(atual->prox) {

		if (atual->qtd_memoria >= tamanho_bloco && !atual->usado) {

			primeiro = atual;

			break;

		}

		atual = atual->prox;

	}



	if (!primeiro->qtd_memoria) {

		return NULL;

	}



	return primeiro;

}



/**

 * Procura na fila um espaço disponível para reserva a fim de comportar o bloco passado como parâmetro.

 * Faz uso do algoritmo best_fit.

 *

 * RETORNO:

 * 	- ponteiro para o bloco de memória disponível

 * 	- NULL caso nenhum bloco disponível comporte a reserva

 *

 *

 */



queue_t* best_fit(queue_t* fila, int tamanho_bloco)

{

	queue_t* atual = fila;

	queue_t* melhor = worst_fit(fila, tamanho_bloco);



	while(atual->prox) {

		if (atual->qtd_memoria >= tamanho_bloco && !atual->usado) {

			if (atual->qtd_memoria < melhor->qtd_memoria) {

				melhor = atual;

			}

		}

		atual = atual->prox;

	}



	if (!melhor->qtd_memoria) {

		return NULL;

	}



	return melhor;

}