Sincronización de Procesos Semáforos Emely Arráiz Ene-Mar 08

Conceptos Herramienta de sincronización (provista por el SO). Un semáforo S es una variable de tipo entero, que además de ser inicializada. Puede ser accedida a través de dos operaciones atómicas y mutuamente excluyentes –wait(S) o P(S) o down(S)‏ –signal(S) o V(S) o up(S)‏ Para evitar busy-waiting, cuando un procesos tiene que esperar, se pondra en una cola de procesos bloqueados esperando un evento.

Conceptos Semáforo puede ser implementado como una estructura con dos campos –count : integer –queue: list of processes Cuando un proceso debe esperar por un semáforo S, el es bloqueado (block() ) y colocado en la cola del semaforo. La operación de signal remueve (wakeup() )un proceso desde la cola y lo coloca en la lista de procesos ready.

Semáforos binarios y semáforos generales Semáforo binario – Solo puede tener dos valores, 0 y 1, y es la forma más común de semáforo. Semáforo general – Son semáforos que pueden tomar muchos valores positivos.

Semáforos type semaphore = record count: integer; queue: list of process end; var S: semaphore; Cuando un proceso debe esperar a un semáforo S, se bloquea y se pone en la cola del semáforo S. La operación signal quita (con la política FIFO) un proceso de la cola y lo pone en la cola de procesos listos.

Observaciones de Semaforos (Negativos)‏ Si S.count >=0 – El número de procesos que pueden ejecutar wait(S) sin que se bloqueen = S.count Si S.count<0 – el número de procesos que están esperando en S es = S.count|

