int main(int argc, char **argv) {
int i;
int *arg;
pthread_mutex_init(&mutex, NULL);
pthread_t threads[NUM_PROC];
//==============================
memoria = AreaDeMemoria(TAM_MEM);
PreencheMemoria(memoria);
memProcessos = InicializaMemoria();
//==============================
//
for(i = 0; i < NUM_PROC; i++) {
arg = malloc(sizeof(int));
*arg = i;
if(pthread_create(&threads[i], NULL, processo, (void*)arg)) {
printf("Erro ao criar as threads.\n");
exit(-1);
}
sleep(3);
}
for(i = 0; i < NUM_PROC; i++) {
if(pthread_join(threads[i], NULL)) {
printf("Erro no join das threads.\n");
exit(-1);
}
}
//ImprimeMemoria(memoria, TAM_MEM);
//imprimeMem(&memProcessos);
ImprimeMemoriaProcessos(&memProcessos);
free(arg); free(memoria);
pthread_mutex_destroy(&mutex);
pthread_exit(NULL);
}
int main (void)
{
int qtdprocessos, met;
FILE* out = fopen("saida.txt","w");
int i, j, fail = 0, cnt = 0, tamProntos, tamIO, tamIO2, seg = 0, inxExec, inxIO;
Processo *aux, *procExec, *procIO, *procRetirado;
LIS_tppLista listaIO = LIS_CriarLista();
LIS_tppLista listaProntos = LIS_CriarLista();
Memory * mem = (Memory*)malloc(sizeof(Memory));
FILE* fp = fopen("entrada.txt", "r");
Processo *vp = (Processo*)malloc(100*sizeof(Processo));
qtdprocessos = lerEntrada(&fp, vp);
imprimeVetor(vp, qtdprocessos);
InicializaMemoria(mem);
procExec = NULL;
// Insere os elementos lidos numa lista de prontos
for(i = 0; i < qtdprocessos; i++)
{
LIS_InserirElementoApos(listaProntos, &vp[i]);
LIS_AvancarElementoCorrente(listaProntos, 1);
vp[i].segAtual = -1;
vp[i].naMemoria = 0;
vp[i].t_exec = 0;
vp[i].t_io = 0;
}
printf("1: First Fit \n");
printf("2: Best Fit \n");
printf("3: Worst Fit \n");
printf("4: Next Fit \n");
scanf("%d", &met);
EXEC:
IrInicioLista(listaProntos); // vai pro inicio da lista de prontos
aux = (Processo*)LIS_ObterValor(listaProntos);
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
/* * * * * * * * * * * * * * * * * * * * * * */
// executar o processo
IrInicioLista(listaProntos);
tamProntos = LIS_ObterTamanho(listaProntos);
tamIO = LIS_ObterTamanho(listaIO);
aux = (Processo*)LIS_ObterValor(listaProntos); // obtem o priemeiro elemento da lista de prontos
while(tamProntos > 0)
{
if(!aux->naMemoria) // se o processo não esta em memoria
{
LIS_AvancarElementoCorrente(listaProntos, 1);
aux = (Processo*)LIS_ObterValor(listaProntos);
continue;
}
procExec = aux;
for(i = 0; i < 10; i++) // os 10 clocks de cpu
{
ImprimirEstado(&out, listaIO, procExec, mem, tempoTotal);
clock(1); tempoTotal++;
inxExec = procExec->t_exec;
procExec->exec[inxExec]--;
tamIO = LIS_ObterTamanho(listaIO);
IrInicioLista(listaIO);
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO2 = LIS_ObterTamanho(listaIO);
if(tamIO != tamIO2)
{
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
}
getNext(listaProntos);
if(procExec->exec[inxExec] == 0 || i == 9) // se o seu tempo de exec terminou entao retira da memoria
{
/* * * * * */ //imprimeMemoria(mem);
LIS_ExcluirElemento(listaProntos);
if(procExec->exec[inxExec] == 0) procExec->t_exec++; // se acabou um exec inteiro
if(procExec->exec[inxExec] == 0 && procExec->t_io < procExec->qtdio) // se o processo terminou um exec e ainda tem io para fazer
{
IrFinalLista(listaIO);
LIS_InserirElementoApos(listaIO, procExec);
}
// retira da memoria
// se o processo ainda tem exec para fazer
if(procExec->exec[inxExec] > 0)
{
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procExec);
}
seg = procExec->segAtual;
procRetirado = RetiraProcessoMem(mem, seg);
procRetirado->naMemoria = 0;
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
} /* final dos 10 clocks*/
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
IrInicioLista(listaProntos);
aux = (Processo*)LIS_ObterValor(listaProntos);
}
tamIO = LIS_ObterTamanho(listaIO);
while(tamIO > 0) // entao tem IO sobrando e ngm para executar
{
IrInicioLista(listaIO);
clock(1);tempoTotal++;
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO = LIS_ObterTamanho(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
if(tamProntos > 0) // se alguem voltou par a lista de prontos...
goto EXEC;
}
fclose(out);
free(mem);
free(vp);
free(listaProntos);
free(listaIO);
return 0;
}
Compilador::Compilador(){
InicializaMemoria();
InicializaCubo();
cuadruplos.open ("cuadruplos.txt");
contFunciones = 0;
}
