Sincronizacin de Procesos

Semforos

Emely Arriz Ene-Mar 08

Conceptos


Herramienta de sincronizacin (provista por el SO). Un semforo S es una variable de tipo entero, que adems de ser inicializada. Puede ser accedida a travs de dos operaciones atmicas 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
Semforo puede ser implementado como una estructura con dos campos count : integer queue: list of processes  Cuando un proceso debe esperar por un semforo S, el es bloqueado (block() ) y colocado en la cola del semaforo.  La operacin de signal remueve (wakeup() )un proceso desde la cola y lo coloca en la lista de procesos ready.


Semforos binarios y
semforos generales

Semforo binario Solo puede tener dos valores, 0 y 1, y es la forma ms comn de semforo. Semforo general Son semforos que pueden tomar muchos valores positivos.

Semforos
type semaphore = record count: integer; queue: list of process end; var S: semaphore; Cuando un proceso debe esperar a un semforo S, se bloquea y se pone en la cola del semforo S. La operacin signal quita (con la poltica FIFO) un proceso de la cola y lo pone en la cola de procesos listos.

Observaciones de Semaforos (Negativos)

Si S.count >=0 El nmero de procesos que pueden ejecutar wait(S) sin que se bloqueen = S.count Si S.count<0 el nmero de procesos que estn esperando en S es = S.count|

Semforos 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 exclusin mutua implica que dos procesos NO pueden estar en wait(S) y signal(S) al mismo tiempo sobre el mismo S. Los bloques de cdigo definidos por wait (S) y signal (S) son secciones crticas. Las secciones crticas definidas por wait (S) y signal (S) son muy cortas, tpicamente 10 instrucciones.

Exclusin 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


Sincronizacin


Sea P1 y P2 dos procesos. La instr. S1 de P1 necesita ser ejecutada antes que la instr. S2 de P2.

Definimos un semforo synch, el cual inicializamos en cero. synch=0  La sincronizacin la obtenemos P1: S1; signal(synch);


P2:

wait(synch); S2;

Synchronizing with Semaphores

kMutual

Exclusion:

wait(mutex);

critical section signal(mutex);

kSynchronization:
requirement: S2 executed after S1 is completed Synch = 0 P1: S1; P2: wait(Synch); (Synch); signal(Synch); (Synch); S2;

deadlocks with Semaphores...

kTwo kTwo
p0 :
wait(S); (S); wait(Q); . signal(S); signal(Q);

processes p0 and p1 semaphores Q and S

p1:
wait(Q); wait(S); .. signal(Q); signal(S);

p0 does the first line, then p1 and so on...

More on Synchronization...
Three processes p1; p2; p3
semaphores s1 = 1, s2 = 0 0;

p1 wait(s1 s1); .. code .. signal(s2 s2);

p2 p3 wait(s2 s2); wait(s2 s2); .. code .. .. code .. signal(s2 s2); signal(s1 s1);

the ordering of the processes is (p1(p2*(p3)))*

Whats wrong with busy waiting

kWastes cpu time by waiting kSide effects:

jTwo processes with different priorities arrive at their critical section in an order inverse to their priorities jThe higher priority process gets time-slices jThe 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 semforos binarios. Similar a los anteriores solo que count tiene valor boolean


Spinlocks
Son semforos 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 Clsicos. Sincronizacin

Bounded- Buffer Readers and Writers Dining - philosophers

Bounded - Buffer
N :buffer de un items cada uno. mutex :semforo inicializado en 1. Full : semforo inicializado en 0. (contador) Empty : semforo inicializado en N. (contador) La estructura del proceso

Productor
while (TRUE) { produce item; wait(Empty); wait(mutex); aade item al buffer; signal(mutex); signal(Full); } (Obs: el productor por Empty >0 para poder anadir items.

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 mltiples lectores pero solamente un escritor. Procesos lectores nunca esperan a menos que un escritor est en su seccin crtica. Data compartida Conjunto de datos. mutex :semforo inicializado en 1. wrt : semforo 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
3 Clsico Problema de Sincroniza cin. 4 Datos compartidos 1 bowl de Rice semaforos tenedor[5] inicializado 1

1 semaforo

Problema
Cada filsofo es un proceso.  Un semforo por tenedor


fork: array[0..4] of semfores. Para todo i inicializar fork[i].count=1

Filsofos - Solucin
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

Filsofos - Solucin
#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]); }

Filsofos Solucin (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 Semforos

Semforos son herramientas poderosas para exclusin mutua y coordinacin de procesos.  Difcil entender sus efectos cuando los wait(S) y signal(S) estn esparcidos entre varios procesadores.  Uso debe ser correcto en todos los procesadores. Es fcil cometer errores en la programacin de los semforos  El tiempo durante el cual un proceso est bloqueado en un semforo no est limitado.