Prueba de Laboratorio Modelo B01 Semáforos y Memoria Compartida

Transcripción

1 Prueba de Laboratorio APELLIDOS: NOMBRE: GRUPO DE LABORATORIO: Indicaciones: No se permiten libros, apuntes ni teléfonos móviles. Cuando tenga una solución al ejercicio muéstrela al profesor (compilación + ejecución). Debe anotar su solución por escrito en el espacio disponible en este cuestionario. Tiempo para realizar la prueba: 90 minutos. Calificación Enunciado Construya, utilizando ANSI C estándar, dos ejecutables que modelen el siguiente sistema. La simulación constará de un proceso manager que cargará una cadena de la línea de órdenes y encargará su traducción a un conjunto de procesos traduccion. El usuario ejecutará un proceso manager indicándole tres argumentos:./manager <cadena> <num_proc_trad> <tam_max_subv> Este proceso manager cargará cadena en un array de caracteres empleando el punto como separador de elementos. Esta cadena estará formada por números enteros (entre 1 y 57) que tendrán que traducir a caracteres los procesos de traducción (con ayuda de los procesos de puntuación). En num_proc_trad se indicará el número de procesos de traduccion que se lanzarán para traducir el array y tam_max_subv será el tamaño máximo de cada subvector (cada proceso traduccion traducirá del array original suministrado por el cliente un máximo de tamsv elementos). La correspondencia de traducción se resume en la siguiente tabla (la última fila de la tabla es la correspondencia del carácter con su código ASCII necesario para realizar la traducción): Entero Traducción a b... y z A B... Y Z.,!? _ Código ASCII El sistema contará con un único proceso de puntuación que se encargará de traducir los símbolos de puntuación que se corresponderán con los valores enteros del 53 al 57 inclusive. Así, cuando un proceso de traducción encuentre uno de estos valores despertará al proceso de puntuación que escribirá en una variable de memoria compartida el resultado de traducir ese signo de puntuación, volviendo a dormir después de realizar su trabajo. El proceso de traducción leerá ese valor y lo usará en el array del cliente. Los procesos traduccion atenderán peticiones de traducción hasta que el manager les envíe la señal de terminación. En cada petición el proceso manager les indicará el índice de inicio y fin de cada subvector. Los procesos de traducción actualizarán directamente el resultado en el array creado por el manager. Por ejemplo, ante una llamada como:./exec/manager El proceso cliente lanzará dos procesos de traducción que traducirán en 3 partes la cadena de entrada (2 subvectores de tamaño 2, y un subvector de 1 elemento). El resultado de la traducción será el siguiente array de salida en ASCII, con representación en cadena de caracteres "Hola!": Array de entrada Array de salida (ASCII) Representación como caracteres 'H' 'o' 'l' 'a' '!'

2 Resolución Utilice el código fuente suministrado a continuación como plantilla para resolver el ejercicio. Este código no debe ser modificado (salvo la inicialización de los semáforos en el proceso manager). Únicamente debe incorporar su código en la sección indicada. No realice comprobación de errores en los parámetros. El proceso manager se encarga de enviar la señal de terminación a los procesos de traducción y al proceso de puntuación cuando éstos han calculado el sumatorio final. Preste especial atención a lograr el máximo paralelismo posible en la solución. Indique a continuación el valor de inicialización de los semáforos (código en manager.c): Línea de Código Semáforo Uso Inicialización 199 ordenlista Despierta a un proceso de traducción 200 ordenleida Indica al manager que la orden fue leida 201 fin La traducción de un subvector fue realizada 202 mutex Uso exclusivo del proceso de puntuación 203 iniciopun Despierta al proceso de puntuación 204 finpun Espera fin del proceso de puntuación Test de Resultado Correcto Una vez resuelto el ejercicio, si ejecuta el manager con los siguientes argumentos (make test),./exec/manager el resultados debe ser algo similar a (naturalmente cambiará el PID de los procesos de traducción y probablemente el orden de atención de las peticiones):./exec/manager [PID 15245] Ini 0 Fin 1 Traduccion Subvector Ho [PID 15245] Ini 4 Fin 4 Traduccion Subvector! [PID 15246] Ini 2 Fin 3 Traduccion Subvector la Resultado de la Traduccion: Hola! Complete el resultado obtenido de la ejecución con la siguiente lista de argumentos (make solucion):./exec/manager Resultado:

