void* conectarseConWorkerRedGlobal(void* params){
parametrosReduccionGlobal* parametrosConexion= malloc(sizeof(parametrosReduccionGlobal));
respuestaReduccionGlobal* infoRedGlobal =(respuestaReduccionGlobal*) params;
respuesta confirmacionWorker;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoRedGlobal->ip.cadena,infoRedGlobal->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Inicio Red. Global con Worker %d para Job %d", infoRedGlobal->numero, infoRedGlobal->job);
struct stat fileStat;
if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaReductor.cadena,O_RDWR);
int size = fileStat.st_size;
parametrosConexion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
parametrosConexion->contenidoScript.longitud = size;
parametrosConexion->archivoTemporal.cadena = strdup(infoRedGlobal->archivoTemporal.cadena);
parametrosConexion->archivoTemporal.longitud = infoRedGlobal->archivoTemporal.longitud;
parametrosConexion->infoWorkers = list_create();
list_add_all(parametrosConexion->infoWorkers,infoRedGlobal->parametros->infoWorkers);
empaquetar(socketWorker, mensajeProcesarRedGlobal, 0, parametrosConexion);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(parametrosConexion->contenidoScript.cadena, parametrosConexion->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeOk:
case mensajeRedGlobalCompleta:
log_trace(loggerMaster, "Informo YAMA fin de Reduccion Global en nodo %i",infoRedGlobal->numero);
empaquetar(socketYama, mensajeRedGlobalCompleta, 0 , 0);
estadisticas->cantTareas[RED_GLOBAL]++;
finalizarTiempo(estadisticas->tiempoFinRedGlobal,infoRedGlobal->numero);
break;
case mensajeDesconexion:
case mensajeFalloRedGlobal:
log_trace(loggerMaster, "Informo a YAMA fallo en Reduccion Global del nodo %d.",infoRedGlobal->numero);
estadisticas->cantFallos++;
mandarFalloEnReduccion();
break;
}
return 0;
}
void* conectarseConWorkersTransformacion(void* params) {
parametrosTransformacion* infoTransformacion= (parametrosTransformacion*)params;
respuesta confirmacionWorker;
bloqueYNodo* bloqueOK;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoTransformacion->ip.cadena,infoTransformacion->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarAReplanificar(infoTransformacion);
return 0;
}
log_trace(loggerMaster, "Conexion con Worker %d para bloque %d", infoTransformacion->numero, infoTransformacion->bloquesConSusArchivos.numBloque);
struct stat fileStat;
if(stat(miJob->rutaTransformador.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaTransformador.cadena,O_RDWR);
int size = fileStat.st_size;
infoTransformacion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
infoTransformacion->contenidoScript.longitud = size;
empaquetar(socketWorker, mensajeProcesarTransformacion, 0, infoTransformacion);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(infoTransformacion->contenidoScript.cadena, infoTransformacion->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeTransformacionCompleta:
log_trace(loggerMaster, "Informo a YAMA fin Transformacion para bloque %d en nodo %d.",infoTransformacion->bloquesConSusArchivos.numBloque,infoTransformacion->numero);
bloqueOK = malloc(sizeof(bloqueYNodo));
bloqueOK->workerId = infoTransformacion->numero;
bloqueOK->bloque = infoTransformacion->bloquesConSusArchivos.numBloque;
empaquetar(socketYama, mensajeTransformacionCompleta, 0 , bloqueOK);
finalizarTiempo(estadisticas->tiempoFinTrans,bloqueOK->bloque);
estadisticas->cantTareas[TRANSFORMACION]++;
free(bloqueOK);
break;
case mensajeDesconexion:
mandarAReplanificar(infoTransformacion);
break;
}
return 0;
}
void* conectarseConWorkersRedLocal(void* params){
parametrosReduccionLocal* infoRedLocal= (parametrosReduccionLocal*)params;
respuesta confirmacionWorker;
int numeroNodo;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoRedLocal->ip.cadena,infoRedLocal->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Conexion con Worker %d para estos tmp %d", infoRedLocal->numero, list_size(infoRedLocal->archivosTemporales));
struct stat fileStat;
if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaReductor.cadena,O_RDWR);
int size = fileStat.st_size;
infoRedLocal->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
infoRedLocal->contenidoScript.longitud = size;
empaquetar(socketWorker, mensajeProcesarRedLocal, 0, infoRedLocal);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(infoRedLocal->contenidoScript.cadena, infoRedLocal->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeRedLocalCompleta:
log_trace(loggerMaster, "Informo a YAMA fin Reduccion Local en nodo %d.",infoRedLocal->numero);
numeroNodo = *(int*)confirmacionWorker.envio;
empaquetar(socketYama, mensajeRedLocalCompleta, 0 , &numeroNodo);
finalizarTiempo(estadisticas->tiempoFinRedLocal,numeroNodo);
estadisticas->cantTareas[RED_LOCAL]++;
break;
case mensajeDesconexion:
case mensajeFalloRedLocal:
log_trace(loggerMaster, "Informo a YAMA fallo en Reduccion Local en nodo %d.",infoRedLocal->numero);
estadisticas->cantFallos++;
mandarFalloEnReduccion();
break;
}
return 0;
}
void mandarAReplanificar(parametrosTransformacion* infoTransformacion){
log_trace(loggerMaster, "Informo a YAMA replanificacion nodo %d.",infoTransformacion->numero);
bloqueYNodo* bloqueReplanificar=malloc(sizeof(bloqueYNodo));
bloqueReplanificar->workerId = infoTransformacion->numero;
bloqueReplanificar->bloque = infoTransformacion->bloquesConSusArchivos.numBloque;
empaquetar(socketYama, mensajeFalloTransformacion, 0 , bloqueReplanificar);
estadisticas->cantFallos++;
free(bloqueReplanificar);
}
int main (int argc, char* argv[])
{
int bitsPorMuestreo;
if ( argc != 4 ){
printf( "Faltan argumentos - Deben ser 3 archivos:\n" );
printf( " - archivo de entrada 1 (monofonico)\n" );
printf( " - archivo de entrada 2 (monofonico)\n" );
printf( " - archivo de salida (esfonico)\n" );
system( "pause" );
return -1;
}
printf( "Archivo fuente 1 %s\n", argv[1] );
printf( "Archivo fuente 2 %s\n", argv[2] );
printf( "Archivo Destino %s\n", argv[3] );
system( "pause" );
cargarWAVE( &Header, &pistaEntrada1, argv[1] );
cargarWAVE( &Header, &pistaEntrada2, argv[2] );
bitsPorMuestreo = detectarBitsPorMuestreo( &pistaEntrada1 );
if ( bitsPorMuestreo != detectarBitsPorMuestreo( &pistaEntrada2 ) ){
printf( "Los archivos tienen diferente numero de bits por muestreo\n" );
}
empaquetar( &pistaEntrada1, bitsPorMuestreo );
empaquetar( &pistaEntrada2, bitsPorMuestreo );
pistaSalida.bitsPerSample = bitsPorMuestreo;
pistaSalida.numSamples = pistaEntrada1.numSamples;
pistaSalida.SoundLength = 2*pistaEntrada1.SoundLength;
pistaSalida.Sample = (unsigned short*)malloc( pistaSalida.SoundLength );
unirArchivosWAVE( pistaEntrada1.numSamples, pistaEntrada1.Sample, pistaEntrada2.Sample, pistaSalida.Sample, bitsPorMuestreo );
corregirHeader( &Header );
desempaquetar( &pistaSalida, bitsPorMuestreo );
escribirWAVE( &Header, &pistaSalida, argv[3] );
printf ("Concluy� exitosamente.\n");
system("pause");
return 0;
}
void* conectarseConWorkerAlmacenamiento(void* params){
parametrosAlmacenamiento* parametrosConexion= malloc(sizeof(parametrosAlmacenamiento));
respuestaAlmacenamiento* almacenamiento =(respuestaAlmacenamiento*) params;
respuesta confirmacionWorker ;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(almacenamiento->ip.cadena,almacenamiento->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Inicio Almacenamiento Final con Worker %d", almacenamiento->nodo);
parametrosConexion->rutaAlmacenamiento.longitud = miJob->rutaResultado.longitud;
parametrosConexion->rutaAlmacenamiento.cadena= strdup(miJob->rutaResultado.cadena);
parametrosConexion->archivoTemporal.cadena = strdup(almacenamiento->archivo.cadena);
parametrosConexion->archivoTemporal.longitud = almacenamiento->archivo.longitud;
empaquetar(socketWorker, mensajeProcesarAlmacenamiento, 0, parametrosConexion);
confirmacionWorker = desempaquetar(socketWorker);
switch(confirmacionWorker.idMensaje){
case mensajeAlmacenamientoCompleto:
log_trace(loggerMaster, "Informo YAMA fin de Almacenamiento Final en nodo.",almacenamiento->nodo);
empaquetar(socketYama, mensajeAlmacenamientoCompleto, 0 , 0);
break;
case mensajeFalloAlmacenamiento:
case mensajeDesconexion:
log_trace(loggerMaster, "Informo a YAMA fallo en Almacenamiento Final del nodo %d.",almacenamiento->nodo);
estadisticas->cantFallos++;
empaquetar(socketYama, mensajeFalloAlmacenamiento, 0 , 0);
break;
}
return 0;
}
void enviarJobAYama(job* miJob) {
empaquetar(socketYama,mensajeSolicitudTransformacion, 0 ,miJob);
log_trace(loggerMaster,"Enviando solicitud de etapa Transformacion a YAMA");
respuesta respuestaYama = desempaquetar(socketYama);
if(respuestaYama.idMensaje != mensajeOk){
log_error(loggerMaster,"No se pudo iniciar correctamente el job");
exit(1);
}
log_trace(loggerMaster, "Envio correcto de datos a Yama.");
}
void planificar(job* job){
pthread_mutex_lock(&mutexJobs);
infoNodo* worker = malloc(sizeof(infoNodo));
pthread_mutex_unlock(&mutexJobs);
t_list* listaNodos = list_create();
int nodos,bloques;
informacionArchivoFsYama* infoArchivo = recibirInfoArchivo(job);//RECIBE BLOQUES Y TAMAÑO DE FS SOBRE EL ARCHIVO DEL JOB
llenarListaNodos(listaNodos,infoArchivo);
if(list_is_empty(listaNodos)){
finalizarJob(job,TRANSFORMACION,FALLO_INGRESO);
}
calcularDisponibilidadWorkers(listaNodos);
worker = posicionarClock(listaNodos);//POSICIONA EL CLOCK EN EL WORKER DE MAYOR DISPONIBILIDAD
calcularNodosYBloques(infoArchivo,&nodos,&bloques);
bool** matrix = llenarMatrizNodosBloques(infoArchivo,nodos,bloques);
respuestaSolicitudTransformacion* respuestaMaster = moverClock(worker, listaNodos, matrix, infoArchivo->informacionBloques,job->id);
empaquetar(job->socketFd,mensajeRespuestaTransformacion,0,respuestaMaster);
actualizarCargasNodos(job->id,TRANSFORMACION);
planificarReduccionesLocales(job,matrix,respuestaMaster,nodos,bloques);
enviarReduccionGlobalAMaster(job);
actualizarCargasNodos(job->id,RED_GLOBAL);
mostrarTablaDeEstados();
esperarRespuestaReduccionDeMaster(job);
realizarAlmacenamientoFinal(job);
free(infoArchivo);
free(respuestaMaster);
free(listaNodos);
free(worker);
finalizarJob(job,4,OK);
}
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;
}
}
void mandarFalloEnReduccion(){
estadisticas->cantFallos++;
empaquetar(socketYama,mensajeFalloReduccion,0,0);
}
