Se ha denunciado esta presentación.
Se está descargando tu SlideShare. ×
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Anuncio
Cargando en…3
×

Eche un vistazo a continuación

1 de 28 Anuncio
Anuncio

Más Contenido Relacionado

Presentaciones para usted (20)

Similares a Semaforos (20)

Anuncio

Semaforos

  1. 1. Sincronización de Procesos Semáforos Emely Arráiz Ene-Mar 08
  2. 2. 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.
  3. 3. 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.
  4. 4. 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.
  5. 5. 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.
  6. 6. 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|
  7. 7. 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.
  8. 8. 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.
  9. 9. 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
  10. 10. 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;
  11. 11. Synchronizing with SemaphoresSynchronizing with Semaphores ♥Mutual Exclusion:Mutual Exclusion: wait(mutex); critical section signal(mutex); ♥Synchronization:Synchronization: requirement: S2 executed after S1 is completed Synch = 0 P1: S1; P2: wait(Synch);(Synch); signal(Synch);(Synch); S2;
  12. 12. deadlocks with Semaphores...deadlocks with Semaphores... ♥Two processes p0 and p1 ♥Two semaphores QQ and SS p0 : p1: wait(S);(S); wait(Q);wait(Q); wait(Q);wait(Q); wait(S);wait(S); …….. …..….. signal(S);signal(S); signal(Q);signal(Q); signal(Q);signal(Q); signal(S);signal(S); ♥ p0 does the first line, then p1 and so on...
  13. 13. More on Synchronization...More on Synchronization... Three processes p1; p2; p3 semaphores s1 = 1, s2 = 0s1 = 1, s2 = 0; p1p1 p2p2 p3p3 wait(s1s1); wait(s2s2); wait(s2s2); .. code .. .. code .. .. code .. signal(s2s2); signal(s2s2); signal(s1s1); the ordering of the processes isthe ordering of the processes is ((p1(p2*(p3)))*p1(p2*(p3)))*
  14. 14. What’s wrong with busy waitingWhat’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
  15. 15. 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
  16. 16. 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++;
  17. 17. Problemas Clásicos. Sincronización  Bounded- Buffer  Readers and Writers  Dining - philosophers
  18. 18. 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); }
  19. 19. 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; }
  20. 20. 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.
  21. 21. Readers-Writers (cont.) Writer[1..n] La estructura del proceso escritor while (TRUE) { wait(wrt); escribo; signal(wrt); }
  22. 22. 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); }
  23. 23. 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
  24. 24. 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
  25. 25. 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
  26. 26. 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]); }
  27. 27. 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); } }
  28. 28. 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.

×