int32_t compactar() {
sem_wait(&sem_mutex_ocupado);
if (list_is_empty(espacioOcupado)) {
log_error(loggerError, ANSI_COLOR_RED "No se puede compactar una memoria vacía"ANSI_COLOR_RESET);
return -1;
}
if(list_is_empty(espacioLibre)) {
log_error(loggerError, ANSI_COLOR_RED "No se puede compactar una memoria completamente llena"ANSI_COLOR_RESET);
return -1;
}
log_info(loggerInfo, ANSI_COLOR_GREEN"Compactacion iniciada por fragmentacion externa"ANSI_COLOR_RESET);
NodoOcupado* primerNodo=list_get(espacioOcupado, 0);
if(primerNodo->comienzo!=0) {
leeryEscribir(primerNodo,0);
primerNodo->comienzo=0;
}
int32_t i;
for(i=1; i<list_size(espacioOcupado); i++) {
NodoOcupado* nodo= list_get(espacioOcupado, i);
NodoOcupado* anterior= list_get(espacioOcupado, i-1);
bool chequeo=(nodo->comienzo==anterior->comienzo+anterior->paginas);
if(!chequeo) {
leeryEscribir(nodo,anterior->comienzo+anterior->paginas);
nodo->comienzo=anterior->comienzo+anterior->paginas;
}
//fin for
}
NodoOcupado* nodo=list_get(espacioOcupado, i-1);
int32_t nuevoComienzo=(nodo->comienzo+nodo->paginas);
if(nuevoComienzo==totalPaginas) {
list_clean_and_destroy_elements(espacioLibre, free);
} else {
NodoLibre* nodoLibre=malloc(sizeof(NodoLibre));
nodoLibre->comienzo = nuevoComienzo;
nodoLibre->paginas = totalPaginas - nuevoComienzo;
sem_wait(&sem_mutex_libre);
list_clean_and_destroy_elements(espacioLibre, free);
list_add(espacioLibre, nodoLibre);
sem_post(&sem_mutex_libre);
}
graficoCompactar();
sem_post(&sem_mutex_ocupado);
return 1;
}
void ansisop_ejecucion_instruccion2(instruccion_t instruccion,
int32_t param_numero)
{
t_list* parametros = list_create();
_agregar_numero_a_parametros(parametros, param_numero);
ejecucion_instruccion(instruccion, parametros);
list_clean_and_destroy_elements(parametros, _free_parametro);
}
void ansisop_ejecucion_instruccion5(instruccion_t instruccion,
char param_registro)
{
t_list* parametros = list_create();
_agregar_registro_a_parametros(parametros, param_registro);
ejecucion_instruccion(instruccion, parametros);
list_clean_and_destroy_elements(parametros, _free_parametro);
}
void inicializarVariablesGlobales() {
reiniciar(true);
VIDAS = configPersonajeVidas();
if (planDeNiveles != NULL)
queue_destroy_and_destroy_elements(planDeNiveles, (void*)destruirObjetivosxNivel);
planDeNiveles = configPersonajePlanDeNiveles();
list_clean_and_destroy_elements(listaHilosxNivel, (void*)destruirEstructuraHiloPersonaje);
}
int validarPosicionesEnemigo(t_list* bufferMovimiento) {
int i, r;
for (i = 0; i < list_size(bufferMovimiento); i++) {
coordenada_t* coordenadaTemp; //= malloc(sizeof(coordenada_t));
coordenadaTemp = list_get(bufferMovimiento, i);
log_trace(logFile, "Validando buffer %d, posiicion (%d, %d)", i,
coordenadaTemp->ejeX, coordenadaTemp->ejeY);
r = validarPosicionEnemigo(coordenadaTemp);
// free (coordenadaTemp);
if (!r) {
list_clean_and_destroy_elements(bufferMovimiento, (void*) free);
return 0;
}
}
return 1;
}
void handler_crear_segmento(uint32_t *respuesta, char *orden, t_param_memoria *parametros_memoria, char **savePtr1, t_log *logger)
{
char *id_prog = strtok_r(NULL, ",", savePtr1);
char *tamanio = strtok_r(NULL, ",", savePtr1);
pthread_mutex_lock(&op_atomica);
void *mem_ppal = parametros_memoria->mem_ppal;
uint32_t tamanio_mem_ppal = parametros_memoria->tamanio_mem_ppal;
t_list *lista_segmentos = parametros_memoria->listaSegmentos;
char *algoritmo_compactacion = parametros_memoria->algoritmo_comp;
t_list *espacios_libres = buscarEspaciosLibres(lista_segmentos, mem_ppal, tamanio_mem_ppal);
*respuesta = crearSegmento(atoi(id_prog), atoi(tamanio), espacios_libres, lista_segmentos, algoritmo_compactacion);
if(*respuesta == 0){
log_info(logger, "[ATENCION_CONN] No hay espacio para este segmento. Voy a intentar compactar.");
compactar(lista_segmentos, mem_ppal, tamanio_mem_ppal);
if (!list_is_empty(espacios_libres)) {
list_clean_and_destroy_elements(espacios_libres, eliminarEspacioLibre);
}
list_destroy(espacios_libres);
espacios_libres = buscarEspaciosLibres(lista_segmentos, mem_ppal, tamanio_mem_ppal);
*respuesta = crearSegmento(atoi(id_prog), atoi(tamanio), espacios_libres, lista_segmentos, algoritmo_compactacion);
if((*respuesta == 0) || (respuesta == NULL))
log_info(logger, "[ATENCION_CONN] No hay lugar para crear un segmento, incluso después de haber compactado la memoria.");
}
list_destroy_and_destroy_elements(espacios_libres, eliminarEspacioLibre);
pthread_mutex_unlock(&op_atomica);
if(respuesta == NULL)
log_info(logger, "[ATENCION_CONN] RESPUESTA ES NULL!!!! QUE CARAJO PASÓ???");
log_info(logger, "[ATENCION_CONN] La respuesta al comando crear_segmento será: %d.", *respuesta);
return;
}
/*
* @NAME: list_destroy_and_destroy_elements
* @DESC: Destruye una lista y sus elementos
*/
void list_destroy_and_destroy_elements(t_list *self, void(*element_destroyer)(void*)) {
list_clean_and_destroy_elements(self, element_destroyer);
free(self);
}
void stack_clean_and_destroy_elements(t_stack *self, void(*element_destroyer)(void*)) {
list_clean_and_destroy_elements(self->elements, element_destroyer);
}
/*
* @NAME: queue_clean_and_destroy_elements
* @DESC: Elimina todos los elementos de la cola.
*/
void queue_clean_and_destroy_elements(t_queue *self, void(*element_destroyer)(void*)) {
pthread_mutex_lock(self->mutex);
list_clean_and_destroy_elements(self->elements, element_destroyer);
pthread_mutex_unlock(self->mutex);
}
