void list_start(list_t list) {
if(!list->head)
list_clean(list);
if(list->curr != list->head)
list->curr = list->head;
}
void limpiarTLB() {
pthread_mutex_lock(&mutexTLB);
int i = list_size(TLB);
list_clean(TLB);
pthread_mutex_unlock(&mutexTLB);
log_trace(logger1,"Se limpiaron %u paginas de la TLB", i);
}
void list_end(list_t list) {
if(!list->head)
list_clean(list);
if(list->curr != list->tail)
list->curr = list->tail;
}
void avisarAlNivel(t_enemigo * enemigo){
//TODO ver como consigo el fd del Planificador
int i;
ITEM_NIVEL * personaje;
t_list * listaPersonajesAtacados = obtenerListaDePersonajesAbajoDeEnemigo(enemigo);
if (list_size(listaPersonajesAtacados) > 0){
char * simbolosPersonajesAtacados = string_new();
for(i=0 ; i < list_size(listaPersonajesAtacados) ; i++){
personaje = list_get(listaPersonajesAtacados,i);
string_append(&simbolosPersonajesAtacados, charToString(personaje->id));
}
//TODO tengo que sacar los personajes de la lista de personajes?
//while(list_size(listaPersonajesAtacados) > 0){
// list_remove(listaPersonajesAtacados,0);
//}
//TODO tengo que sacar los personajes de la lista de personajes?
while(list_size(listaPersonajesAtacados) > 0){
ITEM_NIVEL * persAtacado = list_get(listaPersonajesAtacados,0);
int i = 0;
bool encontrado = false;
while(i<list_size(items) && !encontrado){
ITEM_NIVEL * elem = list_get(items,i);
if (elem->item_type == PERSONAJE_ITEM_TYPE)
if (strcmp(charToString(persAtacado->id), charToString(elem->id)) == 0){
encontrado = true;
pthread_mutex_lock(&mx_lista_items);
list_remove(items,i);
//TODO ver si no hay que actulizar el mapa
pthread_mutex_unlock(&mx_lista_items);
}
i++;
}
list_remove(listaPersonajesAtacados,0);
}
if(IMPRIMIR_INFO_ENEMIGO){
pthread_mutex_lock(&mutex_log);
log_info(logger,"El enemigo atacó a los personajes: %s ", simbolosPersonajesAtacados);
pthread_mutex_unlock(&mutex_log);
}
//if (PRUEBA_CON_CONEXION)
if(true){
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketDeEscucha, NIV_enemigosAsesinaron_PLA, simbolosPersonajesAtacados);
pthread_mutex_unlock(&mutex_mensajes);
}
free(simbolosPersonajesAtacados);
}
list_clean(listaPersonajesAtacados); //TODO, con esto libero todos los elementos de la lista o tengo q recorrerla e ir liberando?
}
bool estoyArribaDeAlgunPersonaje(t_enemigo * enemigo){
t_list * lista = obtenerListaDePersonajesAbajoDeEnemigo(enemigo);
int cantidad = list_size(lista);
list_clean(lista);
//free(lista); // TODO se libera t0do????
return (cantidad > 0);
}
bool hayPersonajeAtacable(){
bool hay = false;
t_list * lista = buscarPersonajesAtacables();
if (list_size(lista)>0)
hay = true;
list_clean(lista);
return hay;
}
void finalizarProcesosColaExit() {
//ACA DEBO ENVIAR MENSAJE A LA CONSOLA DE QUE FINALIZARON SUS PROGRAMAS
//COMO LO HAGO?
//todo LUEGO BORRO ABSOLUTAMENTE Y DESTRUYO
list_clean(listaExit);
}
node_t list_next(list_t list) {
if(!list->head)
return list_clean(list);
if(!list->curr->next) {
list->curr = NULL;
} else {
list->curr = list->curr->next;
}
return list_peek(list);
}
void cazarPersonajes(t_list* bufferMovimiento, coordenada_t* posicion,
int idEnemigo) {
if (hayPersonajes()) {
list_clean(bufferMovimiento);
perseguirPersonaje(posicion, idEnemigo);
} else {
movimientoDeEspera(bufferMovimiento, posicion);
}
}
node_t list_prev(list_t list) {
if(!list->head)
return list_clean(list);
if(!list->curr->prev) {
list->curr = NULL;
} else {
list->curr = list->curr->prev;
}
return list_peek(list);
}
void regenerarDiccionario()
{
// Regenero diccionario de variables
t_mensaje msg_aux;
char buffer_stack[stack];
int i;
list_clean(variables);
if (pcb.context_actual != 0)
{
msg_solicitud_bytes.base = pcb.stack_segment;
msg_solicitud_bytes.offset = pcb.stack_pointer - pcb.stack_segment;
msg_solicitud_bytes.tamanio = pcb.context_actual * 5;
msg_cambio_proceso_activo.id_programa = pcb.unique_id;
mensaje.tipo = SOLICITUDBYTES;
send(sockUmv, &mensaje, sizeof(t_mensaje), 0);
send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0);
send(sockUmv, &msg_solicitud_bytes, sizeof(t_msg_solicitud_bytes), 0);
if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0)
{
log_error(logger, "UMV desconectada.");
depuracion(SIGINT);
}
if (mensaje.tipo == ENVIOBYTES)
{
if (recv(sockUmv, &buffer_stack, (pcb.context_actual * 5), 0) == 0)
{
log_error(logger, "UMV desconectada.");
depuracion(SIGINT);
}
for (i = 0; i < pcb.context_actual; i++)
{
nueva_var = (t_variable *)malloc(sizeof(t_variable));
nueva_var->id = buffer_stack[i * 5];
nueva_var->dir = pcb.stack_pointer + (i * 5);
memcpy(&nueva_var->valor, &buffer_stack[(i * 5) + 1], 4);
list_add(variables, nueva_var);
}
}
else
{
msg_aux.tipo = mensaje.tipo;
send(sockKernel, &msg_aux, sizeof(t_mensaje), 0);
proceso_finalizo = 1;
}
}
}
node_t list_unqueue(list_t list) {
node_t node = NULL;
node_t temp = NULL;
if(!list->tail)
return list_clean(list);
node = node_copy_public(list->tail);
temp = list->tail->prev;
if(temp)
temp->next = NULL;
node_free(list->tail);
list_set_tail(list, temp);
return node;
}
node_t list_pop(list_t list) {
node_t node = NULL;
node_t temp = NULL;
if(!list->head)
return list_clean(list);
node = node_copy_public(list->head);
temp = list->head->next;
if(temp)
temp->prev = NULL;
node_free(list->head);
list_set_head(list, temp);
return node;
}
t_personaje_niv1 * buscaPersonajeCercano(t_enemigo * enemigo){
t_list * listaPersonajesAtacables = buscarPersonajesAtacables();
t_personaje_niv1 * personajeCercano = list_get(listaPersonajesAtacables,0);
int distancia1;
int distancia2;
int i;
for(i=0;i<list_size(listaPersonajesAtacables);i++){
distancia1 = distanciaAPersonaje(enemigo, personajeCercano);
distancia2 = distanciaAPersonaje(enemigo, list_get(listaPersonajesAtacables,i));
if(distancia1 > distancia2)
personajeCercano = list_get(listaPersonajesAtacables,i);
}
list_clean(listaPersonajesAtacables);
return personajeCercano;
}
void compactacionBruta()
{
log_info(SwapLog,"Inicio de compactacion de espacio en memoria de swap");
list_sort(espacioOcupado,compararUbicaciones);
uint32_t cantidadOcupados = list_size(espacioOcupado);
uint32_t comienzo = 0;
uint32_t indice,indiceNodo;
int32_t cantidadPaginasNodo;
t_nodoOcupado* nodoOcupado;
int32_t ubicacionPagina, nuevaUbicacion;
char* espacioViejo;
char* espacioNuevo;
for(indice = 0;indice < cantidadOcupados;indice++)
{
nodoOcupado = list_get(espacioOcupado,indice);
cantidadPaginasNodo = nodoOcupado->paginas;
for(indiceNodo = 0; indiceNodo < cantidadPaginasNodo; indiceNodo++)
{
ubicacionPagina = nodoOcupado->comienzo + indiceNodo;
nuevaUbicacion = comienzo + indiceNodo;
espacioViejo = archivoMapeado->memoria + ubicacionPagina*configuracion->tamano_pagina;
espacioNuevo = archivoMapeado->memoria + nuevaUbicacion*configuracion->tamano_pagina;
memcpy(espacioNuevo,espacioViejo,configuracion->tamano_pagina);
}
nodoOcupado->comienzo = comienzo;
comienzo = nodoOcupado->comienzo + cantidadPaginasNodo;
}
uint32_t totalLibres;
totalLibres = contarPaginasLibres();
uint32_t comienzoLibre = configuracion->cantidad_paginas - totalLibres;
t_nodoLibre* nodoLibre = malloc(sizeof(t_nodoLibre));
nodoLibre->comienzo = comienzoLibre;
nodoLibre->paginas = totalLibres;
list_clean(espacioLibre);
list_add(espacioLibre,nodoLibre);
usleep(deSegundoAMicroSegundos(configuracion->retardo_compactacion));
log_info(SwapLog,"Finalizacion de compactacion en memoria de swap");
}
int32_t main(void){
struct list list;
uint32_t i;
struct listIterator it;
list_init(list, sizeof(uint32_t));
for (i = 0; i < NB_ELEMENT_LIST; i++){
if (list_add_tail(&list, &i) == NULL){
log_err("unable to add element to list");
return EXIT_FAILURE;
}
}
if (list_get_length(&list) != NB_ELEMENT_LIST){
log_err_m("incorrect list size: %u", list_get_length(&list));
return EXIT_FAILURE;
}
for (listIterator_init(&it, &list); listIterator_get_next(&it) != NULL; ){
if (it.index != *(uint32_t*)listIterator_get_data(it)){
log_err_m("iterator error @ %u", it.index);
return EXIT_FAILURE;
}
}
for (listIterator_init(&it, &list); listIterator_get_prev(&it) != NULL; ){
if (it.index != *(uint32_t*)listIterator_get_data(it)){
log_err_m("iterator error @ %u", it.index);
return EXIT_FAILURE;
}
}
if (listIterator_get_index(&it, &list, MODIFY_INDEX) != NULL){
if (MODIFY_INDEX != *(uint32_t*)listIterator_get_data(it)){
log_err_m("iterator error after get index: %u", *(uint32_t*)listIterator_get_data(it));
return EXIT_FAILURE;
}
listIterator_pop_next(&it);
}
else{
log_err_m("unable to get index %u", MODIFY_INDEX);
return EXIT_FAILURE;
}
for (listIterator_init(&it, &list); listIterator_get_next(&it) != NULL; ){
if (it.index == MODIFY_INDEX){
listIterator_push_prev(&it, &(it.index));
break;
}
}
for (listIterator_init(&it, &list); listIterator_get_next(&it) != NULL; ){
if (it.index != *(uint32_t*)listIterator_get_data(it)){
log_err_m("iterator error @ %u", it.index);
return EXIT_FAILURE;
}
}
list_clean(&list);
return EXIT_SUCCESS;
}
/*
* @NAME: queue_clean
* @DESC: Elimina todos los nodos de la cola.
*/
void queue_clean(t_queue *self) {
pthread_mutex_lock(self->mutex);
list_clean(self->elements);
pthread_mutex_unlock(self->mutex);
}
/*
* @NAME: list_destroy
* @DESC: Destruye una lista
*/
void list_destroy(t_list *self) {
list_clean(self);
free(self);
}
void list_clean_and_destroy_elements(t_list *self, void(*element_destroyer)(void*)){
list_iterate(self, element_destroyer);
list_clean(self);
}
t_list* deserializarOrdenDeReduce(char* mensajeSerializado){
t_list* listaNodoNombres = list_create();
list_clean(listaNodoNombres);
uint32_t cantidadEstructuras;
int offset = 0;
memcpy(&cantidadEstructuras,mensajeSerializado,sizeof(cantidadEstructuras));
offset+=sizeof(cantidadEstructuras);
int i;
for(i=0; i<cantidadEstructuras; i++){
uint32_t idNodo;
memcpy(&idNodo,mensajeSerializado + offset,sizeof(idNodo));
offset+=sizeof(idNodo);
uint32_t longIp;
memcpy(&longIp,mensajeSerializado + offset,sizeof(longIp));
offset+=sizeof(longIp);
char* ipNodo = malloc(longIp);
memcpy(ipNodo,mensajeSerializado + offset,longIp);
offset+=longIp;
uint32_t longPuerto;
memcpy(&longPuerto,mensajeSerializado + offset,sizeof(longPuerto));
offset+=sizeof(longPuerto);
char* puerto = malloc(longPuerto);
memcpy(puerto,mensajeSerializado + offset,longPuerto);
offset+=longPuerto;
estructuraNN* unaEstructura = malloc(sizeof(estructuraNN));
unaEstructura->nodo.idNodo = idNodo;
strcpy(unaEstructura->nodo.ipNodo,ipNodo);
strcpy(unaEstructura->nodo.puertoNodo,puerto);
unaEstructura->listaNombres = list_create();
uint32_t cantidadBloques;
memcpy(&cantidadBloques,mensajeSerializado + offset,sizeof(cantidadBloques));
offset+=sizeof(cantidadBloques);
int j;
for(j=0; j < cantidadBloques; j++){
uint32_t longNombre;
memcpy(&longNombre,mensajeSerializado + offset,sizeof(longNombre));
offset+=sizeof(longNombre);
char* nombreEnDondeGuardarlo = malloc(longNombre);
memcpy(nombreEnDondeGuardarlo,mensajeSerializado + offset,longNombre);
offset+=longNombre;
list_add(unaEstructura->listaNombres,nombreEnDondeGuardarlo);
}
list_add(listaNodoNombres,unaEstructura);
}
return listaNodoNombres;
}
void stack_clean(t_stack *self) {
list_clean(self->elements);
}
void silverstack_llamarConRetorno(t_nombre_etiqueta etiqueta, t_puntero donde_retornar)
{
// 1) Preservo el contexto actual
// 2) Preservo el program counter
// 3) Preservo donde retornar el valor
// 4) Asigno el nuevo contexto al puntero de stack
// 5) Reseteo a 0 el tamanio del contexto actual
int buffer;
t_mensaje msg_aux;
int nuevo_contexto = pcb.stack_pointer + (5 * pcb.context_actual);
buffer = pcb.stack_pointer;
pcb.stack_pointer = nuevo_contexto;
msg_envio_bytes.base = pcb.stack_segment;
msg_envio_bytes.offset = pcb.stack_pointer - pcb.stack_segment;
msg_envio_bytes.tamanio = 4;
mensaje.tipo = ENVIOBYTES;
msg_cambio_proceso_activo.id_programa = pcb.unique_id;
send(sockUmv, &mensaje, sizeof(t_mensaje), 0);
send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0);
send(sockUmv, &msg_envio_bytes, sizeof(t_msg_envio_bytes), 0);
send(sockUmv, &buffer, sizeof(buffer), 0);
if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0)
{
log_error(logger, "UMV desconectada.");
depuracion(SIGINT);
}
if (mensaje.tipo == ENVIOBYTES)
{
pcb.stack_pointer += 4;
buffer = pcb.program_counter;
msg_envio_bytes.base = pcb.stack_segment;
msg_envio_bytes.offset = pcb.stack_pointer - pcb.stack_segment;
msg_envio_bytes.tamanio = 4;
mensaje.tipo = ENVIOBYTES;
msg_cambio_proceso_activo.id_programa = pcb.unique_id;
send(sockUmv, &mensaje, sizeof(t_mensaje), 0);
send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0);
send(sockUmv, &msg_envio_bytes, sizeof(t_msg_envio_bytes), 0);
send(sockUmv, &buffer, sizeof(buffer), 0);
if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0)
{
log_error(logger, "UMV desconectada.");
depuracion(SIGINT);
}
if (mensaje.tipo == ENVIOBYTES)
{
pcb.stack_pointer += 4;
buffer = donde_retornar;
msg_envio_bytes.base = pcb.stack_segment;
msg_envio_bytes.offset = pcb.stack_pointer - pcb.stack_segment;
msg_envio_bytes.tamanio = 4;
mensaje.tipo = ENVIOBYTES;
msg_cambio_proceso_activo.id_programa = pcb.unique_id;
send(sockUmv, &mensaje, sizeof(t_mensaje), 0);
send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0);
send(sockUmv, &msg_envio_bytes, sizeof(t_msg_envio_bytes), 0);
send(sockUmv, &buffer, sizeof(buffer), 0);
if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0)
{
log_error(logger, "UMV desconectada.");
depuracion(SIGINT);
}
if (mensaje.tipo == ENVIOBYTES)
{
pcb.stack_pointer += 4;
pcb.context_actual = 0;
list_clean(variables);
silverstack_irAlLabel(etiqueta);
}
else
{
msg_aux.tipo = mensaje.tipo;
send(sockKernel, &msg_aux, sizeof(t_mensaje), 0);
proceso_finalizo = 1;
}
}
else
{
msg_aux.tipo = mensaje.tipo;
send(sockKernel, &msg_aux, sizeof(t_mensaje), 0);
proceso_finalizo = 1;
}
}
else
{
msg_aux.tipo = mensaje.tipo;
send(sockKernel, &msg_aux, sizeof(t_mensaje), 0);
proceso_finalizo = 1;
}
}
