tipoRespuesta* ejecutarInstruccion(tipoInstruccion* instruccion,t_list* listaDeHuecosOcupados, t_list* listaDeHuecosLibres, tipoConfigSWAP* configuracion){
tipoRespuesta* respuesta;
switch (instruccion->instruccion) {
case INICIAR:
respuesta = reservarEspacio(listaDeHuecosOcupados,listaDeHuecosLibres,instruccion->pid,instruccion->nroPagina,configuracion->cantidadDePaginas,configuracion->tamanioDePagina,configuracion->nombreDeSWAP);
break;
case LEER:
respuesta = leerPagina(listaDeHuecosOcupados,instruccion->pid,instruccion->nroPagina,configuracion->tamanioDePagina,configuracion->nombreDeSWAP);
break;
case ESCRIBIR:
respuesta = escribirPagina(listaDeHuecosOcupados,instruccion->pid,instruccion->texto,instruccion->nroPagina,configuracion->tamanioDePagina,configuracion->nombreDeSWAP);
break;
case FINALIZAR:
respuesta = liberarEspacio(listaDeHuecosOcupados,listaDeHuecosLibres,instruccion->pid);
break;
}
return respuesta;
}
tipoRespuesta* ejecutarInstruccion(tipoInstruccion* instruccion,t_list* listaDeHuecosUtilizados,t_list* listaDeHuecosLibres,tipoConfigSWAP* configuracion, t_log* logger, bool* finalizarProceso){
tipoRespuesta* respuesta;
switch (instruccion->instruccion) {
case INICIAR:
respuesta = reservarEspacio(listaDeHuecosUtilizados,listaDeHuecosLibres,instruccion->pid,instruccion->nroPagina,configuracion->cantidadDePaginas,configuracion->tamanioDePagina,configuracion->nombreDeSWAP,configuracion->retardoDeCompactacion, logger);
break;
case LEER:
respuesta = leerPagina(listaDeHuecosUtilizados,instruccion->pid,instruccion->nroPagina,configuracion->tamanioDePagina,configuracion->nombreDeSWAP, logger,configuracion->retardoDeSWAP);
break;
case ESCRIBIR:
respuesta = escribirPagina(listaDeHuecosUtilizados,instruccion->pid,instruccion->texto,instruccion->nroPagina,configuracion->tamanioDePagina,configuracion->nombreDeSWAP, logger,configuracion->retardoDeSWAP);
break;
case FINALIZAR:
respuesta = liberarEspacio(listaDeHuecosUtilizados,listaDeHuecosLibres,instruccion->pid, configuracion->tamanioDePagina, logger,configuracion->nombreDeSWAP);
break;
case FINALIZAR_PROCESO:
respuesta = finalizarProcesoSWAP(finalizarProceso);
break;
}
return respuesta;
}
void recibir_operaciones_memoria(sock_t* socketMemoria) {
int32_t finalizar = true;
int32_t recibido;
char* pedido_serializado;
header_t* header = _create_empty_header();
while(finalizar) {
recibido = _receive_header(socketMemoria, header);
if(recibido == ERROR_OPERATION) return;
if(recibido == SOCKET_CLOSED) {
socketMemoria = accept_connection(socketServidor);
//set_operation_code(header, 5);
header->cod_op=5;
}
switch(get_operation_code(header)) {
case LEER_PAGINA: {
pedido_serializado = malloc(get_message_size(header));
recibido = _receive_bytes(socketMemoria, pedido_serializado, get_message_size(header));
if(recibido == ERROR_OPERATION) return;
t_pagina* pagina_pedida = deserializar_pedido(pedido_serializado);
leer_pagina(pagina_pedida);
sleep(arch->retardo);
header_t* headerMemoria = _create_header(RESULTADO_OK, sizeof(int32_t)+pagina_pedida->tamanio_contenido);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
enviado=_send_bytes(socketMemoria, &pagina_pedida->tamanio_contenido, sizeof(int32_t));
enviado=_send_bytes(socketMemoria, pagina_pedida->contenido, pagina_pedida->tamanio_contenido);
log_debug(loggerDebug, "Se leyeron :%d bytes", pagina_pedida->tamanio_contenido);
if(enviado == ERROR_OPERATION) return;
free(pagina_pedida->contenido);
free(pagina_pedida);
free(pedido_serializado);
free(headerMemoria);
break;
}
case ESCRIBIR_PAGINA: {
pedido_serializado = malloc(get_message_size(header));
recibido = _receive_bytes(socketMemoria, pedido_serializado, get_message_size(header));
if(recibido == ERROR_OPERATION) return;
t_pagina* pagina_pedida = deserializar_pedido(pedido_serializado);
log_debug(loggerDebug, "Me llega a escribir pid: %d, pagina:%d, tam:%d, contenido:%s", pagina_pedida->PID, pagina_pedida->nro_pagina, pagina_pedida->tamanio_contenido, pagina_pedida->contenido);
int32_t resultado= escribir_pagina(pagina_pedida);
sleep(arch->retardo);
if (resultado == RESULTADO_ERROR) {
header_t* headerMemoria = _create_header(RESULTADO_ERROR, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
free(headerMemoria);
return;
} else if (resultado == RESULTADO_OK) {
header_t* headerMemoria = _create_header(RESULTADO_OK, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
free(headerMemoria);
}
free(pedido_serializado);
free(pagina_pedida);
break;
}
case RESERVAR_ESPACIO: {
t_pedido_memoria* pedido_memoria = malloc(sizeof(t_pedido_memoria));
recibido = _receive_bytes(socketMemoria, &(pedido_memoria->pid), sizeof(int32_t));
if (recibido == ERROR_OPERATION)return;
recibido = _receive_bytes(socketMemoria, &(pedido_memoria->cantidad_paginas),sizeof(int32_t));
if (recibido == ERROR_OPERATION)return;
log_debug(loggerDebug, "Recibi este pedido: %d y cant paginas %d", pedido_memoria->pid, pedido_memoria->cantidad_paginas);
int32_t operacionValida= reservarEspacio(pedido_memoria);
sleep(arch->retardo);
if (operacionValida == RESULTADO_ERROR) {
header_t* headerMemoria = _create_header(RESULTADO_ERROR, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
log_debug(loggerDebug, "No se reservo el espacio solicitado");
free(headerMemoria);
} else if (operacionValida == RESULTADO_OK) {
header_t* headerMemoria = _create_header(RESULTADO_OK, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
log_info(loggerInfo, ANSI_COLOR_GREEN"Se reservo el espacio solicitado" ANSI_COLOR_RESET);
free(headerMemoria);
}
break;
}
case BORRAR_ESPACIO: {
int32_t PID;
recibido = _receive_bytes(socketMemoria, &(PID), sizeof(int32_t));
if (recibido == ERROR_OPERATION)return;
int32_t operacionValida= borrarEspacio(PID);
sleep(arch->retardo);
if (operacionValida == RESULTADO_ERROR) {
header_t* headerMemoria = _create_header(RESULTADO_ERROR, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
log_debug(loggerDebug, "Finalizado erroneo");
free(headerMemoria);
return;
} else if (operacionValida == RESULTADO_OK) {
header_t* headerMemoria = _create_header(RESULTADO_OK, 0);
int32_t enviado = _send_header(socketMemoria, headerMemoria);
if(enviado == ERROR_OPERATION) return;
log_debug(loggerDebug, "Finalizado correcto, se envia:%d", RESULTADO_OK);
free(headerMemoria);
}
break;
}
case RECONEXION : {
log_info(loggerInfo, ANSI_COLOR_BOLDYELLOW "Se conecto una nueva instancia de la memoria" ANSI_COLOR_RESET);
break;
}
default: {
log_error(loggerError, ANSI_COLOR_BOLDRED "Se recibió un codigo de operación no valido"ANSI_COLOR_RESET);
}
}
}
free(header);
}
//Aplicamos todos los algoritmos a todos los archivos
void TodosArchivos(){
int n, costo=0;
int nficheros=20;
char *nombres[nficheros];
double tiempo;
DarNombres(nombres);
int finales[nficheros][5];
float tiempos[nficheros][5];
int tamanio[nficheros];
int resultadosoptimos[nficheros];
resultadosoptimos[0]=2192;
resultadosoptimos[1]=14142;
resultadosoptimos[2]=6194;
resultadosoptimos[3]=3796;
resultadosoptimos[4]=130;
resultadosoptimos[5]=116;
resultadosoptimos[6]=64;
resultadosoptimos[7]=88700;
resultadosoptimos[8]=360630;
resultadosoptimos[9]=15812;
resultadosoptimos[10]=23386;
resultadosoptimos[11]=90998;
resultadosoptimos[12]=115534;
resultadosoptimos[13]=140691;
resultadosoptimos[14]=1855928;
resultadosoptimos[15]=13499184;
resultadosoptimos[16]=15844731;
resultadosoptimos[17]=441786736;
resultadosoptimos[18]=43849646;
resultadosoptimos[19]=7620628;
double desviacion_total[5];
double desviaciones[nficheros][5];
for (int i=0; i<nficheros; i++){
n = leerNumeroDatos(nombres[i]);
reservarEspacio(n);
obtenerMatrices(nombres[i], mat1, mat2);
tamanio[i]=n;
//Aplico Greedy
start_timers();
alg_Greedy(n, mat1, mat2, sol, &costo);
tiempo = elapsed_time();
finales[i][0]=costo;
tiempos[i][0]=tiempo;
desviaciones[i][0]=(finales[i][0] - resultadosoptimos[i])*10;
desviaciones[i][0] = desviaciones[i][0]/resultadosoptimos[i];
desviaciones[i][0] = desviaciones[i][0]*10;
//Aplico AGG posicional
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo,0,0);
tiempo = elapsed_time();
finales[i][1]=costo;
tiempos[i][1]=tiempo;
desviaciones[i][1]=(finales[i][1] - resultadosoptimos[i])*10;
desviaciones[i][1] = desviaciones[i][1]/resultadosoptimos[i];
desviaciones[i][1] = desviaciones[i][1]*10;
alg_Greedy(n, mat1, mat2, sol, &costo);
//Aplico AGG posicional
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo,0,1);
tiempo = elapsed_time();
finales[i][2]=costo;
tiempos[i][2]=tiempo;
desviaciones[i][2]=(finales[i][2] - resultadosoptimos[i])*10;
desviaciones[i][2] = desviaciones[i][2]/resultadosoptimos[i];
desviaciones[i][2] = desviaciones[i][2]*10;
alg_Greedy(n, mat1, mat2, sol, &costo);
//Aplico AGG posicional
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo,0,2);
tiempo = elapsed_time();
finales[i][3]=costo;
tiempos[i][3]=tiempo;
desviaciones[i][3]=(finales[i][3] - resultadosoptimos[i])*10;
desviaciones[i][3] = desviaciones[i][3]/resultadosoptimos[i];
desviaciones[i][3] = desviaciones[i][3]*10;
}
int cont1=0,cont2=0,cont3=0,cont4=0, cont5=0;
for (int i=0; i<nficheros; i++){
int mejor=0;
if (finales[i][mejor]>=finales[i][1])
mejor=1;
if (finales[i][mejor]>=finales[i][2])
mejor=2;
if (finales[i][mejor]>=finales[i][3])
mejor=3;
if (mejor == 0) cont1++;
if (mejor == 1) cont2++;
if (mejor == 2) cont3++;
if (mejor == 3) cont4++;
printf("Problema: %s con n: %d\n",nombres[i],tamanio[i]);
printf("\tGreeedy: %d en %f\n", finales[i][0],tiempos[i][0]);
printf("\tAM0: %d en %f\n", finales[i][1],tiempos[i][1]);
printf("\tAM1: %d en %f\n", finales[i][2],tiempos[i][2]);
printf("\tAM2: %d en %f\n", finales[i][3],tiempos[i][3]);
}
printf("\nNuevo de veces que es mejor:\n Greedy: %d\n AM0: %d\n AM1: %d\n AM2: %d\n",
cont1, cont2, cont3, cont4);
for(int j=0; j< nficheros; j++){
desviacion_total[0] += desviaciones[j][0];
desviacion_total[1] += desviaciones[j][1];
desviacion_total[2] += desviaciones[j][2];
desviacion_total[3] += desviaciones[j][3];
}
desviacion_total[0] = desviacion_total[0]/nficheros;
desviacion_total[1] = desviacion_total[1]/nficheros;
desviacion_total[2] = desviacion_total[2]/nficheros;
desviacion_total[3] = desviacion_total[3]/nficheros;
printf("\nDesviaciones: \n Greedy: %f\n AM0: %f\n AM1: %f\n AM2: %f\n",
desviacion_total[0], desviacion_total[1], desviacion_total[2], desviacion_total[3]);
}
int main(int argc, char * argv[])
{
int todos = 1;
if (todos == 1){
TodosArchivos();
return 0;
}
int n = leerNumeroDatos(argv[1]);
if (n > 0) {
reservarEspacio(n);
obtenerMatrices(argv[1], mat1, mat2);
double tiempo;
int costo;
//Aplico Greedy
start_timers();
alg_Greedy(n, mat1, mat2, sol, &costo);
tiempo = elapsed_time();
printf("Greedy de %d datos: Coste-> %d. Tiempo-> %fs.\n", n, costo, tiempo);
printf("Solucion encontrada: ");
for (int i=0; i<n; i++){
printf("%d ", sol[i]);
}
printf("\n\n");
//Aplico AM0
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo, 0,0);
tiempo = elapsed_time();
printf("Algoritmos Memeticos 0 de %d datos: Coste-> %d. Tiempo-> %fs.\n", n, costo, tiempo);
printf("Solucion encontrada: ");
for (int i=0; i<n; i++){
printf("%d ", sol[i]);
}
printf("\n\n");
alg_Greedy(n, mat1, mat2, sol, &costo);
//Aplico AM1
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo, 0,1);
tiempo = elapsed_time();
printf("Algoritmos Memeticos 1 de %d datos: Coste-> %d. Tiempo-> %fs.\n", n, costo, tiempo);
printf("Solucion encontrada: ");
for (int i=0; i<n; i++){
printf("%d ", sol[i]);
}
printf("\n\n");
alg_Greedy(n, mat1, mat2, sol, &costo);
//Aplico AM2
start_timers();
alg_Memetico(n, mat1, mat2, sol, &costo, 0,2);
tiempo = elapsed_time();
printf("Algoritmos Memeticos 2 de %d datos: Coste-> %d. Tiempo-> %fs.\n", n, costo, tiempo);
printf("Solucion encontrada: ");
for (int i=0; i<n; i++){
printf("%d ", sol[i]);
}
printf("\n\n");
}
return 0;
}
