void _destruyo_proceso(proceso_msp_t* proceso, direccion base, bool* ok)
{
(*ok) = quitar_segmento(proceso, base);
list_destroy(proceso->segmentos);
liberar_marcos_proceso(proceso->pid);
list_remove_and_destroy_by_condition(get_lista_procesos(), (void*) _es_proceso, (void*) _destruyo_proc);
}
// ver de notificar que elimino un job, blah
void job_eliminar(int fdJob, header_t header){
bool buscarJobPorFd(void* element){
return ((t_job*)element)->fd == fdJob;
}
pthread_mutex_lock(&mutex_lista_jobs);
list_remove_and_destroy_by_condition(lista_jobs, (void*)job_buscar_por_fd, (void*)job_liberar);
pthread_mutex_unlock(&mutex_lista_jobs);
}
void openFileListRemoveAndDestroy(open_file_list_t* list, open_file_t* file) {
bool cmpOfPaths(open_file_t* openFile) {
if (strlen(file->path) == strlen(openFile->path)) {
if (strncmp(file->path, openFile->path, strlen(file->path) + 1)
== 0) {
return true;
}
}
return false;
}
list_remove_and_destroy_by_condition(list->open_file_list, cmpOfPaths,
open_file_destroyer);
}
int32_t hiloEjecucionCPU(t_HiloCPU* paramsCPU)
{
log_info(MemoriaLog,"Esperando pedidos de Cpu \n");
int32_t codigoOperacion;
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
while(codigoOperacion!=0) {
switch(codigoOperacion) {
case codigo_iniciar:
iniciar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_finalizar:
finalizar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_leer:
lectura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_escribir:
escritura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
}
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
}
if(codigoOperacion==0){
log_info(MemoriaLog, "Se desconectó un CPU\n");
bool PorCerrado(sock_t* socket){
return socket->fd==0;
}
int32_t veces = list_count_satisfying(CPUsConectados,(void*)PorCerrado);
int32_t it;
for(it=0; it<veces; it++){
list_remove_and_destroy_by_condition(CPUsConectados, (void*)PorCerrado, (void*)clean_socket);
}
}
int compactacion() {
t_link_element* nodo;
t_link_element* nodoSiguiente;
t_link_element* nodoAnterior;
t_segmento* segmentoLibre; //segmento libre
t_segmento* segmentoReservado; //segmento ocupado
t_segmento* segmentoSiguiente;
t_segmento* segmentoCero;
t_segmento* segmento;
t_segmento* segmentoSiguienteAlLibre;
t_segmento* segmentoAnterior;
pthread_mutex_lock(&escribirListaUMV);
int diferenciaEntreSegmentos = 0;
int cantidadDeSegmentosDeDiferencia = 0;
int i;
segmentoCero = list_get(UMV, 0);
if (UMV->elements_count != 1) {
nodo = UMV->head->next;
} else
goto error;
segmento = nodo->data;
while (nodo != NULL ) {
libre: if (segmento->segmentoReservado == 0) {
//Preparo el ambiente para poder realizar las operaciones
segmentoLibre = segmento;
//Busco el primer segmento reservado para subirlo a la posicion del segmento libre
nodoSiguiente = nodo->next;
if (nodoSiguiente == NULL )
goto error;
segmentoSiguiente = nodoSiguiente->data;
segmentoSiguienteAlLibre = nodoSiguiente->data;
//Busco el primer segmento reservado
while (segmentoSiguiente->segmentoReservado != 1) {
nodoSiguiente = nodoSiguiente->next;
if (nodoSiguiente == NULL )
goto error;
segmentoSiguiente = nodoSiguiente->data;/*CORREGIDO*///CORREGIR, NO AVANZA,SIEMPRE ES EL MISMO NODO
++cantidadDeSegmentosDeDiferencia;
}
//Encontre el segmento reservado
segmentoReservado = segmentoSiguiente;
//Me fijo si el segmento reservado es el siguiente al libre
if (segmentoReservado == segmentoSiguienteAlLibre) {
//Si es igual, y el segmento libre es mayor al reservado
if (segmentoLibre->size > segmentoReservado->size) {
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
diferenciaEntreSegmentos = segmentoLibre->size
- segmentoLibre->size;
segmentoLibre->size = segmentoLibre->size
- diferenciaEntreSegmentos;
segmentoLibre->posInicial = segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoReservado->posInicial =
segmentoReservado->posInicial
- diferenciaEntreSegmentos;
segmentoReservado->posMemoria =
segmentoReservado->posMemoria
- diferenciaEntreSegmentos;
/*ultima modificacion*/
segmentoReservado->size = segmentoReservado->size + diferenciaEntreSegmentos;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
} else {
//el segmento libre es mas chico que el segmento reservado, debo agrandar el libre y achicar el ocupado
if (segmentoLibre->size < segmentoReservado->size) {
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
diferenciaEntreSegmentos = segmentoReservado->size
- segmentoLibre->size;
segmentoLibre->size = segmentoLibre->size
+ diferenciaEntreSegmentos;
segmentoLibre->posInicial =
segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoReservado->posInicial =
segmentoReservado->posInicial
+ diferenciaEntreSegmentos;
segmentoReservado->posMemoria =
segmentoReservado->posMemoria
+ diferenciaEntreSegmentos;
segmentoReservado->size = segmentoReservado->size
- diferenciaEntreSegmentos;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
} else {
//Los segmentos son iguales
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
segmentoLibre->posInicial =
segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
segmentoReservado->posInicial =
segmentoReservado->posInicial + 1;// pos inicial es ilustrativo,
//no me dice nada mas que el id del segmento
}
}
} else {
/*HAY UNO O MAS SEGMENTOS DE DIFERENCIA ENTRE EL LIBRE Y EL RESERVADO
* LIBRE LIBRE RESERVADO*/
//distino al siguiente
if (segmentoLibre->size > segmentoReservado->size) {
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
diferenciaEntreSegmentos = segmentoLibre->size
- segmentoReservado->size;
segmentoLibre->size = segmentoLibre->size
- diferenciaEntreSegmentos;
segmentoLibre->posInicial = segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoSiguienteAlLibre->posInicial = //cambiado
segmentoSiguienteAlLibre->posInicial
- diferenciaEntreSegmentos;
segmentoSiguienteAlLibre->posMemoria =
segmentoSiguienteAlLibre->posMemoria
- diferenciaEntreSegmentos;
segmentoSiguienteAlLibre->size =
segmentoSiguienteAlLibre->size
+ diferenciaEntreSegmentos;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
} else {
if (segmentoLibre->size == segmentoReservado->size) {
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
segmentoLibre->posInicial =
segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
segmentoReservado->posInicial =
segmentoReservado->posInicial + 1;
} else {
if (segmentoLibre->size < segmentoReservado->size) {
//segmentolibre menor al segmento reservado
//Ya sabemos que debemos ocupar el libre y por lo menos el siguiente al libre
void* posHacia;
void* posDesde;
posHacia = segmentoLibre->posMemoria;
posDesde = segmentoReservado->posMemoria;
memcpy(posHacia, posDesde, segmentoReservado->size);
diferenciaEntreSegmentos = segmentoReservado->size
- segmentoLibre->size;
//ocupar el segmento libre
segmentoLibre->posInicial =
segmentoReservado->posInicial;
segmentoLibre->segmentoReservado = 1;
segmentoLibre->pid = segmentoReservado->pid;
segmentoLibre->size = segmentoReservado->size;
//empezar a restar de los segmentos siguientes
for (i = 0; i <= cantidadDeSegmentosDeDiferencia;//revisar acá
++i) {
if (segmentoSiguienteAlLibre->size
> diferenciaEntreSegmentos/*ultima modificacion*/) {
//Termino aca y achico
segmentoSiguienteAlLibre->size =
segmentoSiguienteAlLibre->size
- diferenciaEntreSegmentos;
segmentoSiguienteAlLibre->posInicial =
segmentoSiguienteAlLibre->posInicial
+ diferenciaEntreSegmentos;
segmentoSiguienteAlLibre->posMemoria =
segmentoSiguienteAlLibre->posMemoria
+ diferenciaEntreSegmentos;
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado = 0;
break;
} else {
if (segmentoSiguienteAlLibre->size
< diferenciaEntreSegmentos) {/*ULTIMA MODIFICACION*/
diferenciaEntreSegmentos =
diferenciaEntreSegmentos
- segmentoSiguienteAlLibre->size;
nodoSiguiente = nodo->next;
nodoAnterior = nodoSiguiente;
segmentoAnterior = nodoAnterior->data;
nodoSiguiente = nodoSiguiente->next;
segmentoSiguienteAlLibre =
nodoSiguiente->data;
bool _destructorSegmentoConsumido(
t_segmento* segmentoADestruir) {
return segmentoADestruir->posInicial
== segmentoAnterior->posInicial
&& segmentoADestruir->size/*CAMBIE ACA*/
== segmentoAnterior->size;
}
list_remove_and_destroy_by_condition(
UMV,
(void*) _destructorSegmentoConsumido,
free);
//Lo ocupo y disminuyo la difDeSegmentos,
//tomo el siguiente para ver si está ocupado , elimino
} else { // son iguales
segmentoReservado->pid = -1;
segmentoReservado->segmentoReservado =
0;
bool _destructorSegmentoConsumido(
t_segmento* segmentoADestruir) {
return segmentoADestruir->posInicial
== segmentoSiguienteAlLibre->posInicial
&& segmentoADestruir->posInicial
== segmentoSiguienteAlLibre->size;
}
list_remove_and_destroy_by_condition(
UMV,
(void*) _destructorSegmentoConsumido,
free);
break;
}
}
}
}
}
}