Semáforos sin busy-waiting wait(S): S.count- -; if (S.count < 0) { colocar este proceso en S.queue block este proceso (block)‏, o sleep el proceso { signal(S): S.count++; if (S.count < = 0){ remover el proceso de la cola colocar este proceso en lista de ready (wakeup(P))‏ } La magnitud del valor negativo es el numero de procesos en waiting.

Operaciones Atomicidad y exclusión mutua implica que dos procesos NO pueden estar en wait(S) y signal(S) al mismo tiempo sobre el mismo S. Los bloques de código definidos por wait (S) y signal (S) son secciones críticas. Las secciones críticas definidas por wait (S) y signal (S) son muy cortas, típicamente 10 instrucciones.

Exclusión Mutua N procesos. S inicializado en 1. Un solo proceso le es permitido entrar en la SC. Proceso Pi: repeat wait(S)‏ SC signal(S)‏ RS until false

Sincronización Sea P1 y P2 dos procesos. La instr. S1 de P1 necesita ser ejecutada antes que la instr. S2 de P2. Definimos un semáforo synch, el cual inicializamos en cero. synch=0 La sincronización la obtenemos P1: S1; signal(synch); P2: wait(synch); S2;

Synchronizing with Semaphores Mutual Exclusion: Mutual Exclusion: wait (mutex); critical section signal(mutex); Synchronization: Synchronization: requirement: S2 executed after S1 is completed Synch = 0 (Synch); P1: S1;P2:wait(Synch); (Synch); signal(Synch);S2;

deadlocks with Semaphores... Two processes p 0 and p 1 QS Two semaphores Q and S p 0 : p 1 : (S);wait(Q); wait(S);wait(Q); wait(Q);wait(S); ….….. signal(S);signal(Q); signal(Q);signal(S); p 0 does the first line, then p 1 and so on...

More on Synchronization... Three processes p1; p2; p3 s1 = 1, s2 = 0 semaphoress1 = 1, s2 = 0; p1p2p3 p1 p2 p3 s1s2s2 wait(s1);wait(s2);wait(s2);.. code.... code.... code.. s2s2s1 signal(s2);signal(s2);signal(s1); the ordering of the processes is (p1(p2*(p3)))*

What’s wrong with busy waiting Wastes cpu time by waiting Side effects:  Two processes with different priorities arrive at their critical section in an order inverse to their priorities  The higher priority process gets time-slices  The lower priority process cannot complete its processing of its critical section and leave ! Priority Inversion

Semaforos Binarios Los semaforos que hemos estudiado son llamados contadores o enteros. Tenemos tambien semáforos binarios. –Similar a los anteriores solo que count tiene valor boolean

Spinlocks Son semáforos enteros que usan busy waiting, en lugar de blocking. Util sobre multiprocesadores ….. Se gasta tiempo de CPU pero salvamos switch entre procesos wait(S): S--; while S< 0 do{} signal(S): S++;

Problemas Clásicos. Sincronización Bounded- Buffer Readers and Writers Dining - philosophers

Bounded - Buffer N :buffer de un items cada uno. mutex :semáforo inicializado en 1. Full : semáforo inicializado en 0. (contador)‏ Empty : semáforo inicializado en N. (contador)‏ La estructura del proceso Productor while (TRUE) { (Obs: el productor por Empty >0 produce item; para poder anadir items. wait(Empty); wait(mutex); añade item al buffer; signal(mutex); signal(Full); }

Bounded- Buffer (cont)‏ La estructura del proceso consumidor while (TRUE) { (Obs: El consumidor espera por Full>0)‏ wait(Full); wait(mutex); remueve item del buffer; signal(mutex); signal(Empty); consume item; }

Readers - Writers Data es compartida entre diferentes procesos concurrentes. Lectores: leen solamente. No ejecutan modificaciones. Escritores: leen y escriben Problema: permitir múltiples lectores pero solamente un escritor. Procesos lectores nunca esperan a menos que un escritor esté en su sección crítica. Data compartida Conjunto de datos. mutex :semáforo inicializado en 1. wrt : semáforo inicializado en 1. readcount : entero inicializado 0.

Readers-Writers (cont.)‏ Writer[1..n] La estructura del proceso escritor while (TRUE) { wait(wrt); escribo; signal(wrt); }

Readers-Writers (cont.)‏ La estructura del proceso. Reader[1..m] lector while (TRUE) { wait(mutex); readcount++; if (readcount == 1) wait(wrt); signal(mutex); ejecuta lectura; wait(mutex); readcount-- ; if (readcount == 0) signal(wrt); signal(mutex); }

Dining Philosophers Clásico Problema de Sincroniza ción. Datos compartidos 1 bowl de Rice semaforos tenedor[5] inicializado 1 1 semaforo 5 4 3

Problema Cada filósofo es un proceso. Un semáforo por tenedor fork: array[0..4] of semáfores. Para todo i inicializar fork[i].count=1

Filósofos - Solución Process Pi repeat think; wait(fork[i]); wait(fork[(i+1) mod 5]); eat; signal(fork[(i+1) mod 5]); signal(fork[i]); until false Problema : Deadlock

Filósofos - Solución #define N 5 #define RIGHT(i) (((i)+1) %N)‏ #define LEFT(i) (((i)== N) ? 0 : (i)+1)‏ Typedef enum { THINKING, HUNGRY, EATING } phil_state; phil_state state [N] ; Semaphore mutex = 1; Semaphore s [N] ; void test (int i) { if (state [i] == HUNGRY && state [LEFT(i)] != EATING && state [RIGHT(i)] != EATING ) { state [i] == EATING; signal(s[i]); } } void get_forks(int i) { wait(mutex); state [i] == HUNGRY; test(i); signal(mutex); wait(s[i]); }

Filósofos – Solución (cont.)‏ void put_forks(int i) { wait(mutex); state [i] == THINKING; test(LEFT(i)); test(RIGHT(i)); signal(mutex); } void philosopher(int i) { while(1) { think(); get_forks(process); eat(); put_forks(process); }

Problemas con Semáforos Semáforos son herramientas poderosas para exclusión mutua y coordinación de procesos. Difícil entender sus efectos cuando los wait(S) y signal(S) están esparcidos entre varios procesadores. Uso debe ser correcto en todos los procesadores. Es fácil cometer errores en la programación de los semáforos El tiempo durante el cual un proceso está bloqueado en un semáforo no está limitado.