datos_personaje_t *removerPersonajePorSimbolo(datos_planificador_t *datosPlan,
char simbolo) {
int _is_personaje(datos_personaje_t *unPersonaje) {
return unPersonaje->simbolo == simbolo;
}
datos_personaje_t *unPersonaje = NULL;
pthread_mutex_lock(datosPlan->mutexColas);
if (datosPlan->personajeEnMovimiento != NULL ) {
if (datosPlan->personajeEnMovimiento->simbolo == simbolo) {
unPersonaje = datosPlan->personajeEnMovimiento;
datosPlan->personajeEnMovimiento = NULL;
datosPlan->quantumCorriente = 0;
}
}
if (unPersonaje == NULL ) {
unPersonaje = list_remove_by_condition(
datosPlan->personajesListos->elements, (void *) _is_personaje);
}
if (unPersonaje == NULL ) {
unPersonaje = list_remove_by_condition(
datosPlan->personajesBloqueados->elements,
(void *) _is_personaje);
}
pthread_mutex_unlock(datosPlan->mutexColas);
return unPersonaje;
}
void* hiloPCBaFinalizar() {
while (1) {
sem_wait(&semProgramaFinaliza);
log_debug(log_pcp, "Debido a que se detuvo el programa %d, se envia el pcb a la cola de Exit", pcbAFinalizar);
bool obtenerDeBloqueados(t_pcbBlockedSemaforo* pcbBlocked) {
return pcbBlocked->pcb->pcb_id == pcbAFinalizar;
}
bool obtenerDeReady(t_pcb* pcbReady) {
return pcbReady->pcb_id == pcbAFinalizar;
}
bool obtenerDeClientes(t_clienteCPU* cliente) {
return cliente->pcbAsignado->pcb_id == pcbAFinalizar;
}
while (1) {
t_pcbBlockedSemaforo* pcbBlock = list_remove_by_condition(listaBloqueados, (void*) obtenerDeBloqueados);
if (pcbBlock != NULL ) {
queue_push(colaExit, pcbBlock->pcb);
sem_post(&semProgExit);
sem_post(&semMultiProg);
pthread_mutex_unlock(&mutex_exit);
log_debug(log_pcp, "El pcb se encontraba en la cola de bloqueados");
break;
}
t_pcb* pcb = list_remove_by_condition(colaReady->elements, (void*) obtenerDeReady);
if (pcb != NULL ) {
queue_push(colaExit, pcb);
sem_post(&semProgExit);
sem_post(&semMultiProg);
pthread_mutex_unlock(&mutex_exit);
log_debug(log_pcp, "El pcb se encontraba en la cola de ready");
break;
}
t_clienteCPU* cliente = list_find(listaClientes, (void*) obtenerDeClientes);
if (cliente != NULL ) {
cliente->programaCerrado = true;
cliente->fueAsignado=false;
queue_push(colaExit, cliente->pcbAsignado);
sem_post(&semProgExit);
sem_post(&semMultiProg);
pthread_mutex_unlock(&mutex_exit);
log_debug(log_pcp, "El programa se encontraba en ejecucion");
break;
}
sleep(2);
}
}
return 0;
}
bool destruirPrograma( Programa * programa )
{
bool matchearPrograma(Programa *nodoPrograma)
{
return nodoPrograma->pid == programa->pid;
}
list_remove_by_condition( programas, matchearPrograma);
if( programa != NULL)
{
log_info( logger, "Destruyendo programa con pid: %d", programa->pid);
borrarSegmento( programa->stack );
borrarSegmento( programa->script );
if(programa->etiquetas != NULL)
borrarSegmento( programa->etiquetas );
borrarSegmento( programa->instrucciones );
free( programa );
return true;
}else{
log_error( logger, "El programa con pid: %d no se ha podido destruir", programa->pid);
return false;
}
}
//Se ejecuta funcion despues de validar, devuelve posicion pagina inicial
uint32_t ocuparEspacio(int32_t PID,int32_t paginasAOcupar)
{
uint32_t posicionInicial;
t_nodoLibre* nodoLibre;
t_nodoOcupado* nodoOcupado = malloc(sizeof(t_nodoOcupado));
nodoOcupado->paginas = paginasAOcupar;
nodoOcupado->PID = PID;
CantidadDePaginasCondicion = paginasAOcupar;
nodoLibre = list_find(espacioLibre, validarEspacioLibre);
nodoOcupado->comienzo = nodoLibre->comienzo;
posicionInicial = nodoOcupado->comienzo;
if(nodoLibre->paginas > paginasAOcupar)
{
nodoLibre->comienzo = nodoLibre->comienzo + paginasAOcupar;
nodoLibre->paginas = nodoLibre->paginas - paginasAOcupar;
}
else
{
//Cantidad de paginas a ocupar es igual a cantidad libre
NumeroDePaginaCondicion = nodoLibre->comienzo;
nodoLibre = list_remove_by_condition(espacioLibre, validarUbicacionLibre);
free(nodoLibre);
}
list_add(espacioOcupado,nodoOcupado);
return posicionInicial;
}
int usarRecurso(char simboloRecurso, t_list *recursosLiberados,
t_list *recursosUsados, char simboloPersonaje) {
int _is_recurso(recurso_t *recurso) {
return recurso->id == simboloRecurso;
}
recurso_t *recursoLiberado = list_find(recursosLiberados,
(void *) _is_recurso);
if (recursoLiberado != NULL ) {
recursoLiberado->quantity--;
personaje_recurso_t *personajeDesbloqueado = malloc(
sizeof(personaje_recurso_t));
personajeDesbloqueado->idRecurso = recursoLiberado->id;
personajeDesbloqueado->idPersonaje = simboloPersonaje;
list_add(recursosUsados, personajeDesbloqueado);
if (recursoLiberado->quantity == 0) {
list_remove_by_condition(recursosLiberados, (void *) _is_recurso);
recurso_destroy(recursoLiberado);
}
}
return recursoLiberado != NULL ;
}
void socket_multiplex(t_list* sockets) {
struct epoll_event events[list_size(sockets)];
int epollfd = epoll_create(list_size(sockets));
void _add_elements(t_socket* socket) {
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLRDHUP;
ev.data.fd = socket->socket;
epoll_ctl(epollfd, EPOLL_CTL_ADD, socket->socket, &ev);
}
list_iterate(sockets, (void*) _add_elements);
int nfds = epoll_wait(epollfd, events, list_size(sockets), -1);
for (int i = 0; i < nfds; ++i) {
int sock_epoll = events[i].data.fd;
uint32_t event = events[i].events;
bool _search_by_socket(t_socket* socket) {
return sock_epoll == socket->socket;
}
if (event & EPOLLRDHUP) {
t_socket* sock_found = list_remove_by_condition(sockets, (void*) _search_by_socket);
if (sock_found->handler_closed != NULL) {
sock_found->handler_closed(sock_found);
}
free(sock_found);
} else if (event & EPOLLIN) {
t_socket* sock_found = list_find(sockets, (void*) _search_by_socket);
sock_found->handler(sock_found);
}
}
close(epollfd);
}
void cerrarMINivel(global tabla){
bool _soyNID(nodoNivel*nivel){
if(nivel->nid==tabla.cabecera->nid) return true;
return false;
}
list_remove_by_condition(listaNiveles,(void*)_soyNID);
}
void threadDispositivo(stDispositivo* unDispositivo) {
int error = 0;
t_queue *colaRafaga;
stRafaga *unaRafaga;
stPCB *unPCB;
colaRafaga = unDispositivo->rafagas;
while (!error) {
while (unDispositivo->numInq == 0)
pthread_mutex_lock(&unDispositivo->empty);
pthread_mutex_lock(&unDispositivo->mutex); // Se lockea el acceso a la cola
unaRafaga = queue_pop(colaRafaga);
unDispositivo->numInq--;
pthread_mutex_unlock(&unDispositivo->mutex); // Se desbloquea el acceso a la cola
log_info("Pedido I/O - Retardo de dispositivo [%s] con [%d].",unDispositivo->nombre,atoi(unDispositivo->retardo));
usleep(atoi(unDispositivo->retardo)*unaRafaga->unidades*1000);
/*Busqueda del pcb en la lista de pcb bloqueados*/
int _es_el_pcb(stPCB *p) {
return p->pid == unaRafaga->pid;
}
pthread_mutex_lock(&mutex_listaBlock);
unPCB = list_remove_by_condition(listaBlock, (void*) _es_el_pcb);
pthread_mutex_unlock(&mutex_listaBlock);
/*Ponemos en la cola de Ready para que lo vuelva a ejecutar un CPU*/
ready_productor(unPCB);
log_info("El PCB [PID - %d] cambia de estado BLOCK a READY\n", unPCB->pid);
free(unaRafaga);
}
}
void BorrarItem(t_list* items, char id) {
bool _search_by_id(ITEM_NIVEL* item) {
return item->id == id;
}
list_remove_by_condition(items, (void*) _search_by_id);
}
void liberarProceso(int32_t PID)
{
uint32_t byteInicial;
uint32_t tamanio;
t_nodoOcupado* nodoOcupado;
pidCondicion = PID;
nodoOcupado = list_remove_by_condition(espacioOcupado,validarMismoPid);
byteInicial = nodoOcupado->comienzo * configuracion->tamano_pagina;
tamanio = nodoOcupado-> paginas * configuracion->tamano_pagina;
NumeroDePaginaCondicion = nodoOcupado->comienzo + nodoOcupado->paginas;
t_nodoLibre* nodoLibre = list_find(espacioLibre,buscarNodoComienzo);
if(nodoLibre == NULL)
{
nodoLibre = malloc(sizeof(t_nodoLibre));
nodoLibre->comienzo = nodoOcupado->comienzo;
nodoLibre->paginas = nodoOcupado->paginas;
list_add(espacioLibre,nodoLibre);
}
else
{
nodoLibre->comienzo = nodoOcupado->comienzo;
nodoLibre->paginas += nodoOcupado->paginas;
}
log_info(SwapLog,"Se libera proceso con PID %d, byte inicial %d y tamaño %d",PID,byteInicial,tamanio);
free(nodoOcupado);
}
int verificar_Posicion(t_datosParaPedirInstancia *datos, t_list *listaDeCajas)
{
char *recurso = malloc(strlen(datos->recurso) + 1);
strcpy(recurso,datos->recurso);
//busca en la lista de las cajas, la struct con el mismo recurso, para poder ver la posX y la posY
bool es_Misma_Caja(t_datosCaja *ptr)
{
return strcmp(ptr->caja_letra, recurso) == 0;
}
t_datosCaja *datosCaja = list_remove_by_condition(listaDeCajas, (void *) es_Misma_Caja);
//se fija si las posX y posY son iguales, tambien se fija si hay suficientes instancias
if((datosCaja->caja_posx == datos->posX) && (datosCaja->caja_posy == datos->posY) && (datosCaja->caja_instancias > 0))
{
datosCaja->caja_instancias--; //TODO
char letra = datosCaja->caja_letra[0];
restarRecurso(ListaItems, letra); //parte grafica
nivel_gui_dibujar(ListaItems);
list_add(listaDeCajas, datosCaja);
bool es_Mismo_Recurso(t_recursosDisponibles *ptr)
{
return strcmp(ptr->recurso_letra, recurso) == 0;
}
//edito la lista de recursos disponibles
t_recursosDisponibles *recursoDisponible = list_remove_by_condition(listaDeRecursosDisponibles, (void *) es_Mismo_Recurso);
recursoDisponible->recurso_instancias--;
list_add(listaDeRecursosDisponibles, recursoDisponible);
return YES;
}else
void terminaDeFormaAbortiva(int pid_local) {
//Ak aviso a consola
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID == pid_local);
}
printf("Se termino un CPU de forma abortiva\n");
if (pid_local == -1) {
} else {
t_sock_mje* socketConsola;
pthread_mutex_lock(&sem_l_Exec);
pcb_t* pcb_elegido = list_remove_by_condition(proc_Exec,
(void*) esEl_Pid);
pthread_mutex_unlock(&sem_l_Exec);
if(pcb_elegido == NULL){
pthread_mutex_lock(&sem_temp);
pcb_elegido = list_remove_by_condition(temp,
(void*) esEl_Pid);
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_l_Ready);
list_add_in_index(proc_Ready, 0, pcb_elegido);
log_debug(logger,"PCB con PID %d pasado al principio de READY xfin CPU",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
}else{
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso",
pid_local);
pthread_mutex_unlock(&sem_l_Exec);
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",
pid_local);
pthread_mutex_unlock(&sem_l_Reject);
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola, &pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("123456");
sem_post(&sem_REJECT_dispo);}
}
int a = 100;
pthread_exit(&a);
}
void finalizar_job_a_si_mismo(t_job* job) {
pthread_mutex_lock(&mutex_jobs);
bool _job(t_job* jobLista) {
return jobLista->id == job->id;
}
list_remove_by_condition(lista_jobs, (void*) _job);
pthread_mutex_unlock(&mutex_jobs);
pthread_exit(NULL);
}
int ansisop_wait (int socket_local, int pid_local){
int* tamanioNombreWS = recibirCpu(socket_local,sizeof(int),pid_local);
char* nombreSemaforo = recibirCpu(socket_local,*tamanioNombreWS,pid_local);
pcb_t* pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
int retorno=0;
t_datos_samaforos* datos_sem;
t_sock_mje* socketConsola;
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID==pid_local);
}
datos_sem = dictionary_get(reg_config.dic_semaforos,nombreSemaforo);
pthread_mutex_lock(&datos_sem->semsem);
if (datos_sem->valor > 0 && list_is_empty(datos_sem->cola_procesos)){
(datos_sem->valor)-- ;
retorno=0;
}
else if (datos_sem->valor <= 0) { // Bloqueo el proceso
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC x bloqueo de Semaforo",pid_local);
pthread_mutex_unlock(&sem_l_Exec);
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
if (socketConsola->proc_status==0){
t_pcb_bloqueado* elem_block = malloc(sizeof(t_pcb_bloqueado));
elem_block->pcb_bloqueado = pcb_elegido;
elem_block->tipo_de_bloqueo = 2;
elem_block->dispositivo = nombreSemaforo;
elem_block->unidades = 0;
pthread_mutex_lock(&sem_l_Block); // se bloquea
list_add(proc_Block, elem_block);
log_debug(logger, "PCB con PID %d pasado a cola BLOCK",pid_local);
pthread_mutex_unlock(&sem_l_Block);
sem_post(&sem_BLOCK_dispo);
}
else{
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a REJECT xfin de consola",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
sem_post(&sem_REJECT_dispo);
}
retorno = 1; // retorna 1 si se bloquea el proceso para que cambie de PCB
}
pthread_mutex_unlock(&datos_sem->semsem);
return retorno;
}
void remover_y_eliminar_conexion_cpu(uint32_t cpu_id)
{
bool _cpu_por_id(void* elemento)
{
return ((conexion_cpu_t*) elemento)->id == cpu_id;
}
pthread_mutex_lock(&MUTEX_CONEXIONES_CPU);
conexion_cpu_t* conn = list_remove_by_condition(CONEXIONES_CPU, _cpu_por_id);
pthread_mutex_unlock(&MUTEX_CONEXIONES_CPU);
cerrar_liberar(conn->socket);
free(conn);
}
infoNodo* avanzarClock(infoNodo* worker, t_list* listaNodos){
bool nodoConNumero(infoNodo* nodo){
return nodo->numero == worker->numero;
}
infoNodo* siguienteWorker = malloc(sizeof(infoNodo));
list_remove_by_condition(listaNodos, (void*)nodoConNumero);
list_add_in_index(listaNodos, list_size(listaNodos), worker);
siguienteWorker = list_get(listaNodos, 0);
return siguienteWorker;
}
void planificar_turnos(t_planificador **direccion_planificador)
{
t_planificador *planificador;
planificador= *direccion_planificador;
t_setColas *set = planificador->setColas;
if (!queue_is_empty(set->colaListos)) //Si hay personajes listos para planificar.
{
if((planificador->socketPersonajeActual == -1 || (planificador->quantumsRestantes)==0)) //Si todavia nunca planifico o ya no quedan quantums
{ pthread_mutex_lock(&set->semaforo);
sem_wait(&set->contadorDeListos);
planificador->socketPersonajeActual =((t_personaje*) queue_peek(set->colaListos))->socket; //Miro al primer personaje de la cola
sem_post(&set->contadorDeListos);
pthread_mutex_unlock(&set->semaforo);
planificador->quantumsRestantes=quantum; //Restauro el valor original de quantum
}
int respuestaDeTurno = enviar_permisoDeMovimiento(&planificador); //Le envio el turno
(planificador->quantumsRestantes)--; //Decremento el quantum
if(respuestaDeTurno == -1) //Si hubo algún error (el personaje se desconectó o no pudo responder por algún otro motivo)
{
t_personaje *personajeFalla;
pthread_mutex_lock(&set->semaforo);
sem_wait(&set->contadorDeListos);
personajeFalla = (t_personaje *) queue_pop(set->colaListos); //Saco al personaje de la cola
pthread_mutex_unlock(&set->semaforo);
close(planificador->socketPersonajeActual);//Cierro su socket
int _es_el_personaje(t_personaje* alguien)
{
return string_equals_ignore_case(alguien->remitente,personajeFalla->remitente);
}
pthread_mutex_lock(&semaforoConexiones);
list_remove_by_condition(todosLosPersonajesConectados, (void*) _es_el_personaje); //Lo saco de los conectados
log_info(planificador->logger,"%s se sacó de la lista de personajes conectados y de cola de listos porque hubo un error en recibir la respuesta de turno. \n", personajeFalla->remitente);
loguearConectados(planificador);
pthread_mutex_unlock(&semaforoConexiones);
free(personajeFalla->remitente);
free(personajeFalla);
}
else //Si no hubo errores
{
if(respuestaDeTurno==1) //Si luego del turno el personaje se bloqueó
void desbloquearPersonaje(datos_personaje_t *perDesbloqueado,
datos_planificador_t *datosPlan) {
int _is_personaje(datos_personaje_t *personaje) {
return personaje->simbolo == perDesbloqueado->simbolo;
}
t_list *personajesBloqueados = datosPlan->personajesBloqueados->elements;
t_queue *personajesListos = datosPlan->personajesListos;
datos_personaje_t *personajeDesbloqueado = list_remove_by_condition(
personajesBloqueados, (void *) _is_personaje);
coordenadas_destroy(perDesbloqueado->coordObjetivo);
perDesbloqueado->coordObjetivo = NULL;
perDesbloqueado->objetivo = '\0';
pthread_mutex_lock(datosPlan->mutexColas);
queue_push(personajesListos, personajeDesbloqueado);
pthread_mutex_unlock(datosPlan->mutexColas);
}
void ansisop_entradaSalida(int socket_local, int pid_local){
//se recibe parametros para IO
int* long_char = recibirCpu(socket_local,sizeof(int),pid_local);
char * dispositivo = recibirCpu(socket_local, *long_char,pid_local);
int * unidades = recibirCpu(socket_local,sizeof(int),pid_local);
//se recibe el PCB
pcb_t* pcb_bloqueado = recibirPCBdeCPU(socket_local,pid_local);
t_sock_mje* socketConsola;
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID==pid_local);
}
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC x bloqueo de IO",pid_local);
pthread_mutex_unlock(&sem_l_Exec);
if (socketConsola->proc_status==0){
t_pcb_bloqueado* elem_block = malloc(sizeof(t_pcb_bloqueado));
elem_block->pcb_bloqueado = pcb_bloqueado;
elem_block->tipo_de_bloqueo = 1;
elem_block->dispositivo = dispositivo;
elem_block->unidades = * unidades;
pthread_mutex_lock(&sem_l_Block); // se bloquea
list_add(proc_Block, elem_block);
log_debug(logger, "PCB con PID %d pasado a cola BLOCK",pid_local);
pthread_mutex_unlock(&sem_l_Block);
sem_post(&sem_BLOCK_dispo);
}
else{
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_bloqueado);
log_debug(logger, "PCB con PID %d pasado a REJECT xfin de consola",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
sem_post(&sem_REJECT_dispo);
}
}
void replanificarJobNuevoNodo(t_job* job, int idNodo, int idBloque) {
bool by_idNodo(t_nodo* n) {
return (*(n->id) == idNodo);
}
t_nodo* nodo = list_find(nodosList, (void*)by_idNodo);
if(nodo != NULL){ //si el nodo al que le fallo el map no se desconecto
bool _by_idNodo_idBloque(t_map* m) {
return (*(m->idNodo) == *(nodo->id)) && (*(m->idBloque) == idBloque);
}
t_map* map = list_remove_by_condition(job -> maps, (void*)_by_idNodo_idBloque);
replanificarMapFallado(job, map);
}else{
void verificarKoopa(char *sPayload){
tSimbolo *simbolo = deserializarSimbolo(sPayload);
free(sPayload);
log_info(logger, "El personaje %c finalizo su ejecucion", *simbolo);
bool _search_symbol(t_estado_personaje *personaje){
return(personaje->simbolo == *simbolo);
}
t_estado_personaje *personaje = list_remove_by_condition(personajes_jugando, (void *)_search_symbol);
free(personaje);
if(list_size(personajes_jugando) == 0){
log_debug(logger, "No hay tipitos jugando entonces ejecuto koopa y cierro todo");
cerrarTodo();
executeKoopa(pathScript);
exit(EXIT_SUCCESS);
}
}
void eliminar_conexion_proceso(sock_t* conexion)
{
bool _buscar_conexion(void* elemento)
{
return ((conexion_proceso_t*)elemento)->socket->fd == conexion->fd;
}
pthread_mutex_lock(&MUTEX_CONEXIONES_PROCESOS);
conexion_proceso_t* conexionp = list_remove_by_condition(CONEXIONES_PROCESOS, _buscar_conexion);
FD_CLR(conexion->fd, &READFDS_PROCESOS);
pthread_mutex_unlock(&MUTEX_CONEXIONES_PROCESOS);
loggear_desconexion_consola(conexionp->pid);
cerrar_liberar(conexionp->socket);
free(conexionp);
}
t_estadistica* sacarNodoEstadistica(int32_t PID)
{
pidCondicion = PID;
t_estadistica* nodo = list_remove_by_condition(estadisticasProcesos,compararNodoEstadistica);
return nodo;
}
//------------------------------------------------------------------------------------------
// ---------------------------------- atender_CPU -----------------------------------------
//Esta funcion representa un thread que trabaja con un CPU conectado por socket
//------------------------------------------------------------------------------------------
void *atender_CPU(int* socket_desc) {
//void perdioLaConexion();
//signal(SIGPIPE,perdioLaConexion);
int socket_local = *socket_desc;
//Empieza handshake
int* recibido = recibirCpu(socket_local, sizeof(int),-1);
if (*recibido == CPU) {
log_debug(logger, "Se ha conectado correctamente CPU: %d",socket_local);
}
//Confirmo conexio a cpu
int ok = OK;
enviarCPU(socket_local,sizeof(int),&ok,-1);
//Lo libero ya q era un malloc de atender_conexion_CPU
free(socket_desc);
int CpuActivo = 1; // 0 desactivado - 1 activado
int cambioPcb = 0; // 0 desactivado - 1 activado
pcb_t* pcb_elegido;
int pid_local = 0;
int* estado_proceso;
t_sock_mje* socketConsola;
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID==pid_local);
}
while (CpuActivo) {
//////////////////////////////////////////////
//Le otorgo un pcb para tarabajar/////////////
//////////////////////////////////////////////
pid_local = -1;
sem_wait(&sem_READY_dispo); // espero que haya un proceso en READY disponible
pthread_mutex_lock(&sem_l_Ready);
pcb_elegido = list_remove(proc_Ready, 0); //Agarro el pcb
pid_local = *(pcb_elegido->PID);
log_debug(logger, "PCB con PID %d sacado de READY", pid_local);
pthread_mutex_unlock(&sem_l_Ready);
pthread_mutex_lock(&sem_temp);
list_add(temp,pcb_elegido); //Agarro el pcb
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
cambioPcb = 0;
if (socketConsola->proc_status!=0){ //verifico si se cerro la consola del proceso
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a REJECT xfin de consola",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
sem_post(&sem_REJECT_dispo);
cambioPcb = 1;
}
if(!cambioPcb){
enviarPCB(pcb_elegido, socket_local, reg_config.quantum, reg_config.quantum_sleep);
//Guardo pcb en la lista de ejecutandose
pthread_mutex_lock(&sem_temp);
list_remove_by_condition(temp, (void*) esEl_Pid);
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_l_Exec);
list_add(proc_Exec, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXEC", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
}
while (!cambioPcb && CpuActivo){
estado_proceso = recibirCpu(socket_local,sizeof(int),pid_local);
switch (*estado_proceso) {
case FIN_QUANTUM:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC x fin Quantum",pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Ready);
list_add(proc_Ready, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a READY x fin Quantum",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
sem_post(&sem_READY_dispo);
cambioPcb = 1;//activo el cambio del pcb ya q termino el quantum
}
break;
case FIN_PROC:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Exit);
list_add(proc_Exit, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",pid_local);
pthread_mutex_unlock(&sem_l_Exit);
cambioPcb = 1;//activo el cambio del pcb ya q termino el proceso
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("Proceso_Finalizado_Correctamente");
sem_post(&sem_EXIT_dispo);
}
break;
case FIN_CPU:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin CPU", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Ready);
list_add_in_index(proc_Ready, 0, pcb_elegido);
log_debug(logger,"PCB con PID %d pasado al principio de READY xfin CPU",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
sem_post(&sem_READY_dispo);
CpuActivo = 0;
}
//LIBERAR PCB
//BORAR CONSOLA DEL DICCIONARIO
break;
case SOLIC_IO: //es la primitiva entradaSalida
{
ansisop_entradaSalida(socket_local, pid_local);
cambioPcb = 1;//activo el cambio del pcb ya q se bloqueo el proceso
}
break;
case OBT_VALOR: //es la primitiva obtenerValorCompartida
ansisop_obtenerValorCompartida (socket_local,pid_local);
break;
case GRABA_VALOR: //es la primitiva asignarValorCompartida
ansisop_asignarValorCompartida (socket_local,pid_local);
break;
case WAIT_SEM: // es la primitiva wait
{
cambioPcb = ansisop_wait (socket_local, pid_local);
enviarCPU(socket_local,sizeof(int),&cambioPcb,pid_local);
// si cambioPcb es 0 significa que el wait no bloqueo y el cpu puede seguir procesando,
// si es 1 entonces el proceso se bloqueo y el CPU debe tomar otro PCB
break;
}
case SIGNAL_SEM: // es la primitiva signal
ansisop_signal(socket_local,pid_local);
break;
case IMPRIMIR: // es la primitiva imprimir
{
int* valoraImprimir = recibirCpu(socket_local,sizeof(int),pid_local);
/* t_sock_mje* */ socketConsola = dictionary_get(dict_pid_consola,&pid_local);
int envVar = 100;
if(socketConsola->proc_status == 0){
enviarCPUConHeader(socketConsola->socket_dest,envVar,sizeof(int),valoraImprimir,pid_local);
}
free(valoraImprimir);
break;
}
case IMPRIMIR_TXT: // es la primitiva imprimirTexto
{
/* t_sock_mje* */ socketConsola = dictionary_get(dict_pid_consola,&pid_local);
int* tamanioAImprimir = recibirCpu(socket_local,sizeof(int),pid_local);
void* mensaje = recibirCpu(socket_local,*tamanioAImprimir,pid_local);
int envTexto = 101;
if(socketConsola->proc_status == 0){
enviarCPUConHeader(socketConsola->socket_dest,envTexto,sizeof(int),tamanioAImprimir,pid_local);
enviarCPU(socketConsola->socket_dest,*tamanioAImprimir,mensaje,pid_local);
}
free(tamanioAImprimir);
free(mensaje);
break;
}
case SEG_FAULT:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
cambioPcb = 1;//activo el cambio del pcb ya q termino el proceso
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("Proceso_Produjo_SEG_FAULT");
sem_post(&sem_REJECT_dispo);
break;
}
default:
break;
}
free(estado_proceso);
}
}
}
//---------------------------------------------------------------------------
void hilo_reduce_job(t_reduce_dest* reduce_dest) {
int result = 1;
uint32_t answer_reduce = 0;
mostrar_reduce_dest(reduce_dest);
int _isNodoHost(t_reduce_nodo_dest* nodo) {
return reduce_dest->id_nodo_host == nodo->id_nodo;
}
t_reduce_nodo_dest* nodo_host = list_remove_by_condition(reduce_dest->list_nodos, (void *)_isNodoHost);
char *ip_nodo = from_int_to_inet_addr(nodo_host->ip_nodo);
int socket_nodo = solicitarConexionConNodo(ip_nodo, nodo_host->puerto_nodo, nodo_host->id_nodo);
if(socket_nodo != 1) {
result = enviar_infoReduce_job(socket_nodo, reduce_dest, nodo_host);
result = (result > 0) ? receive_answer_reduce(socket_nodo, &answer_reduce) : result;
} else {
answer_reduce = INCORRECT_NODO;
}
if(result <= 0) {
answer_reduce = REDUCE_NOT_OK;
}
t_buffer* reduce_result_buff;
switch(answer_reduce) {
case REDUCE_OK: case REDUCE_NOT_OK:
reduce_result_buff = buffer_create_with_protocol(answer_reduce);
if(reduce_dest->prot == ORDER_PARTIAL_REDUCE) {
buffer_add_int(reduce_result_buff, reduce_dest->id_nodo_host);
}
break;
case INCORRECT_NODO:
reduce_result_buff = buffer_create_with_protocol(NODO_NOT_FOUND);
if(reduce_dest->prot == ORDER_REDUCE) {
buffer_add_int(reduce_result_buff, 1);
buffer_add_int(reduce_result_buff, nodo_host->id_nodo);
}
break;
case NODO_NOT_FOUND:
reduce_result_buff = buffer_create_with_protocol(NODO_NOT_FOUND);
if(reduce_dest->prot == ORDER_REDUCE) {
uint32_t i,amount_nodes = 0;
result = receive_int_in_order(socket_nodo, &amount_nodes);
buffer_add_int(reduce_result_buff, amount_nodes);
for(i=0;(i<amount_nodes) && (result > 0); i++) {
uint32_t id_nodo = 0;
result = receive_int_in_order(socket_nodo, &id_nodo);
buffer_add_int(reduce_result_buff, id_nodo);
}
if(result <= 0) {
buffer_destroy(reduce_result_buff);
reduce_result_buff = buffer_create_with_protocol(REDUCE_NOT_OK);
}
}
break;
case TEMP_NOT_FOUND:
reduce_result_buff = buffer_create_with_protocol(TEMP_NOT_FOUND);
uint32_t i,amount_temps = 0;
result = receive_int_in_order(socket_nodo, &amount_temps);
buffer_add_int(reduce_result_buff, amount_temps);
for(i=0;(i<amount_temps) && (result > 0); i++) {
uint32_t id_nodo = 0;
result = receive_int_in_order(socket_nodo, &id_nodo);
if(reduce_dest->prot == ORDER_REDUCE) {
buffer_add_int(reduce_result_buff, id_nodo);
}
char* path = NULL;
result = (result > 0) ? receive_dinamic_array_in_order(socket_nodo, (void **) &path) : result;
if(path != NULL) {
buffer_add_string(reduce_result_buff, path);
free(path);
}
}
if(result <= 0) {
buffer_destroy(reduce_result_buff);
reduce_result_buff = buffer_create_with_protocol(REDUCE_NOT_OK);
}
break;
default:
reduce_result_buff = buffer_create_with_protocol(REDUCE_NOT_OK);
break;
}
if((socket_nodo != -1) && (result > 0)) {
close(socket_nodo);
}
pthread_mutex_lock(&conex_marta_ready);
result = (result > 0) ? send_buffer_and_destroy(socket_marta, reduce_result_buff) : result;
pthread_mutex_unlock(&conex_marta_ready);
free(ip_nodo);
free_reduce_nodo_dest(nodo_host);
free_reduce_dest(reduce_dest);
}
void eliminar_referencia(int page_referenced, t_proceso * proceso) {
bool la_referenciada(int ref) {
return (ref == page_referenced);
}
list_remove_by_condition(proceso->referencias, (void *) la_referenciada);
}
}
i++;
}
return item;
}
void borrarPersonajeListaPersonajes(t_list * lista, char * simbolo){
int32_t _esta_el_personaje(t_personaje_niv1 * personaje){
return string_equals_ignore_case(personaje->simbolo,simbolo);
}
t_personaje_niv1 * pers = list_remove_by_condition(lista, (void*) _esta_el_personaje);
personaje_destroy(pers);
}
void personaje_destroy(t_personaje_niv1 * pers){
free(pers->posicion);
//list_destroy(pers->recursosActuales);
//free(pers->simbolo);
free(pers);
}
t_personaje_niv1 * buscarPersonajeListaPersonajes(t_list * lista, char * simbolo){
/*
* @NAME: list_remove_and_destroy_by_condition
* @DESC: Remueve y destruye los elementos de la lista que hagan que condition devuelva != 0.
*/
void list_remove_and_destroy_by_condition(t_list *self, bool(*condition)(void*), void(*element_destroyer)(void*)) {
void* data = list_remove_by_condition(self, condition);
element_destroyer(data);
}
void procesar_mensaje (int sock_plataforma, int nro_nivel, t_paquete paqueteAux, t_list *ListaItems, t_list *ListaPersonajes, t_configNivel datosNivel, pthread_mutex_t *mutexListaItems, pthread_mutex_t *mutexListaPersonajes, pthread_mutex_t *mutexEnemigos, t_log *logger)
{
switch(paqueteAux.selector)
{
case NUEVO_PERSONAJE:
{
t_nuevoPersonaje *nuevoPersonaje = (t_nuevoPersonaje *) paqueteAux.datos;
pthread_mutex_lock(mutexListaItems);
pthread_mutex_lock(mutexListaPersonajes);
t_personaje *personaje = (t_personaje *) malloc(sizeof(t_personaje));
personaje->personajeID = nuevoPersonaje->personajeID;
personaje->nivelID = nuevoPersonaje->nivelID;
personaje->recursosAsignados = list_create();
personaje->recursosNecesitados = list_create();
personaje->posX = 0;
personaje->posY = 0;
personaje->recursoBloqueante = '\0';
personaje->prioridad = prioridad;
++prioridad;
crearListaRecursosNecesitados(nuevoPersonaje->recursosNecesitados,personaje->recursosNecesitados);
ITEM_NIVEL *itemPersonaje = malloc(sizeof(ITEM_NIVEL));
itemPersonaje->id = nuevoPersonaje->personajeID;
itemPersonaje->posx = 0;
itemPersonaje->posy = 0;
itemPersonaje->item_type = PERSONAJE_ITEM_TYPE;
list_add(ListaItems,itemPersonaje);
list_add(ListaPersonajes,personaje);
nivel_gui_dibujar(ListaItems,datosNivel.nombre);
pthread_mutex_unlock(mutexListaItems);
pthread_mutex_unlock(mutexListaPersonajes);
log_info(logger, "Personaje: %c conectado.", personaje->personajeID);
break;
}
case UBICACION_RECURSO:
{
log_info(logger, "Mensaje UBICACION_RECURSO recibido.");
t_ubicacionRecurso *ubicacionRecurso = (t_ubicacionRecurso *) paqueteAux.datos;
pthread_mutex_lock(mutexListaItems);
bool _funcBuscarRecurso(ITEM_NIVEL *item) {
return item->id == ubicacionRecurso->recursoID;
}
ITEM_NIVEL *itemBuscado = list_find(ListaItems,(void *)_funcBuscarRecurso);
pthread_mutex_unlock(mutexListaItems);
ubicacionRecurso->posX = itemBuscado->posx;
ubicacionRecurso->posY = itemBuscado->posy;
t_paquete *paquete = empaquetar(UBICACION_RECURSO, sizeof(t_ubicacionRecurso), ubicacionRecurso);
if(send(sock_plataforma,paquete,sizeof(t_paquete),0) == -1)
{
log_error(logger, "Error al enviar mensaje UBICACION_RECURSO.");
exit(1);
}
free(paquete);
log_info(logger, "Mensaje UBICACION_RECURSO enviado.");
break;
}
case UBICACION_PERSONAJE:
{
log_info(logger, "Mensaje UBICACION_PERSONAJE recibido.");
t_ubicacionPersonaje *ubicacionPersonaje = (t_ubicacionPersonaje *) paqueteAux.datos;
pthread_mutex_lock(mutexListaItems);
pthread_mutex_lock(mutexListaPersonajes);
bool _funcBuscarEnListaItems(ITEM_NIVEL *personaje) {
return personaje->id == ubicacionPersonaje->personajeID;
}
ITEM_NIVEL *itemPersonaje = list_find(ListaItems,(void *)_funcBuscarEnListaItems);
bool _funcBuscarEnListaPersonajes(t_personaje *personaje) {
return personaje->personajeID == ubicacionPersonaje->personajeID;
}
t_personaje *personaje = list_find(ListaPersonajes,(void *)_funcBuscarEnListaPersonajes);
if((itemPersonaje != NULL) && (personaje != NULL))
{
itemPersonaje->posx = ubicacionPersonaje->posX;
itemPersonaje->posy = ubicacionPersonaje->posY;
personaje->posX = ubicacionPersonaje->posX;
personaje->posY = ubicacionPersonaje->posY;
bool _funcPisarEnemigo(ITEM_NIVEL *itemEnemigo)
{
if(itemEnemigo->item_type == ENEMIGO_ITEM_TYPE)
{
return ((itemPersonaje->posx == itemEnemigo->posx) && (itemPersonaje->posy == itemEnemigo->posy));
}
return false;
}
bool muertePorEnemigo = list_any_satisfy(ListaItems, (void *) _funcPisarEnemigo);
if(muertePorEnemigo)
{
t_victimaEnemigo victimaEnemigo;
victimaEnemigo.personajeID = itemPersonaje->id;
victimaEnemigo.nivelID = nro_nivel;
t_paquete *paquete = empaquetar(VICTIMA_ENEMIGO, sizeof(t_victimaEnemigo), &victimaEnemigo);
if(send(sock_plataforma, paquete, sizeof(t_paquete), 0) == -1)
{
log_error(logger, "Error al enviar mensaje VICTIMA_ENEMIGO.");
exit(1);
}
free(paquete);
log_info(logger, "Mensaje VICTIMA_ENEMIGO enviado.");
}
nivel_gui_dibujar(ListaItems,datosNivel.nombre);
pthread_mutex_unlock(mutexListaItems);
pthread_mutex_unlock(mutexListaPersonajes);
}
break;
}
case INSTANCIA_RECURSO:
{
log_info(logger, "Mensaje INSTANCIA_RECURSO recibido.");
t_instanciaRecurso *instanciaRecurso = (t_instanciaRecurso *) paqueteAux.datos;
pthread_mutex_lock(mutexListaItems);
pthread_mutex_lock(mutexListaPersonajes);
bool _funcBuscarRecursoEnItems(ITEM_NIVEL *rec) {
return rec->id == instanciaRecurso->recursoID;
}
ITEM_NIVEL *itemRecurso = list_find(ListaItems,(void *)_funcBuscarRecursoEnItems);
bool _funcBuscarPersonaje(t_personaje *pers) {
return pers->personajeID == instanciaRecurso->personajeID;
}
t_personaje *personaje = list_find(ListaPersonajes,(void *)_funcBuscarPersonaje);
if(personaje != NULL)
{
if(itemRecurso->quantity)
{
--itemRecurso->quantity;
bool _funcBuscarRecurso(t_recurso *recurso) {
return recurso->recursoID == instanciaRecurso->recursoID;
}
t_recurso *recursoAsignado = list_find(personaje->recursosAsignados, (void *) _funcBuscarRecurso);
t_recurso *recursoNecesitado = list_find(personaje->recursosNecesitados, (void *) _funcBuscarRecurso);
if(recursoAsignado != NULL)
{
++recursoAsignado->cantidad;
}
else
{
t_recurso *recurso = malloc(sizeof(t_recurso));
recurso->recursoID = instanciaRecurso->recursoID;
recurso->cantidad = 1;
list_add (personaje->recursosAsignados, recurso);
}
--recursoNecesitado->cantidad;
if(recursoNecesitado->cantidad == 0)
{
list_remove_by_condition(personaje->recursosNecesitados, (void *) _funcBuscarRecurso);
}
if (send(sock_plataforma,&paqueteAux,sizeof(t_paquete),0) == -1)
{
log_error(logger, "Error al enviar mensaje RESPUESTA.");
exit(1);
}
log_info(logger, "Mensaje INSTANCIA_RECURSO enviado.");
}
else
{
personaje->recursoBloqueante = instanciaRecurso->recursoID;
}
}
