Exemplo n.º 1
0
Arquivo: List.c Projeto: kr094/c
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);
}
Exemplo n.º 3
0
Arquivo: List.c Projeto: kr094/c
void list_end(list_t list) {
	if(!list->head)
		list_clean(list);

	if(list->curr != list->tail)
		list->curr = list->tail;
}
Exemplo n.º 4
0
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?

}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
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);

}
Exemplo n.º 8
0
Arquivo: List.c Projeto: kr094/c
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);
}
Exemplo n.º 9
0
void cazarPersonajes(t_list* bufferMovimiento, coordenada_t* posicion,
		int idEnemigo) {

	if (hayPersonajes()) {
		list_clean(bufferMovimiento);
		perseguirPersonaje(posicion, idEnemigo);
	} else {

		movimientoDeEspera(bufferMovimiento, posicion);
	}

}
Exemplo n.º 10
0
Arquivo: List.c Projeto: kr094/c
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);
}
Exemplo n.º 11
0
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;
		}
	}
}
Exemplo n.º 12
0
Arquivo: List.c Projeto: kr094/c
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;
}
Exemplo n.º 13
0
Arquivo: List.c Projeto: kr094/c
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;
}
Exemplo n.º 14
0
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");
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
0
/*
 * @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);
}
Exemplo n.º 18
0
/*
 * @NAME: list_destroy
 * @DESC: Destruye una lista
 */
void list_destroy(t_list *self) {
	list_clean(self);
	free(self);
}
Exemplo n.º 19
0
void list_clean_and_destroy_elements(t_list *self, void(*element_destroyer)(void*)){
	list_iterate(self, element_destroyer);
	list_clean(self);
}
Exemplo n.º 20
0
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;
}
Exemplo n.º 21
0
void stack_clean(t_stack *self) {
	list_clean(self->elements);
}
Exemplo n.º 22
0
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;
	}
}