3 Esqueleto de Código Fuente A continuación se muestra el esqueleto de código fuente para resolver el ejercicio. Sólo debe modificar la inicialización de los semáforos e incluir la parte que falta del proceso traductor y el proceso de puntuación. Makefile 1 DIROBJ := obj/ 2 DIREXE := exec/ 3 DIRHEA := include/ 4 DIRSRC := src/ 5 6 CFLAGS := I$(DIRHEA) c Wall std=c99 7 LDLIBS := pthread lrt lm 8 CC := gcc 9 10 all : dirs manager traduccion puntuacion dirs: 13 mkdir p $(DIROBJ) $(DIREXE) manager: $(DIROBJ)manager.o $(DIROBJ)semaforoI.o 16 $(CC) lm o $(DIREXE)$@ $^ $(LDLIBS) traduccion: $(DIROBJ)traduccion.o $(DIROBJ)semaforoI.o 19 $(CC) o $(DIREXE)$@ $^ $(LDLIBS) puntuacion: $(DIROBJ)puntuacion.o $(DIROBJ)semaforoI.o 22 $(CC) o $(DIREXE)$@ $^ $(LDLIBS) $(DIROBJ)%.o: $(DIRSRC)%.c 25 $(CC) $(CFLAGS) $^ o $@ test: 28./exec/manager prueba: 31./exec/manager clean : 34 rm rf *~ core $(DIROBJ) $(DIREXE) $(DIRHEA)*~ $(DIRSRC)*~ globaltp.h 35 #define _POSIX_SOURCE 36 #define _BSD_SOURCE 37 #include <stdio.h> 38 #include <errno.h> 39 #include <string.h> 40 #include <stdlib.h> 41 #include <unistd.h> 42 #include <fcntl.h> 43 #include <math.h> 44 #include <signal.h> 45 #include <sys/mman.h> 46 #include <sys/stat.h> 47 #include <sys/types.h> #include <semaforoi.h> #define SEMORDENLISTA "s_ordenlista" 52 #define SEMORDENLEIDA "s_ordenleida" 53 #define SEMFIN "s_fin" 54 #define MUTEX "s_mutex" #define MEMVECTOR "mc_vector" 57 #define MEMORDEN "mc_orden" #define MEMPUNTUACION "mc_puntuacion" 60 #define SEMPUNTUINI "s_puntuini" 61 #define SEMPUNTUFIN "s_puntufin" #define MAXARRAY struct TDatos_t { 66 char cadena[maxarray]; 67 }; struct TOrden_t { 70 int inicio; 71 int fin; 72 }; enum TipoProceso_t {TRADUCCION, PUNTUACION}; struct TProceso_t { semaforoi.h 1 #ifndef SEMAFOROI_H 2 #define SEMAFOROI_H 3 #include <semaphore.h> 4 5 sem_t *crear_sem (const char *name, 6 unsigned int valor); 7 sem_t *get_sem (const char *name); 8 void destruir_sem (const char *name); 9 void signal_sem (sem_t *sem); 10 void wait_sem (sem_t *sem); 11 #endif 77 enum TipoProceso_t tipo; /* Tipo del proceso: TRADUCCION, PUNTUACION */ 78 pid_t pid; /* PID del proceso hijo */ 79 };

