Simulador Algoritmo de Escalonamento de Processos

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

#include<stdio.h>
#include <iostream> //Bibliotecas
#include <stdlib.h>
#define MaxTam 5 //Difine o numero de processos
using namespace std;
struct processos{ //Registro ou struct para armazenar os dados dos processos
	int chegada;
	int execucao;
	int id;
	int espera;
	int turnaround;
};
struct processoscp{ //Registro ou struct para copiar os dados dos processos
	int chegada;
	int execucao;
	int id;
};
//Protótipos
void FIFO(processos *proc); 
void SJF(processos *proc);
void ExibirFIFO(processoscp *proc, processos *pro);
void ExibirSJF(processoscp *proc, processos *pro);
//Programa Principal
int main()
{
	processos *proc; //Variável para armazenar os processos (do tipo ponteiro) 
	processoscp *procpy; //Variável para armazenar as cópias dos processos (do tipo ponteiro)
	int select; //Variavel para armazenar a seleção do usuário
	
	proc = (processos*)calloc(MaxTam,sizeof(processos)); //Alocação dinâmica das variavéis
	procpy = (processoscp*)calloc(MaxTam,sizeof(processoscp)); //Alocação dinâmica das variavéis
	
	//Entrada de dados
	for (int i=0; i<MaxTam; i++)
	{
		printf("\t\t********** PROCESSO %d *************\n",i+1);
		printf("\t\t Informe o instante de chegada: ");
		do{
			scanf("%d",&(proc+i)->chegada);
		}while ((proc+i)->chegada<0);
		
		(procpy+i)->chegada = (proc+i)->chegada;
		
		printf("\t\t Informe o tempo de execucao: ",i+1);
		do{
			scanf("%d",&(proc+i)->execucao);
		}while ((proc+i)->execucao<1);
		
		(procpy+i)->execucao = (proc+i)->execucao;
		
		(proc+i)->id = i;
		(procpy+i)->id = (proc+i)->id;
		system("cls");
	}
	
	//Verificação da opção que o usuário digitar
	printf("\t\t*******SELECIONE UMA DAS OPCOES:*******\n\n \t\t\t 1- FIFO | 2- SJF: ");
	do{
		scanf("%d",&select);
	}while (select<1 || select>2);
	
	if (select == 1){
		//Chamada FIFO
		FIFO(proc);
		ExibirFIFO(procpy,proc);
	}
	
	else{
		//Chamada SJF
		SJF(proc);
		ExibirSJF(procpy,proc);
	}
	printf("\n");	
	system("pause");
}
void FIFO(processos *proc){ //Procedimento para o algoritmo FIFO
	
	int temp=0,temp2=0;
	
	for (int x=0; x<MaxTam-1; x++) //Algoritmo para enfilerar os processos por ordem de chegada
	{
		for (int y=x+1; y<MaxTam; y++)
		{
			if ((proc+x)->chegada > (proc+y)->chegada){
								
				temp2 = (proc+x)->execucao;
				(proc+x)->execucao = (proc+y)->execucao;
				(proc+y)->execucao = temp2;	
								
				temp = (proc+x)->chegada;
				(proc+x)->chegada = (proc+y)->chegada;
				(proc+y)->chegada = temp;
							
			}
		}		
	}
	
	//Abribuição do tempo de espera e do turnaround para o processo que chegou primeiro
	(proc+0)->espera = 0;
	(proc+0)->turnaround = (proc+0)->espera + (proc+0)->execucao;
	
	//Abribuição do tempo de espera e do turnaround para os demais processos 
	for (int i=1; i<MaxTam; i++){
		(proc+i)->espera = (proc+(i-1))->turnaround - (proc+i)->chegada + (proc+(i-1))->chegada;
		(proc+i)->turnaround = (proc+i)->espera + (proc+i)->execucao;
	}
}
//Procedimento SJF 
void SJF(processos *proc){
	
	int temp=0,temp2=0, aux=0, aux2=0;
	
	
	if ((proc+0)->chegada < (proc+1)->chegada && (proc+0)->chegada < (proc+2)->chegada &&
		(proc+0)->chegada < (proc+3)->chegada && (proc+0)->chegada < (proc+4)->chegada)
	{
		(proc+0)->chegada = (proc+0)->chegada;
		(proc+0)->execucao = (proc+0)->execucao;
		
	}
	else if ((proc+1)->chegada < (proc+2)->chegada && (proc+1)->chegada < (proc+3)->chegada &&
			 (proc+1)->chegada < (proc+0)->chegada && (proc+1)->chegada < (proc+4)->chegada)
	{
		aux = (proc+0)->chegada;
		(proc+0)->chegada = (proc+1)->chegada;
		(proc+1)->chegada = aux;
		aux2 = (proc+0)->execucao;
		(proc+0)->execucao = (proc+1)->execucao;
		(proc+1)->execucao = aux2;
		
	}
	else if ((proc+2)->chegada < (proc+3)->chegada && (proc+2)->chegada < (proc+4)->chegada &&
			 (proc+2)->chegada < (proc+0)->chegada && (proc+2)->chegada < (proc+1)->chegada)
	{
		aux = (proc+0)->chegada;
		(proc+0)->chegada = (proc+2)->chegada;
		(proc+2)->chegada = aux;
		aux2 = (proc+0)->execucao;
		(proc+0)->execucao = (proc+2)->execucao;
		(proc+2)->execucao = aux2;
	}
	
	else if ((proc+3)->chegada < (proc+4)->chegada && (proc+3)->chegada < (proc+0)->chegada &&
			 (proc+3)->chegada < (proc+1)->chegada && (proc+3)->chegada < (proc+2)->chegada)
	{
		aux = (proc+0)->chegada;
		(proc+0)->chegada = (proc+3)->chegada;
		(proc+3)->chegada = aux;
		aux2 = (proc+0)->execucao;
		(proc+0)->execucao = (proc+3)->execucao;
		(proc+3)->execucao = aux2;
	}
	else if ((proc+4)->chegada < (proc+0)->chegada && (proc+4)->chegada < (proc+1)->chegada &&
		 	 (proc+4)->chegada < (proc+2)->chegada && (proc+4)->chegada< (proc+3)->chegada)
	{
		aux = (proc+0)->chegada;
		(proc+0)->chegada = (proc+4)->chegada;
		(proc+4)->chegada = aux;
		aux2 = (proc+0)->execucao;
		(proc+0)->execucao = (proc+4)->execucao;
		(proc+4)->execucao = aux2;
	}
	
	for (int x=1; x<MaxTam-1; x++)
	{
		for (int y=x+1; y<MaxTam; y++)
		{
			if ((proc+x)->execucao > (proc+y)->execucao){
				
				temp2 = (proc+x)->execucao;
				(proc+x)->execucao = (proc+y)->execucao;
				(proc+y)->execucao = temp2;
								
				temp = (proc+x)->chegada;
				(proc+x)->chegada = (proc+y)->chegada;
				(proc+y)->chegada = temp;
												
			}
		}		
	}
	
	(proc+0)->espera = 0;
	(proc+0)->turnaround = (proc+0)->espera + (proc+0)->execucao;
	
	for (int i=1; i<MaxTam; i++){
		(proc+i)->espera = (proc+(i-1))->turnaround - (proc+i)->chegada + (proc+(i-1))->chegada;
		(proc+i)->turnaround = (proc+i)->espera + (proc+i)->execucao;
	}
}
//Procedimento para exibir o FIFO
void ExibirFIFO(processoscp *proc, processos *pro){
	
	//Comparação dos processos. 
	/*	Pelo fato de ter ordenado os processos pela ordem de chegada, as posições dos vetores
		são alteradas. Então foi necessário a implementação deste para verificar qual era
		o verdadeiro numero do processo
	*/
	system("cls");
	printf("\n\n\n\n\n\n\n *************************** Algoritmo FIFO ******************************\n\n");
	for (int i=0; i<MaxTam; i++){
	
		
		if ((pro+i)->chegada == (proc+0)->chegada && (pro+i)->execucao == (proc+0)->execucao)
		{
			(pro+i)->id = (proc+0)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
		break;	
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+1)->chegada && (pro+i)->execucao == (proc+1)->execucao)
		{
			(pro+i)->id = (proc+1)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
		break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+2)->chegada && (pro+i)->execucao == (proc+2)->execucao)
		{
			(pro+i)->id = (proc+2)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+3)->chegada && (pro+i)->execucao == (proc+3)->execucao)
		{
			(pro+i)->id = (proc+3)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+4)->chegada && (pro+i)->execucao == (proc+4)->execucao)
		{
			(pro+i)->id = (proc+4)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	}
	
	printf("\n ********************************************************************");
}
//Procedimento para
exibir SJF 
void ExibirSJF(processoscp *proc, processos *pro){
		
	system("cls");
	printf("\n\n\n\n\n\n\n *************************** Algoritmo SJF ******************************\n\n");
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+0)->chegada && (pro+i)->execucao == (proc+0)->execucao)
		{
			(pro+i)->id = (proc+0)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
		break;	
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+1)->chegada && (pro+i)->execucao == (proc+1)->execucao)
		{
			(pro+i)->id = (proc+1)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
		break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+2)->chegada && (pro+i)->execucao == (proc+2)->execucao)
		{
			(pro+i)->id = (proc+2)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+3)->chegada && (pro+i)->execucao == (proc+3)->execucao)
		{
			(pro+i)->id = (proc+3)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	
	}
	
	for (int i=0; i<MaxTam; i++){
		
		if ((pro+i)->chegada == (proc+4)->chegada && (pro+i)->execucao == (proc+4)->execucao)
		{
			(pro+i)->id = (proc+4)->id;
			printf("Processo: %d\tChegada: %d\tExecucao: %d\tEspera: %d\tTurnaround: %d\n", 
			(pro+i)->id+1, (pro+i)->chegada, (pro+i)->execucao, (pro+i)->espera,(pro+i)->turnaround);
			break;
		}
	}
	
	printf("\n ********************************************************************");
}