Sistemas Operativos Cuarto Parcial. Sincronizacién y Comunicacién. 30 de mayo de 2023 Dispone de 35 minutos. Las notas saldran el 14 de junio o antes. La revisién sera el 16 o antes, Problema (6 puntos) Los coches de Formula 1 deben monitorizar sus sensores tanto para su registro como para la telemetria. Se desea disefiar la arquitectura concurrente de este sistema asi como determinar los mecanismos de sincronizacion y comunicacién necesarios. Cada sensor (identificado por su ntimero) debe ser muestreado (llamando a la funcién auxiliar double Leer Sensor(sensor_number) ;) periédicamente (con la frecuencia que se requiera) de manera independiente y concurrente, y cada valor obtenido debe ir siendo acumulado sobre la estructura de datos “struct sensor” correspondiente para su posterior consumo (que implicara su promediado y el reseteo a cero de la estructura), struct sensor { int num_veces; double val_acumutado; } struct sensor Sensor Acumulado[NUM SENSORS] ; struct Estado Sensores { time t Time Stamp; /* Marca el avance del tiempo. */ double Valor Promedio[NUM SENSORS]; /* val_promedio=val_acumulado/num veces; */ } Estado_Sensores; Cada décima de segundo, el valor acumulado de cada sensor (vector Sensor_Acumulado) debe ser consumido (promediado y reseteada su estructura) sobre la variable resumen (vector Valor_Promedio) que contendréi el valor promedio de cada sensor durante la tiltima décima de segundo (aprox.). Este vector, mas una marca de tiempo, es el estado promedio del vehiculo (variable Estado_Sensores) a) [1 pts] Justifique: ¢procesos pesados 0 hilos?, cudntos, de qué tipo y el propésito de cada uno. b) [1 pts] 2Qué condiciones de carrera pueden existir? Justifique el mecanismo de sincronizacién mas adecuado en cada caso (afiada o modifique variables si lo considera necesario). ¢) [1 pts] Codifique la tarea (Promediar Estado) que, cada décima de segundo, realiza las labores descritas. NOTA: Considere que existe la funcién time t Esperar Tiempo(double segundos) ; que espera los segundos 0 fraccion indicados y devuelve una marca del tiempo actual al despertar. Adicionalmente, cada nuevo estado promedio del vehiculo debe ser registrado localmente en el fichero CAJANEGRA. dat y simultaneamente debe ser enviado como telemetria a un servidor remoto para poder ser visualizado en tiempo real por los ingenieros del equipo (todos los circuitos tienen cobertura WiFi). d) [1 pts] 2Qué condicién de carrera puede existir entre las tareas Cajanegra y Telemetria y Promediar Estado? Justifique los mecanismos de sincronizacién mas adecuados en cada caso. e) [1 pts] Codifique el esquema general de las tareas Cajanegra y Telemetria e indiqué como deberia modificarse el cédigo de la tarea Promediar Estado para incorporar los mecanismos del apartado d. f) [1 pts] Respecto a la tarea TeLemet ria como cliente del servidor remoto, justifique en detalle el mecanismo de comunicacién mas adecuado y razone la necesidad 0 no de utilizar las macros hton.SOLUCION: a) [1 pts] Justifique: ¢procesos pesados 0 hilos?, cudntos, de qué tipo y el propésito de cada uno. Claramente no interesa utilizar procesos pesados con estado independiente y cambio de contexto pesado, sino todo lo contrario. Utilizaremos procesos ligeros (también denominados hilos), pues deberemos arrancar un gran nlimero de ellos (minimo uno por sensor mas otros 3 para las tareas Promediar_ Estado, Cajanegra y Telemetria) que deberdn ejecutar de manera independiente y concurrentemente (con un cambio de contexto lo mas ligero posible y minima contencién) y comunicados entre sf a través de variables compartidas. b) [1 pts] 2Qué condiciones de carrera pueden existir? Justifique el mecanismo de sincronizacién mas adecuado en cada caso (afiada o modifique variables si lo considera necesario). Se da una condicién de carrera cuando entidades concurrentes acceden sin control a recursos compartido pudiendo dar lugar a resultados inesperados. En este caso los recursos compartidos son las variables compartidas mencionadas en el apartado anterior. Concretamente, cada una de las entradas del vector Sensor_Acumulado, que estaré siendo modificada por el hilo Nuestrear_Sensor correspondiente a ese sensor, y debera ser promediada y reseteada periddicamente por el hilo Promediar Estado, Para resolver la sincronizacién, dado que no es necesario realizar una espera de larga duracién, y para obtener una contencién minima (maxima granularidad) nos sirve garantizar la exclusion mutua de manera independiente para cada entrada del vector Sensor_Acumutado, utilizando un mutex por sensor (podemos afiadir en campo en la estructura) que los hilos bloquearan sélo durante el acceso a dicha entrada del vector. ©) [1 pts] Codifique la tarea (Promediar Estado) que, cada décima de segundo, realiza las labores descritas. NOTA: Considere que existe la funcién time t Esperar Tiempo(double segundos) ; que espera los segundos 0 fraccion indicados y devuelve una marca del tiempo actual al despertar. void Promediar_estado(void) white (4) { Estado_Sensores--Time Stamp = Esperar_Tiempo(1.0/10); for (int sn=0; snmutex); Estado_Sensores->valor_Promedio[ sn] sensor->val_acumulado/sensor->num_veces; sensor->num_veces = 0; sensor ->val_acumyLado'= 9; pthread mutex_unlock(sensor ->mutex); } d) [1 pts] cQué condicién de carrera puede existir entre las tareas Cajanegra y Telemetria y Promediar_Estado? Justifique los mecanismos de sincronizacion mas adecuados en cada caso. En esta ocasién la condicién de carrera sucede alrededor de la variable compartida Estado_Sensores, que estara siendo actualizada periédicamente por el hilo Promediar_Estado, y debe ser registrada y enviada por los hilos Cajanegra y Telemet ria respectivamente, cada vez que se haya actualizado. Este caso sigue un patrén similar pero diferente al Productor-Consumidor. Existe un buffer con una nica entrada (la variable Estado_Sensores), no existe un Consumidor sino dos, y estos no deben retener al Productor (hay minimizar la latencia de este), que no deberia esperar a los consumidores. El acceso a la variable compartida Estado_Sensores deberd estar protegido por un mutex. Los hilos Cajanegra y Telemetria deberan esperar en una variable condicién a que el estado haya sido actualizado. EI hilo Promediar Estado les despertar4 a ambos simultaneamente (cond_broadcast). Para minimizar la contencién del Productor se puede realizar una técnica de doble buffering Afjadiremos esta variables de sincronizacién como variables globales) [1 pts] Codifique el esquema general de las tareas Cajanegra y Telenet ria e indiqué como deberia modificarse el cédigo de la tarea Promediar_Estado para incorporar los mecanismos del apartado d. yold Telenetria(struct sockaddr * addr, socklen_t addrten) int servidor = socket (AF_INET, SOCK_DGRAM, TPPROTO_UDP) ; Yong int Last Time Stamp strict Estado_sensores Doble-Butfer[1]; white (1) pebread mutex tock(mutex) While (Last. Time stamp pthread_cond_wait(nuevo estado, mutex); Last Time Stamp = Estado Sensores-STime stamp; spe (Dob Bur far Fate Sensor es, xixewf (Estado Sencores)); ehread_mutex_untock (mutex); Sendto(servidor, Doble. Buffer, sizeof (Doble Buffer), 0, addr, addrten); Estado_Sensores->Time Stamp) + Cajanegra seria similar, pero escribiendo sobre el descriptor obtenido creando el archivo de registro. void Pronediar estado(void) time_t Time stamp; white (1) { Time_Stamp = Esperar_Tiempo(1.0/10); pthread mutex lock (mutex); stado-Sensorés->Time Stamp = Time Stamp; for (int sn=0; snsa_port = htons (SERVER PORT) ;CODIGO FUENTE: extern tine t Esperar_Tiempo(double); extern double Leer sensor(int); fidefine NUM_SENSORS 39 fidefine NODATA (0.0/0.0) // NaN struct sensor { int num_veces; double val_acumulado; pthread_mutex_t mutex(1]; }; struct sensor Sensor_Acumulado[NUM_SENSORS] ; Struct Estado Sensores { ‘time t TimeStamp; /* Marca el avance del tiempo. double Valor Promedio[NUM SENSORS]; /* val_promedii } Estado_Sensores[1]; pthread mutex t mutex[1]; pthread_cond t nuevo estado[1}; /al_acumulado/num_veces; */ void Muestrear_Sensor(int sensor_number, double frecuencia) struct sensor * sensor = @Sensor_Acumulado[sensor_number]; double valor: white @) Espet a Tienpo(1.0/frecuencia) Leer_Sensor(sensor_number); pthread_nutex-lock(sensor->mutex); sensor->val_acumulado += valor; pthread_mutex-unlock( sensor->mutex); 5D void Promediar estado(void) time_t Time_stamp; wntte (a) Tine “stanp = Esperar_Tiempo(1.0/10); pthread-mutex-tock (mutex), Estado_Sensorés->1ine Stamp = Time stamp; For Gne sno sneHM SENSORS; snes) { Struct sensor " sensor = Sensor Acumulado[sn]; pthread mutex_lock(sensor->nutex); Be" (Sengor-snum veces > 6) Estado Sensores->Valor_Promedio[sn] = sensor->val_acumulado/sensor->nun_veces; else Estado_Sensores-Valor_Promedio[sn] = NO_DATA; sensor-snum veces. = 0; Sensor->val_acumulado’= @; pthread_mutex-untock( sensor->mutex); } pthread_cond_broadcast(nuevo_estado) ; pthread_mutex_unlock(mutex) ; ; | youd caganogra(void) int cajanegra = creat(“CAJANEGRA. dat”, 0666); tine’ Cast" timestamp £8, EUMGE EtESaa'Seassee® Doble surter 1); mite ()¢ pthread mutex tock(mutex) ; while (Last_Time_Stamp >= Estado_Sensores->Time_Stamp) pthread_cond_wait(nuevo_estado, mutex); ast? Fime Stanp = estauo:senscres Sime Stamp; nenspy (Gob eBfer estado, encores, sot (E5tado_Sensores)); pthread_mutex_unlock (mutex); } write(cajanegra, Doble Buffer, sizeof(Doble_Buffer)); 1 youd Telenetria(struct sockaddr * aur, socklen_t addrten) int servidor = socket (AF_INET, SOCK_DGRAM, 8); Yong ant. Last_Time Stamp ="0; Struct Estado_Sensores. bob le. Butfer[1]; winnie’ G4 pthread_mutex_lock(mutex); hate (Last. Tine Stamp > Estado_sensores->Tine_stamp) pthread_cond_wait(nuevo_estado, mutex); ast” Tine Stanp = estado. Sensores-STine. Stamp; hencpy(Dobe But Ter Estado, Sensores, sczeof (estado. Sensores)); pthread_mutex_unlock(mutex); sendto( Servidor, Doble Buffer, sizeof (Doble Buffer), 0, addr, addr len) ;