4 semaforoi.c Escuela Superior de Informática 80 #include <stdio.h> 81 #include <errno.h> 82 #include <string.h> 83 #include <stdlib.h> 84 #include <unistd.h> 85 #include <fcntl.h> #include <semaforoi.h> sem_t *crear_sem (const char *name, unsigned int valor) { 90 sem_t *sem; sem = sem_open(name, O_CREAT, 0644, valor); 93 if (sem == SEM_FAILED) { 94 fprintf(stderr, "Error al crear el sem. <%s>: %s\n", 95 name, strerror(errno)); 96 exit(exit_failure); 97 } return sem; 100 } sem_t *get_sem (const char *name) { 103 sem_t *sem; sem = sem_open(name, O_RDWR); 106 if (sem == SEM_FAILED) { 107 fprintf(stderr, "Error al obtener el sem. <%s>: %s\n", 108 name, strerror(errno)); 109 exit(exit_failure); 110 } return sem; 113 } void destruir_sem (const char *name) { 116 sem_t *sem = get_sem(name); /* Se cierra el sem */ 119 if ((sem_close(sem)) == 1) { 120 fprintf(stderr, "Error al cerrar el sem. <%s>: %s\n", 121 name, strerror(errno)); 122 exit(exit_failure); 123 } /* Se elimina el sem */ 126 if ((sem_unlink(name)) == 1) { 127 fprintf(stderr, "Error al destruir el sem. <%s>: %s\n", 128 name, strerror(errno)); 129 exit(exit_failure); 130 } 131 } void signal_sem (sem_t *sem) { 134 if ((sem_post(sem)) == 1) { 135 fprintf(stderr, "Error al modificar el sem.: %s\n", 136 strerror(errno)); 137 exit(exit_failure); 138 } 139 } void wait_sem (sem_t *sem) { 142 if ((sem_wait(sem)) == 1) { 143 fprintf(stderr, "Error al modificar el sem. : %s\n", 144 strerror(errno)); 145 exit(exit_failure); 146 } 147 }

