tipoRespuesta* escribirPagina(t_list* listaDeHuecosUtilizados,int pidProceso,char* contenidoAEscribir,int dirLogicaDePagina,int tamanioDePagina, char* particion, t_log* logger, int retardoDeEscritura){
tipoRespuesta* respuestaASolicitudDeEscritura;
char* textoALogear = string_new();
//buscarPIDEnListaDeHuecos
tipoHuecoUtilizado* huecoDelProceso = buscarHuecoUtilizadoPorPID(listaDeHuecosUtilizados,pidProceso);
//traducirDireccionLogicaAFisica
int direccionFisicaEnParticion = traducirDireccionLogicaAFisica(huecoDelProceso,dirLogicaDePagina);
//escribirEnParticion
escribirBloqueMapeado(particion,contenidoAEscribir,direccionFisicaEnParticion,tamanioDePagina);
respuestaASolicitudDeEscritura = crearTipoRespuesta(PERFECTO,OK_PAGINA_ESCRITA);
sleep(retardoDeEscritura);
string_append_with_format(&textoALogear,"Escritura realizada | PID: %d | Byte inicial: %d | Tamanio: %d | Contenido: %s",pidProceso,dirLogicaDePagina*tamanioDePagina,string_length(contenidoAEscribir),contenidoAEscribir);
logearSeguimiento(textoALogear,logger);
free(textoALogear);
return respuestaASolicitudDeEscritura;
}
tipoRespuesta* leerPagina(t_list* listaDeHuecosUtilizados,int pidProceso,int dirLogicaDePagina,int tamanioDePagina,char* particion, t_log* logger, int retardoDeLectura){
tipoRespuesta* respuestaASolicitudDeLectura;
char* contenidoDePagina;
char* textoALogear = string_new();
//buscarPIDEnListaDeHuecos
tipoHuecoUtilizado* huecoDelProceso = buscarHuecoUtilizadoPorPID(listaDeHuecosUtilizados,pidProceso);
//traducirDireccionLogicaEnFisica
int direccionFisicaEnParticion = traducirDireccionLogicaAFisica(huecoDelProceso,dirLogicaDePagina);
//direccionFisicaEnParticion es la posicion donde comienza la pagina en el archivo de particion
//buscarEnContenidoEnParticion
contenidoDePagina = string_duplicate(leerBloqueMapeado(particion,direccionFisicaEnParticion,tamanioDePagina));
//retornarContenidoDePagina
respuestaASolicitudDeLectura = crearTipoRespuesta(PERFECTO,contenidoDePagina);
sleep(retardoDeLectura);
string_append_with_format(&textoALogear,"Lectura realizada | PID: %d | Byte inicial: %d | Tamanio: %d | Contenido: %s",pidProceso,dirLogicaDePagina*tamanioDePagina,string_length(contenidoDePagina),contenidoDePagina);
logearSeguimiento(textoALogear,logger);
free(textoALogear);
free(contenidoDePagina);
return respuestaASolicitudDeLectura;
}
static void test_string_append_with_format() {
char *string = string_new();
string_append_with_format(&string, "%s %s %d", "Hello", "world", 23);
CU_ASSERT_STRING_EQUAL(string, "Hello world 23");
free(string);
}
void comandoPS() {
void mostrarEstadoProceso(void* parametro) {
PCB* unPcb = (PCB*) parametro;
char* proceso = string_new();
string_append_with_format(&proceso, "mProc %d: %s -> %s\n", unPcb->PID,
unPcb->ruta_archivo, get_estado_proceso(unPcb->estado));
printf(ANSI_COLOR_BOLDGREEN "%s \n" ANSI_COLOR_RESET, proceso);
}
tipoRespuesta* reservarEspacio(t_list* listaDeHuecosUtilizados,t_list* listaDeHuecosLibres,int pidProcesoNuevo, int cantPaginasSolicitadas,int cantDePaginasDeSWAP,int tamanioDePagina, char* particion, int retardoDeCompactacion, t_log* logger){
tipoRespuesta* respuestaASolicitudDeReserva;
int baseParaNuevoPID;
char* textoALogear = string_new();
bool tengoEspacioContiguoParaAlmacenarProceso;
if (cantidadDePaginasDisponibles(listaDeHuecosLibres) >= cantPaginasSolicitadas) {
tengoEspacioContiguoParaAlmacenarProceso = tengoEspacioContiguo(listaDeHuecosLibres,cantPaginasSolicitadas,&baseParaNuevoPID);
if(!tengoEspacioContiguoParaAlmacenarProceso){
compactacionAlpha(listaDeHuecosUtilizados,listaDeHuecosLibres,particion,tamanioDePagina,cantDePaginasDeSWAP, retardoDeCompactacion, logger);
baseParaNuevoPID = ultimaPaginaEscrita(listaDeHuecosUtilizados) + 1;
}
asignarEspacio(listaDeHuecosUtilizados,listaDeHuecosLibres,pidProcesoNuevo,baseParaNuevoPID,cantPaginasSolicitadas);
respuestaASolicitudDeReserva = crearTipoRespuesta(PERFECTO,OK_ESPACIO_RESERVADO);
string_append_with_format(&textoALogear,"Proceso mProc asignado | PID: %d | Byte inicial: %d | Tamanio en bytes: %d", pidProcesoNuevo, baseParaNuevoPID*tamanioDePagina, cantPaginasSolicitadas*tamanioDePagina);
logearSeguimiento(textoALogear,logger);
}
else {
respuestaASolicitudDeReserva = crearTipoRespuesta(MANQUEADO,ERROR_NO_HAY_ESPACIO_EN_SWAP);
string_append_with_format(&textoALogear,"Proceso mProc rechazado | Solicitud: %d paginas | Espacio disponible: %d paginas", cantPaginasSolicitadas,cantidadDePaginasDisponibles(listaDeHuecosLibres));
logearSeguimiento(textoALogear,logger);
}
free(textoALogear);
return respuestaASolicitudDeReserva;
}
int main(int argc, char *argv[]) {
pthread_mutex_init(&semNiv, NULL );
if (argc < 4 || string_equals_ignore_case(argv[1], "-h")) {
// Help, I need somebody
// Help, not just anybody
// Help, you know, I need someone
// Help
printf("Necesita minimo 3 argumentos:\n"
"\t1) Archivo de configuracion del \"delay\"\n"
"\t2) Archivo para actualizar Quantums\n"
"\t3) Archivo que se pasara como parametro a Koopa (en el directorio de Koopa)\n"
"[opcionales]\n"
"\t\t> -v: Verboso\n"
"\t\t> -ll [trace/debug/info/warning/error]: Nivel de logeo.\n"
"\t\t> -log [PATH]: Nombre del archivo para logear (Crea y apenda)");
exit(EXIT_SUCCESS);
}
signal(SIGINT, cerrarTodo);
feedKoopa = malloc(sizeof(char) * 30);
string_append_with_format(&feedKoopa, "./koopa %s", argv[3]);
pthread_t tQuantum; //Thread para el quantum
config = config_try_create(argv[1], "delay");
// Obtenemos el delay
delay = config_get_int_value(config, "delay");
// y la sacamos
config_destroy(config);
logger = logInit(argv, "PLATAFORMA");
Quantum = leerDesde(argv[2]); //Hace la primera lectura
//Levnatamos el hilo para iNotify
if (pthread_create(&tQuantum, NULL, (void*)iNotify, (void *) argv[2])) {
log_error(logger, "pthread_create: %s", strerror(errno));
exit(EXIT_FAILURE);
}
orquestador();
return EXIT_FAILURE;
}
void inicializarParticion(char* nombreDeParticion,int tamanioDePagina,int cantidadDePaginas){
//FILE* particion;
char* instruccion = string_new();
string_append_with_format(&instruccion,"dd if=/dev/zero of=%s bs=%d count=%d",nombreDeParticion,tamanioDePagina,cantidadDePaginas);
printf("Inicializando particion...\n\n");
//system("dd if=/dev/zero of=%s bs=%d count=%d",nombreDeParticion,tamanioDePagina,cantidadDePaginas);
system(instruccion);
//sprintf(instruccion,"truncate -s %d %s",tamanioDeParticion,nombreDeParticion);
printf("Particion inicializada. \n");
//particion = fopen(nombreDeParticion,"r+");//modo actualizacion, el archivo debe existir
//return particion;
}
tipoRespuesta* liberarEspacio(t_list* listaDeHuecosUtilizados,t_list* listaDeHuecosLibres,int pidProceso, int tamanioDePagina, t_log* logger, char* rutaDeParticion){
tipoRespuesta* respuestaASolicitudDeLiberacion;
char* textoALogear = string_new();
int base, cantidadDePaginas;
//buscarHuecoDePIDyBorrarHuecoDeLista
liberarProcesoDeListaDeHuecosUtilizadosYDeParticion(listaDeHuecosUtilizados,rutaDeParticion,tamanioDePagina,pidProceso,&base,&cantidadDePaginas);
//actualizarListaDeLibres
actualizarListaDeHuecosLibres(listaDeHuecosLibres,base,cantidadDePaginas);
respuestaASolicitudDeLiberacion = crearTipoRespuesta(PERFECTO,OK_ESPACIO_LIBERADO);
string_append_with_format(&textoALogear,"Proceso mProc liberado | PID: %d | Byte inicial: %d | Tamanio en bytes liberado: %d", pidProceso, base*tamanioDePagina, cantidadDePaginas*tamanioDePagina);
logearSeguimiento(textoALogear,logger);
free(textoALogear);
return respuestaASolicitudDeLiberacion;
}
t_enemigo * enemigo_create(int id){
char * idEnemigo = string_new();
string_append_with_format(&idEnemigo,"%d",id);
t_enemigo * enemigo = malloc(sizeof(t_enemigo));
//enemigo->posicion = posicion_create_pos_rand(); //TODO le saco que cree random la posicion para realizar pruebas
enemigo->posicion = posicion_create_pos(10,id);
enemigo->ultimoMovimiento = "V";
enemigo->cantTurnosEnL = 0;
enemigo->orientacion1 = "";
enemigo->orientacion2 = 0;
enemigo->id=idEnemigo[0]; //agrego el id de enemigo, necesario para las funciones de grafica del nivel
//pthread_mutex_lock(&mx_enemigos);
//numeroEnemigo++;
//pthread_mutex_unlock(&mx_enemigos);
return enemigo;
}
/*Se crean las estructuras necesarias para manejar el Swap*/
void creoEstructuraSwap() {
espacioLibre=list_create();
espacioOcupado=list_create();
metricas=list_create();
/** Ejecuto comando para crear archivo swap.data **/
char* comando=string_new();
string_append_with_format(&comando, "dd if=/dev/zero of=%s bs=%d count=%d > ./dd.log 2>&1", arch->nombre_swap, arch->tamanio_pagina, arch->cantidad_paginas);
system(comando);
free(comando);
log_info(loggerInfo, ANSI_COLOR_BOLDGREEN"Archivo de Swap creado con exito" ANSI_COLOR_RESET);
NodoLibre* nodo= malloc(sizeof(NodoLibre));
nodo->comienzo=0;
nodo->paginas=arch->cantidad_paginas;
sem_wait(&sem_mutex_libre);
list_add(espacioLibre, nodo);
sem_post(&sem_mutex_libre);
totalPaginas=arch->cantidad_paginas;
}
void * procesarInstruccion() {
t_log *logCpu;
protocolo_planificador_cpu* datosParaProcesar = malloc(sizeof(protocolo_planificador_cpu));
protocolo_cpu_memoria* mensajeAMemoria = malloc( sizeof(protocolo_cpu_memoria));
protocolo_memoria_cpu* mensajeDeMemoria = malloc(sizeof(protocolo_memoria_cpu));
int tid = process_get_thread_id();
int socketPlanifAux;
int maximoInstruccion = (int)(60.0f/config->retardo);
t_list * listaTiempos = list_create();
// creacion de la instancia de log
char* nombrelog = string_new();
string_append_with_format(&nombrelog,"../src/logCPU%d",tid);
string_append(&nombrelog,".txt");
logCpu = log_create(nombrelog, "cpu.c", false, LOG_LEVEL_INFO);
free(nombrelog);
/*solo para que quede lindo cuando imprime*/
pthread_mutex_lock(&mutexConectarPlanificador);
printf("Conectando CPU %d al Planificador (%s : %s)... ", tid, config->ipPlanificador,config->puertoPlanificador);
client_init(&socketPlanifAux, config->ipPlanificador, config->puertoPlanificador);
printf("OK\n");
pthread_mutex_unlock(&mutexConectarPlanificador);
if (socketPlanifAux == -1)
log_info(logCpu, "Fallo al conectar con Planificador");
else
log_info(logCpu, "Conectado al Planificador");
if (socketMemoria == -1)
log_info(logCpu, "CPU %d fallo al conectar con Memoria", tid);
else
log_info(logCpu, "CPU %d se conecto con Memoria", tid);
int status;
while (1) {
status = deserializarPlanificador(datosParaProcesar, socketPlanifAux);
if(status <= 0) pthread_exit(0);
if(datosParaProcesar->tipoOperacion == 'u'){
/*tiempo actual*/
time_t tiempoActual = time(NULL);
int i;
int cantidadInstruccionesLeidas = 0;
for(i = 0; i < list_size(listaTiempos); i++){
time_t * tiempoInstruccion = list_get(listaTiempos,i);
if (tiempoActual - (*tiempoInstruccion) <= 60)
cantidadInstruccionesLeidas++;
}
/*borro los tiempos de las isntrucciones que son anteriores al minuto*/
for(i = list_size(listaTiempos) - 1; i >= 0; i--){
time_t * tiempoInstruccion = list_get(listaTiempos,i);
if (tiempoActual - (*tiempoInstruccion) > 60){
free(list_remove(listaTiempos,i));
}
}
datosParaProcesar->pid = tid;
datosParaProcesar->counterProgram = ((int)(((float)cantidadInstruccionesLeidas/(float)maximoInstruccion) * 100.0f));
enviarAPlanificador(datosParaProcesar,socketPlanifAux);
}
else{
logueoRecepcionDePlanif(datosParaProcesar,tid,logCpu);
FILE* archivo = fopen(datosParaProcesar->mensaje, "r+");
if (archivo == NULL){
printf("Error al abrir mCod: %s\n", datosParaProcesar->mensaje);
break;
}
fseek(archivo, 0, SEEK_END);
int tamanio = ftell(archivo);
fseek(archivo, 0, SEEK_SET);
char* lineaLeida = malloc(tamanio);
int quantum = 0;
while ((!feof(archivo) && (quantum < datosParaProcesar->quantum || datosParaProcesar->quantum == 0))) {
//calcularTamanioDeLinea(archivo,&tamanio);
char* instruccionLeida = leerInstruccion(&(datosParaProcesar->counterProgram), lineaLeida, archivo,tamanio);
char** linea = string_split(instruccionLeida, ";");
printf("pid-> %d ejecutar %s\n", datosParaProcesar->pid, *linea);
free(*linea);
/*si no "entiende" la instruccion pasa a la siguiente*/
if (!interpretarInstruccion(instruccionLeida, datosParaProcesar, mensajeAMemoria, socketPlanifAux,logCpu))
continue;
if (datosParaProcesar->tipoOperacion == 'e') break;
/*asi la comunicacion con la memoria es atomica*/
pthread_mutex_lock(&mutex);
enviarAMemoria(mensajeAMemoria);
deserializarMemoria(mensajeDeMemoria, socketMemoria);
pthread_mutex_unlock(&mutex);
loguearEstadoMemoria(mensajeDeMemoria,instruccionLeida,logCpu);
switch (mensajeDeMemoria->codOperacion){
case 'f': {
actualizarOperacionPaquetePlanificador(datosParaProcesar, 'f');
enviarAPlanificador(datosParaProcesar,socketPlanifAux);
/*me voy al eof para salir del while*/
while(getc(archivo) != EOF);
continue;
}
break;
case 'i':{
/*para saber desde el planifciador si el fallo es por inicializacion*/
datosParaProcesar->tipoProceso = 'i';
actualizarOperacionPaquetePlanificador(datosParaProcesar, mensajeDeMemoria->codAux);
enviarAPlanificador(datosParaProcesar,socketPlanifAux);
if (mensajeDeMemoria->codAux == 'a'){
/*me voy al eof para salir del while*/
while(getc(archivo) != EOF);
continue;
}
}
break;
case 'l':
case 'e':{
if (mensajeDeMemoria->codAux == 'a'){
/*para saber desde el planifciador si el fallo es por lectura o escritura*/
datosParaProcesar->tipoProceso = mensajeDeMemoria->codOperacion;
actualizarOperacionPaquetePlanificador(datosParaProcesar, 'a');
enviarAPlanificador(datosParaProcesar,socketPlanifAux);
datosParaProcesar->tipoOperacion = 'f';
/*me voy al eof para salir del while*/
while(getc(archivo) != EOF);
continue;
}
}
break;
}
sleep(config->retardo);
/*guardo tiempo en el que se ejecuto la instruccion*/
time_t * tiempoInstruccion = malloc(sizeof(time_t));
*tiempoInstruccion = time(NULL);
list_add(listaTiempos, tiempoInstruccion);
/*incremento quatum solo para operaciones leer y escribir*/
if (mensajeDeMemoria->codOperacion != 'i' && mensajeDeMemoria->codOperacion != 'f')
quantum++;
}
/*es rr y salio por quantum y no por io*/
if (datosParaProcesar->quantum != 0) {
if (datosParaProcesar->quantum == quantum){
if (datosParaProcesar->tipoOperacion != 'e' && datosParaProcesar->tipoOperacion != 'f'){
actualizarOperacionPaquetePlanificador(datosParaProcesar, 'q');
enviarAPlanificador(datosParaProcesar, socketPlanifAux);
printf("pid-> %d salio por quantum\n", datosParaProcesar->pid);
}
}
}
free(lineaLeida);
fclose(archivo);
}
}
free(mensajeAMemoria);
free(mensajeDeMemoria);
free(datosParaProcesar);
close(socketPlanifAux);
log_info(logCpu, "Cerrada conexion saliente");
log_destroy(logCpu);
return 0;
}
int persistirEstructuras()
{
while(true)
{
sem_wait(&sPersistencia);
char* estructuras = string_new();
strcpy(estructuras,"");
//lista de archivos
string_append_with_format(&estructuras, "%s\n", SECCION_LISTA_ARCHIVOS);
pthread_mutex_lock(&mListaArchivos);
for (int i=0;i<listaArchivos->elements_count;i++)
{
t_reg_archivo* archivo = list_get(listaArchivos,i);
string_append_with_format(&estructuras, "%s;%d;%d;%"PRId64";",
archivo->nombre,
archivo->dirPadre,
archivo->estado,
archivo->tamanio);
for (int j=0;j<archivo->bloques->elements_count;j++)
{
if (j != 0) string_append(&estructuras, "//");
t_list* ubicaciones = list_get(archivo->bloques,j);
for (int k=0;k<ubicaciones->elements_count;k++)
{
t_ubicacion_bloque* ubicacion = list_get(ubicaciones,k);
string_append_with_format(&estructuras, "%s;%d;",
ubicacion->nodo->nombre,
ubicacion->bloque);
}
}
string_append(&estructuras, "\n");
}
pthread_mutex_unlock(&mListaArchivos);
string_append_with_format(&estructuras, "%s\n", SECCION_LISTA_DIRS);
pthread_mutex_lock(&mListaDirs);
for (int i=1;i<listaDirs->elements_count;i++)
{
t_reg_directorio* dir = list_get(listaDirs,i);
string_append_with_format(&estructuras, "%s;%d;\n",
dir->directorio,
dir->padre);
}
pthread_mutex_unlock(&mListaDirs);
string_append_with_format(&estructuras, "%s\n", SECCION_LISTA_CONEXIONES);
pthread_mutex_lock(&mConexiones);
for (int i=0;i<conexiones->elements_count;i++)
{
Conexion_t* conexion = list_get(conexiones,i);
string_append_with_format(&estructuras, "%s;%d;%d;",
conexion->nombre,
conexion->estado,
conexion->totalBloques);
pthread_mutex_lock(&(conexion->mEstadoBloques));
for (int k=0;k<conexion->totalBloques;k++)
{
string_append_with_format(&estructuras, "%d",
conexion->estadoBloques[k]);
}
pthread_mutex_unlock(&(conexion->mEstadoBloques));
string_append(&estructuras, "\n");
}
pthread_mutex_unlock(&mConexiones);
pthread_mutex_lock(&mPersistFile);
persistFile = fopen("./FileSystem.persist","w+");
fprintf(persistFile,estructuras);
fclose(persistFile);
pthread_mutex_unlock(&mPersistFile);
}
return EXIT_SUCCESS;
}
char * charToString(char valor){
char * res = string_new();
string_append_with_format(&res, "%c", valor);
return res;
}
