Este documento describe diferentes herramientas de sincronización como semáforos, monitores y su aplicación en problemas clásicos. Explica cómo semáforos permiten sincronizar procesos mediante operaciones wait() y signal() y cómo pueden causar interbloqueos. También describe cómo monitores encapsulan variables compartidas y procedimientos para accederlas de forma segura entre procesos concurrentes, incluyendo el uso de variables de condición.

1. 1.SEMÁFOROS 2.PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 3. MONITORES GRUPO VI INTEGRANTES: Kruskaya Salazar Yadira Torres Santiago Plascencia SINCRONIZACIÓN DE PROCESOS

2. 1. SEMÁFORO Herramienta de sincronización que no requiere de espera ocupada. Señala si un recurso está libre y se puede utilizar el proceso. Semáforo S – variable entera. Puede solo ser accesada vía dos indivisibles (atómicas) operaciones wait(); y signal();. Wait, activa el proceso cuando encuentra codigo de condición ocupado wait (S): // P: proberen = probar while S≤ 0 ; // no-op; S--; Signal, queda activado cuando un proceso sale de la región crítica y el código de condición está como libre. signal (S): // V:verhogen = incrementar S++;

3. 1. SEMÁFORO – IMPLEMENTACIÓN Defina un semáforo como un registro typedef struct { int value; struct process *L; } semaphore; Suponga dos operaciones simples: block :suspende el proceso que lo invoco. wakeup( P) : reanuda la ejecución de un proceso P bloqueado

4. 1. SEMÁFORO - IMPLEMENTACIÓN wait(S): S.value--; if (S.value < 0) { agregar este proceso a la lista S.L; block; } signal(S): S.value++; if (S.value <= 0) { remover un proceso P de la lista S.L; wakeup(P); } Definamos las operaciones con semáforos como:

5. 1. SEMÁFORO - INTERBLOQUEOS E INANICIÓN Semáforo de conteo – valor entero con un rango sin restricciones dentro de un dominio. Semáforo binario – se los conoce también como cerrojos mútex. valor entero con un rango solo entre 0 y 1; puede ser el más simple de implementar. Puede implementarse un semáforo de conteo S como un semáforo binario. Dos o mas procesos están esperando indefidinamente a que se produzca otro proceso que solo puede ser consecuencia del resultado de otro proceso que esta en estado de espera, debido a la ejecución de la operación signal(), a esto se le atribuye que los procesos se han interbloqueado.

6. 1. SEMÁFORO - INTERBLOQUEOS DE INACICIÓN Interbloqueo(Deadlock) – dos ó más procesos están esperando indefinidamente por un evento que puede ser causado sólo por uno de los procesos que están en espera. Suponga que: S y Q son dos semáforos inicializados a 1 P0 P1 wait(S); wait(Q); wait(Q); wait(S); M M signal(S); signal(Q); signal(Q); signal(S); Inanición – bloqueo indefinido. Un proceso puede jamás ser removido de la cola de semáforos en la cual se encuentra suspendido

7. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.1. Problema del Buffer Limitado 2.2. Problema de los Lectores y Escritores 2.3 Problema de los Filósofos Comensales

8. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.1. Problema del Buffer Limitado Se utiliza para ilustrar la potencia de las primitivas de sincronización. Datos compartidos: semaphore full, empty, mutex; Inicialmente: full = 0, empty = n, mutex = 1 do { … //produce un item en nextp … wait(empty);//Cuenta el # de bufferes vacios y llenos wait(mutex); … //agrega nextp al buffer … signal(mutex); signal(full);// Cuenta el # de bufferes vacios y llenos } while (1);

9. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.1. Problema del Buffer Limitado-Proceso Consumidor do { wait(full) wait(mutex); … //remueve un item desde el //buffer a nextc … signal(mutex); signal(empty); … //consume el item en nextc … } while (1);

10. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.2. Problema de los Lectores - Escritores Esta estructura de utiliza para asegurar q los problemas generados por acceder simultáneamente un escritor y algún otro proceso no afloren. Lectores-Escritores Datos compartidos: semaphore mutex, wrt; Inicialmente: mutex = 1, wrt = 1, readcount = 0 Proceso Escritor. wait(wrt);// asegurar la exclusión mutua mientras actualioza la variable … //está escribiendo … signal(wrt);

11. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.3 Problema de los Filósofos Comensales Es un ejemplo de amplia clase de problemas de control de concurrencia Datos compartidos: semaphore chopstick[5 ]; //Inicialmente todos los valores son 1

12. 2. PROBLEMAS CLÁSICOS DE SINCRONIZACIÓN 2.3 Problema de los Filósofos Comensales Filósofo i: do { wait(chopstick[i]) wait(chopstick[(i+1) % 5]) … //comer … signal(chopstick[i]); signal(chopstick[(i+1) % 5]); … //pensar … } while (1);

13. 3. MONITORES 3.1 Utilización . 3.2 Solución al problema de la cena de los filósofos usando monitores. 3.3 Implementación de un monitor usando semáforos . 3.4 Reanudación de procesos dentro de un monitor.

14. 3.MONITORES Son una herramienta de sincronizacion mas estructurada que un semáforo encapsula variables compartidas en conjunto con los procedimientos para accesar esas variables. Son tipo de dato abstracto, por lo tanto los procesos llaman a los procedimientos del monitor en cualquier momento pero no pueden accesar directamente a las variables encapsuladas.

15. 3. MONITORES Permiten a un proceso esperar dentro del monitor, una variable de condición debe de ser declarada, como condition x, y; La variable de condición puede solo ser usada con las operaciones wait y signal. La operación x.wait(); significa que al proceso que invoca esta operación es suspendido hasta que algun otro proceso invoque x.signal(); La operación x.signal reanuda exactamente un proceso suspendido. If no hay proceso suspendido , then la operación signal no tiene efecto.

16. 3.MONITORES 3.1 Utilización Construcción de sincronización de alto-nivel que permite compartir con seguridad un tipo de datos abstracto entre procesos concurrentes. monitor nombre-monitor { //declaración de variables compartidas procedure body P1 (…) { . . . } procedure body P2 (…) { . . . } procedure body Pn (…) { . . . } { código de inicialización } }

17. 3.MONITORES 3.1 Utilización Visión Esquemática de un Monitor Monitor con Variables de Condición

18. 3.MONITORES 3.2 Solución al problema de la cena de los filósofos usando monitores. monitor dp { enum {thinking, hungry, eating} state[5]; condition self[5]; void pickup(int i) // siguiente movimiento void putdown(int i) // siguiente movimiento void test(int i) // siguiente movimiento void init() { for (int i = 0; i < 5; i++) state[i] = thinking; } } void pickup(int i) { state[i] = hungry; test[i]; if (state[i] != eating) self[i].wait(); } void putdown(int i) { state[i] = thinking; // probar vecinos izquierdo y derecho test((i+4) % 5); test((i+1) % 5); } void test(int i) { if ( (state[(I + 4) % 5] != eating) && (state[i] == hungry) && (state[(i + 1) % 5] != eating)) { state[i] = eating; self[i].signal(); } }

19. 3.MONITORES 3.3 Implementación de un monitor usando semáforos . Variables semaphore mutex; // (initially = 1) semaphore next; // (initially = 0) int next-count = 0; // Cada procedimiento externo F será reemplazado por wait(mutex); … body of F; … if (next-count > 0) signal(next) else signal(mutex); // La exclusión mutua dentro de un monitor está asegurada.

20. 3.MONITORES 3.3 Implementación de un monitor usando semáforos . Por cada variable de condición x, tenemos: semaphore x-sem; // (initially = 0) int x-count = 0; 􀂄 La operación x.wait puede ser implementada como: x-count++; if (next-count > 0) signal(next); else signal(mutex); wait(x-sem); x-count--; La operación x.signal puede ser implementada como: if (x-count > 0) { next-count++; signal(x-sem); wait(next); next-count--; }