5 manager.c 148 #include "globaltp.h" /* Funciones de soporte */ 151 void crearvector (char *datos, char *arg, int *n); 152 void controlador (int senhal); 153 void liberarrecursos (void); 154 void finalizarprocesos (void); int g_nprocesos; /* Número total de procesos creados */ 157 struct TProceso_t *g_pids; /* Tabla de procesos **/ int main (int argc, char *argv[]) { 160 struct TDatos_t *datos; 161 struct TOrden_t *orden; 162 pid_t pid; int shmmcdatos, shmmcorden, shmmcpunt; 165 sem_t *ordenlista, *ordenleida, *fin; 166 int i, nelementrada, nproctraduccion, tammaximosubvector; 167 int nsubvectores, nsubvectoresprocesados = 0, subvectoractual = 0; /* Instalación del manejador de Control C */ 170 if (signal(sigint, controlador) == SIG_ERR) { 171 fprintf(stderr, "Error al instalar manejador en %s: %s\n", argv[0], strerror(errno)); 172 exit(exit_failure); 173 } nproctraduccion = atoi(argv[2]); /* Numero de procesos de traduccion */ 176 tammaximosubvector = atoi(argv[3]); /* Tamano maximo del subvector */ g_nprocesos = nproctraduccion + 1; 179 g_pids = malloc(sizeof(struct TProceso_t) * (g_nprocesos)); /* Inicialización de la tabla de procesos */ 182 for (i = 0; i < g_nprocesos; i++) { 183 g_pids[i].pid = 0; 184 } shmmcdatos = shm_open(memvector, O_CREAT O_RDWR, 0644); /* Creación de v.m.c. */ 187 ftruncate(shmmcdatos, sizeof(struct TDatos_t)); 188 datos = mmap(null, sizeof(struct TDatos_t), PROT_READ PROT_WRITE, MAP_SHARED, shmmcdatos, 0); crearvector(datos >cadena, argv[1], &nelementrada); shmmcorden = shm_open(memorden, O_CREAT O_RDWR, 0644); 193 ftruncate(shmmcorden, sizeof(struct TOrden_t)); 194 orden = mmap(null, sizeof(struct TOrden_t), PROT_READ PROT_WRITE, MAP_SHARED, shmmcorden, 0); shmmcpunt = shm_open(mempuntuacion, O_CREAT O_RDWR, 0644); 197 ftruncate(shmmcpunt, sizeof(char)); ordenlista = crear_sem(semordenlista, /* VALOR SEMÁFORO */); /* Creación de semáforos*/ 200 ordenleida = crear_sem(semordenleida, /* VALOR SEMÁFORO */); 201 fin = crear_sem(semfin, /* VALOR SEMÁFORO */); 202 crear_sem(mutex, /* VALOR SEMÁFORO */); 203 crear_sem(sempuntuini, /* VALOR SEMÁFORO */); 204 crear_sem(sempuntufin, /* VALOR SEMÁFORO */); for (i = 0; i < nproctraduccion ; i++) { /* Creación de procesos de traducción */ 207 switch (pid = fork()) { 208 case 1 : /* Código de error */ 209 fprintf(stderr, "Error en creación de proceso TRADUCCION: %s\n", strerror(errno)); 210 finalizarprocesos(); 211 liberarrecursos(); 212 exit(exit_failure); 213 case 0 : /* Proceso hijo */ 214 if (execl("./exec/traduccion", "traduccion", NULL) == 1) { 215 fprintf(stderr, "Error al usar execl() en proceso TRADUCCION: %s\n", strerror(errno)); 216 exit(exit_failure); 217 } 218 break; 219 default: /* Proceso padre */ 220 g_pids[i].tipo = TRADUCCION; 221 g_pids[i].pid = pid; 222 } 223 } 224 printf ("Se han lanzado %d procesos TRADUCCION\n", nproctraduccion); 225 sleep(1); /* Esperamos 1 seg. */ switch (pid = fork()) { /* Creación de proceso de puntuación */ 228 case 1 : /* Código de error */ 229 fprintf(stderr, "Error en creación de proceso PUNTUACION: %s\n", strerror(errno)); 230 finalizarprocesos(); 231 liberarrecursos(); 232 exit(exit_failure);

