Sincronización de procesos Mariano Gómez Plaza

 Mariano Gómez Plaza Sincronización de procesos 2 Tipos de procesos IndependientesCooperantes Su estado no es compartidoSu estado es compartido Son deterministas Su funcionamiento no es determinista Son reproducibles Su funcionamiento puede ser irreproducible Pueden ser detenidos y rearrancados sin ningún efecto negativo Ejemplo: un programa que calcula 1000 cifras decimales de pi Si son detenidos y posteriormente rearrancados puede que se produzcan efectos negativos Ejemplo: un proceso que escribe en el terminal la cadena “abc” y otro la cadena “cba”

 Mariano Gómez Plaza Sincronización de procesos 3 Productor-consumidor n Un proceso produce datos que son posteriormente procesados por otro proceso n i.e.: el manejador de teclado y el programa que recoge los caracteres de un buffer n Lo más cómodo es emplear un buffer circular ProductorConsumidor Escribe Lee

 Mariano Gómez Plaza Sincronización de procesos 4 Código del productor n El productor no puede escribir en el buffer si está lleno Comparte con el consumidor: el buffer y el contador do {... produce un nuevo elemento (elemento_p)... while (contador == MAX_ELEMENTOS) haz_nada; buffer[indice_p] = elemento_p; indice_p = (indice_p + 1) % MAX_ELEMENTOS; contador = contador + 1; } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 5 Código del consumidor n El productor no puede leer del buffer si está vacío Comparte con el consumidor: el buffer y el contador do { while (contador == 0) haz_nada; elemento_c = buffer[indice_c]; indice_c = (indice_c + 1) % MAX_ELEMENTOS; contador = contador - 1;... consume el elemento (elemento_c)... } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 6 Condiciones de carrera El código anterior no funciona por existir condiciones de carrera al actualizar el contador Veamos qué ocurre al ejecutar la sentencia: contador = contador + 1; ProductorConsumidorload r0, contador add r0, 1 sub r0, 1store contador, r0 Problema: la modificación del contador no es atómica

 Mariano Gómez Plaza Sincronización de procesos 7 Atomicidad n Una operación se dice que es atómica (en un sistema uniprocesador) cuando se ejecuta con las interrupciones deshabilitadas n Las referencias y las asignaciones son atómicas en la mayoría de los sistemas. Esto no es siempre cierto para matrices, estructuras o números en coma flotante n Si el HW no proporciona operaciones atómicas, éstas no pueden construirse por SW

 Mariano Gómez Plaza Sincronización de procesos 8 Sincronización Persona APersona B 3:00 Mira en la nevera. No hay leche 3:05 Va a la tienda 3:10 Llega a la tienda 3:15 Deja la tienda 3:20 Llega a casa y guarda la leche 3:25 3:30 Mira en la nevera. No hay leche Va a la tienda Llega a la tienda Deja la tienda Llega a casa y...

 Mariano Gómez Plaza Sincronización de procesos 9 ¿Cuál es el problema planteado? Alguien necesita leche, pero no tanta n Exclusión mutua: es el mecanismo que asegura que sólo una persona o proceso está haciendo algo en un instante determinado (los otros están excluidos). n Sección crítica: es la sección de código, o colección de operaciones, en el que se actualizan variables comunes. Cuando un proceso está ejecutando código de su SC, ningún otro proceso puede estar en su SC

 Mariano Gómez Plaza Sincronización de procesos 10 Problema de la sección crítica n Toda solución debe cumplir tres condiciones Exclusión mutua Progreso Espera limitada n Solución general: do { protocolo de entrada sección crítica protocolo de salida resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 11 Tipos de soluciones n Suposiciones: l Los procesos se ejecutan a una velocidad  0 l Su velocidad relativa no influye n Soluciones basadas en variables de control Soluciones basadas en instrucciones máquina específicas ( test-and-set o swap ) n Soluciones basadas en primitivas del SO n Soluciones basadas en regiones críticas y monitores

 Mariano Gómez Plaza Sincronización de procesos 12 Solución con variables de control n Válidas para varios procesadores n Suposición: las instrucciones de carga y almacenamiento son atómicas Primer intento Ti y Tj comparten la variable turno Thread Ti do { while (turno != i) haz_nada; sección crítica turno = j; resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 13 Segundo intento n Variables compartidas: flag[i] = FALSE; flag[j] = FALSE; n Estas variables indican la intención de los hilos de entrar en sección crítica Thread Ti do { flag[i] = TRUE; while (flag[j]) haz_nada; sección crítica flag[i] = FALSE; resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 14 Tercer intento (Dekker) n Variables compartidas: int turno, flag[2]; flag[i] = flag[j] = FALSE; Thread Ti do { flag[i] = TRUE; turno = j; while (flag[j] && (turno == j)) haz_nada; sección crítica flag[i] = FALSE; resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 15 Sincronización hardware int test_and_set (int *destino) { int aux; aux = *destino; *destino = TRUE; return (aux); } Variable compartida cerrojo iniciada a FALSE do { while (test_and_set (&cerrojo)) haz_nada; sección crítica cerrojo = FALSE; resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 16 Instrucción swap void swap (int *a, int *b) { int aux; aux = *a; *a = *b; *b = aux; } Variable compartida cerrojo iniciada a FALSE do { llave = TRUE; do { swap (cerrojo, llave); } while (llave != FALSE); sección crítica cerrojo = FALSE; resto de la sección } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 17 Semáforos n Introducidos por Dijkstra en los años 60 Es un tipo especial de variable que sólo puede ser accedida por dos primitivas P y V P (semáforo) : operación atómica que espera hasta que la variable semáforo sea positiva, en este momento la decrementa en 1 V (semáforo) : operación atómica que incrementa la variable semáforo en 1 n ¿Cómo quedaría el problema de la sección crítica con semáforos?

 Mariano Gómez Plaza Sincronización de procesos 18 Características de los semáforos n Son independientes de la máquina n Son simples n Pueden trabajar con varios procesos n Pueden permitir que varios procesos entren en la sección crítica al mismo tiempo en caso de necesitarse esta posibilidad n Doble uso de los semáforos: l Exclusión mutua l Sincronización

 Mariano Gómez Plaza Sincronización de procesos 19 Productor-consumidor n Restricciones: El consumidor espera a que haya datos en el buffer El productor espera a que haya buffers vacíos Sólo un único proceso puede manipular el buffer a la vez n Semáforos: smf_llenos, smf_vacíos y exmut n Inicialización: smf_llenos = 0 smf_vacíos = número_de_buffers exmut = 1

 Mariano Gómez Plaza Sincronización de procesos 20 ProductorConsumidor P (smf_vacíos); P (exmut); Produce un dato; V (exmut); V (smf_llenos); P (smf_llenos); P (exmut); Consume el dato; V (exmut); V (smf_vacíos); ¿Por qué el productor hace P(smf_vacíos ) y V(smf_llenos) ? ¿Es importante el orden en que se ejecutan las primitivas P y V? ¿Cómo podemos extender el problema si hay dos consumidores?

 Mariano Gómez Plaza Sincronización de procesos 21 Lectores-escritores n Descripción: Los escritores acceden a la BBDD cuando no haya ningún otro escritor y ningún lector. Semáforo escribir Los lectores acceden cuando no haya ningún escritor accediendo o esperando. Semáforo leer Variables compartidas: LA, LE, EA, EE. A estas variables accederemos en exclusión mutua. Semáforo exmut

 Mariano Gómez Plaza Sincronización de procesos 22 Iniciación leer = escribir = 0 exmut = 1 LA = EA = LE = EE = 0 n Además: l Los escritores tienen prioridad sobre los lectores

 Mariano Gómez Plaza Sincronización de procesos 23 LectorEscritor P (exmut); if ((EA + EE) == 0) { V (leer); LA = LA + 1; } else { LE = LE + 1; } V (exmut); P (leer); Leemos los datos; P (exmut); LA = LA - 1; if (LA == 0 && EE > 0) { V (escribir); EA = EA + 1; EE = EE - 1; } P (exmut); if (( EA + LA + EE) == 0){ V (escribir); EA = EA + 1; } else { EE = EE + 1; } V (exmut); P (escribir); Escribimos los datos; P (exmut); EA = EA - 1; if (EE > 0) { V (escribir); EA = EA + 1; EE = EE - 1; } else while (LE > 0) { V (leer); LA = LA + 1; LE = LE - 1; } V (exmut);

 Mariano Gómez Plaza Sincronización de procesos 24 Casos particulares n Un lector entra y deja el sistema n Un escritor entra y deja el sistema n Entran dos lectores al sistema n Un escritor entra y debe esperar n Un lector entra y debe esperar n Los lectores abandonan el sistema y el escritor continúa n Los escritores abandonan el sistema, y el último lector continúa y abandona

 Mariano Gómez Plaza Sincronización de procesos 25 Problema de los filósofos n Variables compartidas: exmut semaforo[N] void filosofo (int i) { while (TRUE) { piensa(); toma_tenedores(i); come(); pon_tenedores(i); } } /* Fin de filosofo */

 Mariano Gómez Plaza Sincronización de procesos 26 Problema de los filósofos void toma_tenedores(int i) { P(exmut); estado[i] = HAMBRIENTO; comprueba(i); V(exmut); P(semaforo[i]); } /* Fin de toma_tenedores */ void pon_tenedores(int i) { P(exmut); estado[i] = PENSANDO; comprueba((i-1)%N); comprueba((i+1)%N); V(exmut); } /* Fin de pon_tenedores */

 Mariano Gómez Plaza Sincronización de procesos 27 Problema de los filósofos void comprueba(int i) { if (estado[i] == HAMBRIENTO && estado[(i-1)%N] != COMIENDO && estado[(i+1)%N] != COMIENDO) { estado[i] = COMIENDO; V(semaforo[i]); } } /* Fin de comprueba */ n ¿A qué valores se deben iniciar los semáforos? n ¿Por qué la función comprueba siempre se invoca desde una sección crítica?

 Mariano Gómez Plaza Sincronización de procesos 28 Problema del barbero dormilón n Problema: 1 barbero y N sillas de espera n Si un cliente entra y no hay sillas, se va n Semáforos: clientes : número de clientes en espera sin contar el que está en la silla del peluquero barberos : número de barberos inactivos exmut : exclusión mutua n Variable compartida: esperando : número de clientes esperando n Inicialmente: clientes=0 barberos=0 exmut=1 esperando=0

 Mariano Gómez Plaza Sincronización de procesos 29 Barbero Cliente do { P(exmut); if (esperando < SILLAS) { esperando=esperando + 1; V(clientes); V(exmut); P(barberos); /* Se corta el pelo */ } else { V(exmut); } } while (PELOLARGO); do { P(clientes); P(exmut); esperando=esperando-1; V(barberos); V(exmut); /* Corta el pelo */ } while (TRUE);

 Mariano Gómez Plaza Sincronización de procesos 30 Problema del puente estrecho n Por un puente sólo pueden pasar o coches que suben o coches que bajan. n Solución: n Variables compartidas: int contadorsubida = 0, contadorbajada = 0; semaforo exmut_s, exmut_b, puente; n Iniciación: n Los semáforos inicialmente deben valer 1 n No se tratan los problemas de inanición

 Mariano Gómez Plaza Sincronización de procesos 31 Código subidaCódigo bajada P(exmut_s); contadorsubida++; if (contadorsubida == 1) P(puente); V(exmut_s);... Se sube el puente... P(exmut_s); contadorsubida--; if (contadorsubida == 0) V(puente); V(exmut_s); P(exmut_b); contadorbajada++; if (contadorbajada == 1) P(puente); V(exmut_b);... Se baja el puente... P(exmut_b); contadorbajada--; if (contadorbajada == 0) V(puente); V(exmut_b);

 Mariano Gómez Plaza Sincronización de procesos 32 Codificación los semáforos n Las primitivas P y V se realizan por SW n Razón: P y V se ven implicados en aspectos de planificación n Partimos de la siguiente declaración: typedef struct { int contador; (cola q;) int t; /* Para multiprocesadores */ } SEMAFORO; n En el caso de los semáforos con espera activa el código entre paréntesis sobra

 Mariano Gómez Plaza Sincronización de procesos 33 P y V en spin locks (espera activa) P (SEMAFORO *s) { while (1) { cli; if (s->contador > 0) { s->contador- = 1; sti; return; } sti; } /* fin del while */ } V (SEMAFORO *s) { cli; s->contador+ = 1; sti; }

 Mariano Gómez Plaza Sincronización de procesos 34 P y V en sistemas uniprocesador P (SEMAFORO *s) { cli; if (s->contador > 0) { s->contador- = 1; sti; return; } Añadimos proc. a s->q sti; Planificación } V (SEMAFORO *s) { cli; if (s->q == vacía) { s->contador+ = 1; } else { Sacar proceso de s->q Despertarlo } sti; }

 Mariano Gómez Plaza Sincronización de procesos 35 P y V en sistemas multiprocesador P (SEMAFORO *s) { while (TAS(s->t) != 0); if (s->contador > 0) { s->contador- = 1; s->t = 0; return; } Añadimos proc. a s->q s->t = 0; Planificación } V (SEMAFORO *s) { while (TAS(s->t) != 0); if (s->q vacía) { s->contador+ = 1; } else { Sacar proceso de s->q; Despertarlo; } s->t = 0; }

 Mariano Gómez Plaza Sincronización de procesos 36 Comunicación con mensajes n Válido para comunicación intermáquina n Definición: l Mensaje: parte de información que es pasada de un proceso a otro l Buzón: lugar donde se depositan los mensajes desde el envío a la recepción n Operaciones sobre mensajes: l Enviar l Recibir

 Mariano Gómez Plaza Sincronización de procesos 37 Métodos de comunicación n Comunicación en un único sentido: los mensajes fluyen en un único sentido l Ejemplos: Tuberías de UNIX, productor- consumidor y streams n Comunicación bidireccional: los mensajes fluyen en ambos sentidos l Ejemplos: Llamadas a procedimientos remotos (RPC´s) o el modelo cliente-servidor

 Mariano Gómez Plaza Sincronización de procesos 38 Ejemplos n Productor: int mensaje1[1000]; while (1) { --Preparamos el mensaje1-- enviar (mensaje1, buzón); } n Cliente: char resp[1000]; envia(“leer vax”, buzon1); recibir (resp, buzon2); n Consumidor: int mensaje2[1000]; while (1) { recibir (mensaje2, buzón); --Procesamos el mensaje2-- } n Servidor: char orden[100]; char resp[1000]; recibir (orden, buzon1); enviar (resp, buzon2);

 Mariano Gómez Plaza Sincronización de procesos 39 ¿Por qué utilizar mensajes? n Muchas aplicaciones responden a este esquema n Las partes que se comunican pueden ser completamente independientes. n Ventajas: l Es más difícil que se produzcan errores l Permite que los procesos no confíen entre sí l Las aplicaciones pueden ser escritas por programadores y en tiempos diferentes l Los procesos pueden correr en diferentes procesadores, conectados a través de una red

 Mariano Gómez Plaza Sincronización de procesos 40 Implementación de los mensajes n Nombres l Comunicación simétrica l Comunicación asimétrica n Copiado l Paso por valor: es lento y obligatorio en sistemas sin memoria compartida l Paso por referencia: es rápido pero hay problemas con su modificación Híbrido: copy-on-write

 Mariano Gómez Plaza Sincronización de procesos 41 Implementación de los mensajes n Bloqueo versus no bloqueo l enviar y recibir pueden ser bloqueantes o no l Formas de espera en un buzón: Varios procesos pueden esperar en un buzón Un proceso puede esperar en varios buzones n Longitud l Mensajes de longitud fija l Mensajes de longitud variable