int main(void) {
puts("!!!Hola Job!!!"); /* prints !!!Hola Job!!! */
lectura* resultado_lectura;
if ((resultado_lectura = leerConfiguracion()) == NULL) {
return EXIT_FAILURE;}
script* resultado = mapearScriptsAMemoria(resultado_lectura->mapper,
resultado_lectura->reducer);
conexionMarta* martu = malloc(sizeof(conexionMarta));
martu->ip_Marta = malloc(16);
strcpy(martu->ip_Marta,resultado_lectura->ipMarta);
martu->puerto_Principal = malloc(6);
strcpy(martu->puerto_Principal,resultado_lectura->puertoMarta);
establecerConexiones(resultado_lectura->puertoSalida, martu,
resultado_lectura->archivos, resultado_lectura->combiner,
resultado, resultado_lectura->nombreJob, resultado_lectura->resultado);
free(resultado);
liberarLectura(resultado_lectura);
free(resultado_lectura);
return EXIT_SUCCESS;
}
int main() {
system("clear");
config = leerConfiguracion();
//Inicia el Socket para conectarse con la Memoria
printf("Conectando a la Memoria (%s : %s)... ", config->ipMemoria,config->puertoMemoria);
client_init(&socketMemoria, config->ipMemoria, config->puertoMemoria);
printf("OK\n");
pthread_t vectorHilos[config->cantidadHilos];
pthread_attr_t atrib;
pthread_mutex_init(&mutex, NULL);
pthread_mutex_init(&mutexConectarPlanificador,NULL);
pthread_attr_init(&atrib);
int i;
for (i = 0; i < config->cantidadHilos; i++) {
pthread_create(&vectorHilos[i], &atrib, procesarInstruccion, NULL);
}
for (i = 0; i < config->cantidadHilos; i++) {
pthread_join(vectorHilos[i], NULL);
}
printf("Finalizo el planificador...\n");
pthread_mutex_destroy(&mutex);
pthread_mutex_destroy(&mutexConectarPlanificador);
return 0;
}
void inicializarConfiguracion(void){
archLog = log_crear(PATHLOG);
struct stat file_info;
int control = lstat(PATH, &file_info);
if (control == -1){
log_escribir(archLog, "Leer archivo de configuracion", ERROR, "El archivo no existe");
}
else{
leerConfiguracion(PATH);
imprimirConfiguracion();
}
}
FILE* iniciar_archivo_swap(void) {
tconfig_swap *config_swap = leerConfiguracion();
FILE* swap = fopen(config_swap->nombreSwap, "wb+"); //rb+ para archivo binario
//FILE* swap = fopen(config_swap->nombreSwap, "rb+"); para probar
size_t tamanio_swap = config_swap->tamanioPagina * config_swap->cantidadPaginas;
//rellenamos en cero (char '\0' es 0)
int i ;
char cero = 0;
for (i = 0 ; i < tamanio_swap; i++)
fwrite(&cero, sizeof(char), 1, swap);
fseek(swap, 0, SEEK_SET);
return swap;
}
int llamameParaEjecutarReduceLocal(trabajoReduce *trabajo_reduce) {
char *ruta_reducer;
lectura *leido = leerConfiguracion();
rutas_temporales *rutas_temp = crearDirectorioTemporal(leido->dirTemp,
trabajo_reduce->nombreJob);
ruta_reducer = bajarScriptAPlano(trabajo_reduce->instruccionReduce,
trabajo_reduce->tamanioScriptReduce, rutas_temp->ruta_temp, 1,trabajo_reduce->nombreJob);
aplicarReduceLocal(ruta_reducer, rutas_temp->ruta_temp,
trabajo_reduce->nombreJob);
free(ruta_reducer);
liberarRutasTemporales(rutas_temp);
return 1;
}
void unmapearDataBinAMemoria(){
pthread_mutex_lock(&mutex_munmap);
lectura *resultado_lectura = leerConfiguracion();
int file_descriptor = open(resultado_lectura->nombreBin,O_RDWR);
struct stat file;
fstat(file_descriptor, &file);
int tamanio_archivo = file.st_size;
munmap(data_bin_mapeado,tamanio_archivo);
close(file_descriptor);
liberarLectura(resultado_lectura);
pthread_mutex_unlock(&mutex_munmap);
}
VentanaPrincipal::VentanaPrincipal()
{
editorTexto = new EditorCodigo;
setCentralWidget(editorTexto);
crearAcciones();
crearMenus();
crearToolBars();
crearBarraEstado();
crearWidgetsMovibles();
leerConfiguracion();
connect(editorTexto->document(),
SIGNAL(contentsChanged()),
this,
SLOT(archivoFueModificado()));
setArchivoActual("");
setUnifiedTitleAndToolBarOnMac(true);
}
int main(int argc, char * argv[]) {
int s, r;
struct sockaddr_in dest;
char buffer[MAXBUF];
struct Mensaje mensaje;
if (argc < 3) {
puts("Usage ./cliente [nombre] [pos1] ...");
return EXIT_FAILURE;
}
signal(SIGKILL, handler_seniales);
signal(SIGTERM, handler_seniales);
cantidad_barcos_hundidos = 0;
// Validacion de las posiciones de la matriz
cantidad_barcos = argc - 2; // Le resto los primeros 2 argumentos: ejecutable y nombre de jugador
//char * posiciones[cantidad_barcos];
if (validarPosiciones(argv, posiciones_barcos) == -1) {
return EXIT_FAILURE;
}
//posiciones_barcos = posiciones;
// Leo ip y puerto del servidor del archivo de configuracion
struct Conexion conexion = leerConfiguracion();
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
return EXIT_FAILURE;
}
/*---Initialize server address/port struct---*/
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(conexion.puerto);
if (inet_aton(conexion.ip, &dest.sin_addr.s_addr) == 0) {
perror(conexion.ip);
return EXIT_FAILURE;
}
/*---Connect to server---*/
if (connect(sockfd, &dest, sizeof(dest)) != 0) {
perror("Connect ");
return EXIT_FAILURE;
}
bzero(buffer, MAXBUF);
// Enviar nombre jugador
mensaje.tipo = Registra_Nombre;
strcpy(mensaje.contenido, argv[1]);
sleep(2);
s = send(sockfd, &mensaje, sizeof(mensaje), 0);
if (s == -1) {
perror("Error al enviar el nombre del jugador");
return EXIT_FAILURE;
}
// Recibo la estructura del jugador registrado.
r = recv(sockfd, buffer, sizeof(struct MensajeNIPC), 0);
memcpy(&jugador, buffer + sizeof(TIPO_MENSAJE) + sizeof(int),
sizeof(struct Jugador));
printf("Se ha registrado en el servidor como el jugador %s.\n",
jugador.nombre);
if (mostrar_lista() == -1) {
return EXIT_FAILURE;
}
desconectar();
liberar_recursos();
return EXIT_SUCCESS;
}
int ejecutarMap(trabajoMap *datos_map) {
int resultado;
char *ruta_mapper;
lectura *leido = leerConfiguracion();
char * p;
p = string_itoa(datos_map->nroBloque);
char * info_comienzo_map = malloc(strlen("Comienzo map en bloque ") + 4 + strlen(" -> Job-") +4 + 1);
strcpy(info_comienzo_map,"Comienzo map en bloque ");
strcat(info_comienzo_map,p);
strcat(info_comienzo_map," -> Job-");
char * pepe = string_itoa(datos_map->nombreJob);
strcat(info_comienzo_map,pepe);
pthread_mutex_lock(&mutex_actualizacion_listas);
inicializarListaTrabajoBloques(datos_map->nombreJob);
loguearEntradaJob(datos_map->nombreJob);
pthread_mutex_unlock(&mutex_actualizacion_listas);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_TRACE, info_comienzo_map);
free(info_comienzo_map);
rutas_temporales *ruta_temp = crearDirectorioTemporal(leido->dirTemp,
datos_map->nombreJob);
ruta_mapper = bajarScriptAPlano(datos_map->instruccionMap,
datos_map->tamanioScriptMap, ruta_temp->ruta_temp, 0,datos_map->nombreJob);
aplicarMapABloque(ruta_mapper, datos_map->nroBloque, ruta_temp->ruta_temp,
datos_map->nombreJob);
liberarLectura(leido);
liberarRutasTemporales(ruta_temp);
free(ruta_mapper);
free(datos_map->instruccionMap);
free(datos_map);
free(p);
free(pepe);
return resultado = 1;
}
int hacerReduceTotalConCombiner(char* datos_script, int nombre_job,
int tamanio_script) {
lectura * resultado_lectura = leerConfiguracion();
char *log_reduce_inicio = malloc(strlen("Comienzo ejecucion Reduce Total Con Combiner -> Job-") + 4 +1);
char *numJob = string_itoa(nombre_job);
strcpy(log_reduce_inicio,"Comienzo ejecucion Reduce Total Con Combiner -> Job-");
strcat(log_reduce_inicio, numJob);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO, log_reduce_inicio);
free(log_reduce_inicio);
rutas_temporales * rutas = crearDirectorioTemporal(
resultado_lectura->dirTemp, nombre_job);
char* cantidad_recibidos = juntarTodasLasRutasDeRecibidos(
resultado_lectura->dirTemp, nombre_job);
char *ruta_reducer = bajarScriptAPlano(datos_script, tamanio_script,
rutas->ruta_temp, 1,nombre_job);
char * ruta_resultado = malloc(
strlen(rutas->ruta_temp) + strlen("/resultadoTotal.txt") + 1);
char *comando_reduce = malloc(strlen(ruta_reducer) + strlen("sort | ") + 1);
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombre_job;
}
trabajoPorJob* job_aux = list_find(trabajos_de_jobs,
(void *) estaEnLaLista);
char * todosLosRecibidosYLocal = malloc(
strlen("cat ") + strlen(cantidad_recibidos)
+ strlen(job_aux->trabajo_bloques[cantidad_bloques])
+ strlen("> ") + strlen(rutas->ruta_temp)
+ strlen("/todosLosReduces.txt") + 1);
strcpy(todosLosRecibidosYLocal, "cat ");
strcat(todosLosRecibidosYLocal, cantidad_recibidos);
strcat(todosLosRecibidosYLocal, job_aux->trabajo_bloques[cantidad_bloques]);
strcat(todosLosRecibidosYLocal, ">");
char * entradaScript = malloc(
strlen(rutas->ruta_temp) + strlen("/todosLosReduces.txt") + 1);
strcpy(entradaScript, rutas->ruta_temp);
strcat(entradaScript, "/todosLosReduces.txt");
strcat(todosLosRecibidosYLocal, entradaScript);
system(todosLosRecibidosYLocal);
free(todosLosRecibidosYLocal);
strcpy(comando_reduce, "sort | ");
strcat(comando_reduce, ruta_reducer);
strcpy(ruta_resultado,rutas->ruta_temp);
strcat(ruta_resultado,"/resultadoTotal.txt");
ejecutarScriptReduce(comando_reduce, entradaScript, ruta_resultado);
remove(entradaScript);
free(entradaScript);
liberarLectura(resultado_lectura);
liberarRutasTemporales(rutas);
free(ruta_reducer);
free(ruta_resultado);
free(comando_reduce);
char *log_reduce_fin = malloc(strlen("Finalizacion con exito Reduce Total Con Combiner -> Job-") + 4 +1);
strcpy(log_reduce_fin,"Finalizacion con exito Reduce Total Con Combiner -> Job-");
strcat(log_reduce_fin, numJob);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO, log_reduce_fin);
free(log_reduce_fin);
free(numJob);
return 1;
}
int hacerReduceTotalSinCombiner(char* datos_script, int nombre_job,
int tamanio_script) {
char* comando_cat;
lectura *resultado_lectura = leerConfiguracion();
char *numJob = string_itoa(nombre_job);
char *log_inicio_reduce_total = malloc(strlen("Comienzo ejecucion Reduce Total Sin Combiner -> Job-") + 4 + 1);
strcpy(log_inicio_reduce_total,"Comienzo ejecucion Reduce Total Sin Combiner -> Job-");
strcat(log_inicio_reduce_total,numJob);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO,log_inicio_reduce_total);
free(log_inicio_reduce_total);
rutas_temporales *rutas = crearDirectorioTemporal(resultado_lectura->dirTemp,nombre_job);
char* cantidad_recibidos = juntarTodasLasRutasDeRecibidos(
resultado_lectura->dirTemp, nombre_job);
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombre_job;
}
trabajoPorJob* job_aux = list_find(trabajos_de_jobs,
(void *) estaEnLaLista);
int tamanio_string = 0;
int i = 0;
while (i < cantidad_bloques) {
if (job_aux->trabajo_bloques[i] != NULL) {
tamanio_string = tamanio_string
+ strlen(job_aux->trabajo_bloques[i]) + 2;
}
i++;
}
comando_cat = malloc(
strlen("cat ") + strlen(cantidad_recibidos) + tamanio_string
+ strlen("> ") + strlen("/resultadoMapTotal.txt") + strlen(rutas->ruta_temp)+strlen ("|sort ") + 1);
strcpy(comando_cat, "cat ");
strcat(comando_cat, cantidad_recibidos);
i = 0;
while (i < cantidad_bloques) {
if (job_aux->trabajo_bloques[i] != NULL) {
strcat(comando_cat, job_aux->trabajo_bloques[i]);
strcat(comando_cat, " ");
}
i++;
}
strcat(comando_cat,"|sort ");
strcat(comando_cat, "> ");
strcat(comando_cat,rutas->ruta_temp);
strcat(comando_cat,"/todosLosMaps.txt");
system(comando_cat);
free(cantidad_recibidos);
free(comando_cat);
// rutas_temporales * rutas = crearDirectorioTemporal(
// resultado_lectura->dirTemp, nombre_job);
char *ruta_reducer = bajarScriptAPlano(datos_script, tamanio_script,
rutas->ruta_temp, 1,nombre_job);
char * ruta_total_maps = malloc(
strlen(rutas->ruta_temp) + strlen("/todosLosMaps.txt") + 1);
strcpy(ruta_total_maps, rutas->ruta_temp);
strcat(ruta_total_maps, "/todosLosMaps.txt");
char * ruta_resultado = malloc(
strlen(rutas->ruta_temp) + strlen("/resultadoTotal.txt") + 1);
strcpy(ruta_resultado,rutas->ruta_temp);
strcat(ruta_resultado,"/resultadoTotal.txt");
ejecutarScriptReduce(ruta_reducer, ruta_total_maps, ruta_resultado);
remove(ruta_total_maps);
free(ruta_total_maps);
free(ruta_resultado);
liberarRutasTemporales(rutas);
liberarLectura(resultado_lectura);
char *log_reduce_fin = malloc(strlen("Finalizacion con exito Reduce Total Sin Combiner -> Job-") + 4 +1);
strcpy(log_reduce_fin,"Finalizacion con exito Reduce Total Sin Combiner -> Job-");
strcat(log_reduce_fin, numJob);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO, log_reduce_fin);
free(log_reduce_fin);
free(numJob);
return 1;
}
void guardarRecibido(bloque_mapeado * bloque_recibido, int nombreJob) {
lectura * resultado_lectura = leerConfiguracion();
rutas_temporales * rutas = crearDirectorioTemporal(
resultado_lectura->dirTemp, nombreJob);
char* ruta_archivo_recibido = malloc(
strlen(rutas->ruta_recibido) + strlen("/recibido-") + 4
+ strlen(".txt")); //
strcpy(ruta_archivo_recibido, rutas->ruta_recibido);
strcat(ruta_archivo_recibido, "/recibido-");
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombreJob;
}
trabajoPorJob* job_aux = list_find(trabajos_de_jobs,
(void *) estaEnLaLista);
char* r = string_itoa(job_aux->recibido);
strcat(ruta_archivo_recibido, r);
free(r);
strcat(ruta_archivo_recibido, ".txt");
crearArchivoVacio(ruta_archivo_recibido, bloque_recibido->tamanio_bloque);
int file_descriptor;
file_descriptor = open(ruta_archivo_recibido, O_RDWR);
char *archivo_mapeado = mmap((caddr_t) 0, bloque_recibido->tamanio_bloque,
PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
memcpy(archivo_mapeado, bloque_recibido->bloque,
bloque_recibido->tamanio_bloque);
msync(archivo_mapeado, bloque_recibido->tamanio_bloque, MS_SYNC);
munmap(archivo_mapeado, bloque_recibido->tamanio_bloque);
close(file_descriptor);
free(ruta_archivo_recibido);
pthread_mutex_lock(&mutex_actualizacion_listas);
job_aux->recibido = (job_aux->recibido +1);
pthread_mutex_unlock(&mutex_actualizacion_listas);
loguearme(PATH_LOG, "Proceso Nodo", 0, LOG_LEVEL_INFO, "Recibo archivo para Trabajo Local");
liberarRutasTemporales(rutas);
liberarLectura(resultado_lectura);
limpiarBloqueMapeado(bloque_recibido);
return;
}
bloque_mapeado* enviarResultadoFinal(int nombreJob) {
lectura* resultado_leido = leerConfiguracion();
rutas_temporales* rutas = crearDirectorioTemporal(resultado_leido->dirTemp,
nombreJob);
bloque_mapeado *bloque = malloc(sizeof(bloque_mapeado));
char* ruta_resultado_final = malloc(
strlen(rutas->ruta_temp) + strlen("/resultadoTotal.txt") + 1);
//todo para MMAP
strcpy(ruta_resultado_final, rutas->ruta_temp);
strcat(ruta_resultado_final, "/resultadoTotal.txt");
int file_descriptor;
file_descriptor = open(ruta_resultado_final, O_RDWR);
struct stat file;
fstat(file_descriptor, &file);
bloque->tamanio_bloque = file.st_size;
char* envio = malloc(file.st_size);
char *bloque_mapeado;
bloque_mapeado = mmap((caddr_t) 0, bloque->tamanio_bloque, PROT_WRITE,
MAP_SHARED, file_descriptor, 0);
memcpy(envio, bloque_mapeado, file.st_size);
bloque->bloque = envio;
munmap(bloque_mapeado, bloque->tamanio_bloque);
/*char * borro_carpeta_termino_enviar = malloc(strlen("rm -r ")+ strlen(rutas->ruta_temp)+1);
strcpy(borro_carpeta_termino_enviar,"rm -r ");
strcat(borro_carpeta_termino_enviar,rutas->ruta_temp);
system(borro_carpeta_termino_enviar);
free(borro_carpeta_termino_enviar);*/
liberarLectura(resultado_leido);
liberarRutasTemporales(rutas);
free(ruta_resultado_final);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO,"Resultado Final enviado al FileSystem");
char* ultimo_log = malloc(strlen("Trabajo Job-")+4+strlen(" finalizo exitosamente")+1);
strcpy(ultimo_log,"Trabajo Job-");
char *p = string_itoa(nombreJob);
strcat(ultimo_log,p);
free(p);
strcat(ultimo_log," finalizo exitosamente");
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO,ultimo_log);
free(ultimo_log);
return bloque;
}
int main(){
system("clear");
tiempoEjec=time(NULL);
listaEjecutando = list_create();
listaCpuLibres = list_create();
listaInicializando = list_create();
listaAfinalizar = list_create();
listaPorcentajeCpus = list_create();
listaCpus = list_create();
colaListos = queue_create();
colaIO = queue_create();
sem_init(&hayProgramas,0,0);
sem_init(&hayCPU,0,0);
sem_init(&hayIO,0,0);
pthread_mutex_init(&mutexProcesoListo,NULL);
pthread_mutex_init(&mutexInicializando,NULL);
pthread_mutex_init(&mutexListaCpusLibres,NULL);
pthread_mutex_init(&mutexIO,NULL);
pthread_mutex_init(&mutexListaEjecutando,NULL);
pthread_mutex_init(&mutexSwitchProc,NULL);
pthread_mutex_init(&mutexFinalizarPid,NULL);
pthread_mutex_init(&mutexListasCpu,NULL);
pthread_mutex_init(&mutexListasPorcentajes,NULL);
//creacion de la instancia de log
logPlanificador = log_create("../src/log.txt", "planificador.c", false, LOG_LEVEL_INFO);
//leemos el archivo de configuracion
configPlanificador = leerConfiguracion();
//Inicia el socket para escuchar
int serverSocket;
server_init(&serverSocket, configPlanificador->puertoEscucha);
printf("Planificador listo...\n");
tParametroSelector sel;
sel.socket = serverSocket;
sel.listaCpus = listaCpuLibres;
pthread_t enviarAlCpu,selectorCpu,consumidorIO;
pthread_attr_t attr;
pthread_attr_init(&attr);
/*creacion de hilos*/
pthread_create(&selectorCpu,&attr,selector,(void*)&sel);
pthread_create(&enviarAlCpu,&attr,enviar,NULL);
pthread_create(&consumidorIO,&attr,consumidor,NULL);
int enviar = 1;
int cantProc = 1;
int lng = 0;
char * message = 0;
while(enviar){
/*reemplaza a fgets*/
while(1){
int c ;
if ((c = getchar()) == EOF)
break;
message = realloc(message,lng + 1);
message[lng] = c;
lng++;
if (c == '\n')
break;
}
message = realloc(message,lng + 1);
message[lng] = '\0';
if (!strcmp(message,"exit\n")) {
enviar = 0;
llegoexit = true;
sem_post(&hayCPU);
sem_post(&hayProgramas);
sem_post(&hayIO);
}
else
procesarComando(clasificarComando(message),message,&cantProc);
/*reinicio*/
free(message);
message = 0;
lng = 0;
}
/*espero la terminacion de enviar*/
pthread_join(enviarAlCpu,NULL);
pthread_join(consumidorIO,NULL);
sem_destroy(&hayCPU);
sem_destroy(&hayIO);
sem_destroy(&hayProgramas);
pthread_mutex_destroy(&mutexIO);
pthread_mutex_destroy(&mutexInicializando);
pthread_mutex_destroy(&mutexListaCpusLibres);
pthread_mutex_destroy(&mutexListaEjecutando);
pthread_mutex_destroy(&mutexProcesoListo);
pthread_mutex_destroy(&mutexSwitchProc);
pthread_mutex_destroy(&mutexFinalizarPid);
pthread_mutex_destroy(&mutexListasCpu);
pthread_mutex_destroy(&mutexListasPorcentajes);
/*destruyo la lista y sus elementos*/
list_destroy_and_destroy_elements(listaCpuLibres,free);
list_destroy_and_destroy_elements(listaEjecutando,free);
list_destroy_and_destroy_elements(listaInicializando,free);
list_destroy_and_destroy_elements(listaAfinalizar,free);
list_destroy_and_destroy_elements(listaCpus,free);
list_destroy_and_destroy_elements(listaPorcentajeCpus,free);
/*destruyo la cola y sus elementos*/
queue_destroy_and_destroy_elements(colaListos,free);
close(serverSocket);
logTpoTotal();
return 0;
}