6 233 case 0 : /* Proceso hijo */ 234 if (execl("./exec/puntuacion", "puntuacion", NULL) == 1) { 235 fprintf(stderr, "Error al usar execl() en proceso PUNTUACION: %s\n", strerror(errno)); 236 exit(exit_failure); 237 } 238 break; 239 default: /* Proceso padre */ 240 g_pids[nproctraduccion].tipo = PUNTUACION; 241 g_pids[nproctraduccion].pid = pid; 242 } 243 printf ("Se ha lanzado 1 proceso PUNTUACION\n"); 244 sleep(1); /* Esperamos 1 seg. */ nsubvectores = ceil(nelementrada / (float) tammaximosubvector); /* Nº subvectores */ while (subvectoractual < nsubvectores) { 249 orden >inicio = (subvectoractual * tammaximosubvector); 250 orden >fin = orden >inicio + tammaximosubvector 1; 251 if (orden >fin > (nelementrada 1)) { 252 orden >fin = nelementrada 1; 253 } subvectoractual++; 256 signal_sem(ordenlista); 257 wait_sem(ordenleida); 258 } while (nsubvectoresprocesados < nsubvectores) { /* Esperar a que todos los subvectores */ 261 wait_sem(fin); /* hayan sido calculados. */ 262 nsubvectoresprocesados++; 263 } printf ("\nresultado de la Traduccion: "); 266 for (i=0; i<nelementrada; i++) { 267 printf ("%c", datos >cadena[i]); 268 } 269 printf("\n"); close(shmmcdatos); /* Cierre de v.m.c. */ 272 close(shmmcorden); 273 close(shmmcpunt); finalizarprocesos(); 276 liberarrecursos(); return EXIT_SUCCESS; 279 } /* Inicializa datos a partir de arg */ 282 void crearvector (char *datos, char *arg, int *n) { 283 int i = 0; 284 char *cad; datos[i] = atoi(strtok(arg, ".")); 287 while ((cad = strtok(null, "."))!= NULL) { 288 datos[++i] = atoi(cad); 289 } *n = ++i; 292 } /* Manejador de señal SIGINT */ 295 void controlador (int senhal) { 296 printf("\nfin del programa (Control + C)\n"); 297 finalizarprocesos(); 298 liberarrecursos(); 299 exit(exit_success); 300 } /* Liberación de recursos */ 303 void liberarrecursos (void) { 304 printf("\n Liberando recursos \n"); 305 free(g_pids); 306 destruir_sem(mutex); destruir_sem(semfin); destruir_sem(semordenlista); 307 destruir_sem(semordenleida); destruir_sem(sempuntuini); destruir_sem(sempuntufin); 308 shm_unlink(memvector); shm_unlink(memorden); shm_unlink(mempuntuacion); 309 } /* Terminación de procesos hijos */ 312 void finalizarprocesos (void) { 313 int i; printf("\n Finalización de procesos hijos vivos \n"); 316 for (i = 0; i < g_nprocesos; i++) { 317 if (g_pids[i].pid!= 0) { /* Proceso hijo vivo */ 318 switch (g_pids[i].tipo) { 319 case TRADUCCION: 320 printf("finalizando proceso TRADUCCION [%d]...\n", g_pids[i].pid); 321 break; 322 case PUNTUACION: 323 printf("finalizando proceso PUNTUACION [%d]...\n", g_pids[i].pid); 324 break; 325 }

7 326 kill(g_pids[i].pid, SIGINT); 327 } 328 } 329 } traduccion.c 330 #include "globaltp.h" int main (int argc, char *argv[]) { 333 int shmmcvec, shmmcorden, shmmcpun; 334 struct TDatos_t *datos; 335 struct TOrden_t *orden; 336 char *ordenpuntuacion; 337 sem_t *ordenlista, *ordenleida, *fin, *mutex; 338 sem_t *iniciopun, *finpun; 339 int i, indiceinicio, indicefin; shmmcvec = shm_open(memvector, O_RDWR, 0644); 342 datos = mmap(null, sizeof(struct TDatos_t), PROT_READ PROT_WRITE, MAP_SHARED, shmmcvec, 0); shmmcorden = shm_open(memorden, O_RDWR, 0644); 345 orden = mmap(null, sizeof(struct TOrden_t), PROT_READ PROT_WRITE, MAP_SHARED, shmmcorden, 0); shmmcpun = shm_open(mempuntuacion, O_RDWR, 0644); 348 ordenpuntuacion = mmap(null, sizeof(char), PROT_READ PROT_WRITE, MAP_SHARED, shmmcpun, 0); ordenlista = get_sem(semordenlista); 351 ordenleida = get_sem(semordenleida); 352 fin = get_sem(semfin); 353 mutex = get_sem(mutex); 354 iniciopun = get_sem(sempuntuini); 355 finpun = get_sem(sempuntufin); Incluya aquí el bucle para atender peticiones (Longitud aprox. 25 Líneas de código) Muestre en pantalla información sobre el PID del proceso que ha calculado cada subvector, el inicio y el fin y el resultado parcial de traducción, como en el siguiente ejemplo: [PID 276] Ini 0 Fin 1 Traduccion Subvector Ho 356 return EXIT_SUCCESS; 357 }

8 puntuacion.c Escuela Superior de Informática 358 #include "globaltp.h" int main (int argc, char *argv[]) { Incluya aquí el código del proceso puntuación (Longitud aprox. 20 Líneas de código) 361 return EXIT_SUCCESS; 362 }