Estados de un proceso

Transcripción

1 Semáforos

2 Estados de un proceso Inactivo Listo Ejecutando Completo Escribimos p.state := ready p. state := running Bloqueado Para indicar que un proceso cambia de estado

3 Semáforo Es un tipo de dato abstracto Operaciones wait (originalemente P) and signal (org. V)

4 Semáforo Es un tipo de dato abstracto Representación: int V; conjunto<procesos> L;

5 Semáforo wait(semáforo S) if S.V > 0 then S.V := S.V -1 else S.L := S.L {p} p.state := bloqueado

6 Semáforo wait(semáforo S) if S.V > 0 then S.V := S.V -1 else S.L := S.L {p} p.state := bloqueado p denota el proceso que invoca a la operación wait

7 Semáforo signal(semáforo S) if S.L = then S.V := S.V + 1 else let p S.L S.L := S.L {p} p.state := ready

8 Semáforo binario (o mutex) Es un semáforo donde V puede tomar valores 0 o 1 (true, false) signal(semáforo S) if S.V = 1 then //indefinido if S.L = then S.V := S.V + 1 else let p S.L S.L := S.L {p} p.state := ready

9 Invariantes de semáforo Teorema: a. S.V 0 b. S.V = k + #signal(s) - # wait(s) Se considera que un proceso bloqueado en un wait no realizó la operación wait

10 Exclusión mutua con mutex Usar un semáforo binario S inicializado en V= 1 L= ThreadId = 0 ThreadId = 1 while(true) Sección no crítica wait(s) Sección crítica signal(s) while(true) Sección no crítica wait(s) Sección crítica signal(s)

11 La exclusión mutua basada en semáforos es correcta a. #CS = #wait(s) - #signal(s) b. #CS + S.V = 1 Son invariantes Prueba) a. Por inducción estructural en el programa. b. Usando invariante semáforos S.V = k + #signal(s) - # wait(s) valor inicial = 1 S.V = 1 + #signal(s) - # wait(s) por a. S.V = 1 - #CS luego #CS + S.V = 1

12 La exclusión mutua basada en semáforos es correcta a. #CS = #wait(s) - #signal(s) b. #CS + S.V = 1 Son invariantes Prueba) a. Por inducción estructural en el programa. b. Usando invariante semáforos S.V = k + #signal(s) - # wait(s) valor inicial = 1 S.V = 1 + #signal(s) - # wait(s) por a. S.V = 1 - #CS luego #CS + S.V = 1 Cantidad de procesos ejecutando su región crítica

13 La exclusión mutua basada en semáforos es correcta a. #CS = #wait(s) - #signal(s) b. #CS + S.V = 1 Son invariantes Prueba) a. Por inducción estructural en el programa. b. Usando invariante semáforos S.V = k + #signal(s) - # wait(s) valor inicial = 1 S.V = 1 + #signal(s) - # wait(s) por a. S.V = 1 - #CS luego #CS + S.V = 1

14 La exclusión mutua basada en semáforos es correcta Notar que #CS + S.V = 1 a) garantiza la exclusión mutua (#CS 1) a) garantiza que no hay deadlock dado que deadlock sería dos procesos bloqueados en wait, esto implica S.V = 0 y #CS = 0. a) garantiza que no hay starvation dado que un proceso debería estar siempre en el conjunto de bloqueados. Para esto el otro debe estar en su sección crítica, pero cuando completa la sección critica ejecuta signal. Como hay dos procesos, el otro debe pasar a listo y entrar en la sección crítica.

15 Sección crítica para N procesos Qué sucede cuando tenemos varios procesos?

16 Sección crítica para N procesos Qué sucede cuando tenemos varios procesos? Hay posibilidad de starvation Notar que la operación signal puede desbloquear un proceso cualquiera del conjunto. Esto puede solucionarse cambiando el conjunto por una cola

17 Semáforos fuertes La definición de semáforos que vimos es débil (los procesos bloqueados están en un conjunto) En los semáforos fuertes el conjunto de procesos bloqueados se remplaza por una cola (FIFO)

18 Filósofos comensales (dinning philosophers) Hay un grupo de filósofos que pasa su tiempo pensando y comiendo Hay tantos tenedores como filósofos Un filósofo puede comer sólo cuando tiene dos tenedores Un filósofo puede tomar sólo los tenedores a su izquierda y a su derecha

19 Filósofos comensales El comportamiento de cada filósofo podría describirse como Filosofo_N While(true){ pensar tomar tenedores comer liberar tenedores }

20 Filósofos comensales Un problema de concurrencia clásico Mutex: en un momento dado sólo un filósofo puede tener un tenedor dado Sincronización condicional: un filósofo puede comer sólo cuando tiene dos tenedores Deadlock Livelock Starvation

21 Filósofos comensales Usando N semáforos Filosofo(i) izq = i; der = (i+1)%n; While(true){ pensar wait(tenedores[izq]) wait(tenedores[der]) comer signal(tenedores[izq]) signal(tenedores[der]) }

22 Filósofos comensales Si dos filósofos toman el tenedor izquierdo al mismo tiempo se produce deadlock En general, el deadlock ocurre porque se crea una espera circular

23 Solución 1- Romper la simetría

24 Solución 1- Romper la simetría Uno de los filósofos se debe comportar distinto Tomar primero el tenedor a su derecha y luego el que está a su izquierda Filosofo(i) if (i == 0) {izq = 1; der = 0} else {izq = i; der = (i+1)%n} While(true){ pensar wait(tenedores[izq]) wait(tenedores[der]) comer signal(tenedores[izq]) signal(tenedores[der]) }

25 Solución 2- Reducir la concurrencia No permitir a todos los filósofos tomar tenedores Usar un semáforo sillas con N-1 permisos Filosofo(i) izq = i; der = (i+1)%n While(true){ pensar wait(sillas) wait(tenedores[izq]) wait(tenedores[der]) comer signal(tenedores[izq]) signal(tenedores[der]) signal(sillas) }

26 Solución 2- Reducir la concurrencia

27 Solución 2- Reducir la concurrencia No permitir a todos los filósofos tomar tenedores

28 Solución 2- Reducir la concurrencia No permitir a todos los filósofos tomar tenedores Usar un semáforo sillas con N-1 permisos Filosofo(i) izq = i; der = (i+1)%n While(true){ pensar wait(sillas) wait(tenedores[izq]) wait(tenedores[der]) comer signal(tenedores[izq]) signal(tenedores[der]) signal(sillas) }

29 Productor/Consumidor Es un patrón de interacción frecuente El problema es cómo manejamos las diferentes velocidades entre la producción y la consumición

30 Buffer no acotado Productor puede trabajar libremente Consumidor debe esperar al productor

31 Buffer acotado El productor tiene que esperar cuando el buffer está lleno Consumidor tiene que esperar cuando el buffer está vacío

32 Buffers usando semáforos Capacidad 1 Varios productores Varios consumidores Semáforos

33 Semáforos binarios split Dos semáforos 1 semáforo para indicar cuándo hay espacio libre en el buffer (vacío) 1 semáforo para indicar cuándo hay un elemento en el buffer (lleno) Inicialización Vacio = 1; Lleno = 0; Invariante Vacio + lleno 1

34 Exclusión mutua con mutex Usar dos semáforos binarios aparte del buffer compartido vacio= 1 lleno= 0 Productor While(true) { producir dato wait(vacio) buffer = dato signal(lleno) } Consumidor While(true) { wait(lleno) dato = buffer signal(vacio) Consumir dato }

35 Buffer de tamaño N Los productores agregan al frente Los consumidores toman de atrás

36 Semáforos generales Los semáforos cuentan la cantidad de espacios en el buffer Inicialización Hay N espacios vacios Hay 0 espacio lleno Invariante Vacío+lleno N

37 Semáforos generales Variables compartidas Semaforo vacio = N; Semáforo lleno = 0; Dato buffer[n] int Inicio = 0; int Fin = 0;

38 Único Productor Productor While(true) { producir dato wait(vacio) buffer[inicio] = dato inicio = (inicio + 1) % N; signal(lleno) }

39 Múltiples Productores Usar un semáforo para sincronizar los productores mutexp = 1 Productor While(true) { producir dato wait(vacio) wait(mutexp) buffer[inicio] = dato inicio = (inicio + 1) % N; signal(mutexp) signal(lleno) }

40 Múltiples Consumidores Usar un semáforo para sincronizar los consumidores mutexc = 1 Productor While(true) { producir dato wait(lleno) wait(mutexc) dato = buffer[fin] fin = (fin + 1) % N; signal(mutexc) signal(vacio) }

41 Lectores/Escritores

42 Lectores/Escritores (Prioridad Lectores) Lector! Semáforo escribir = 1, mutex = 1! Variable compartida #lect = 0 Escritor While(true) { wait(mutex) #lect ++ if (#lect = 1) then wait(escribir) signal(mutex) // leer wait(mutex) #lect -- if (#lect = 0) then signal(escribir) signal(mutex) While(true) { wait(escribir) // escribir signal(escribir) }

43 Lectores/Escritores (Prioridad escritores) Escritores)! Semáforo escribir = 1, leer = 1, mutexl = 1, mutexe = 1, mutex= 1.! Variable compartida #lect = 0, #esc = 0 Lector While(true) { wait(mutex) wait(leer) wait(mutexl) #lect ++ if (#lect = 1) then wait(escribir) signal(mutexl) signal(leer) signal(mutex) // leer wait(mutexl) #lect -- if (#lect = 0) then signal(escribir) signal(mutexl) } Escritor While(true) { wait(mutexe) #esc ++ if (#esc = 1) then wait(leer) signal(mutexe) wait(escribir) // escribir signal(escribir) wait(mutexe) #esc -- if (#esc = 0) then signal(leer) signal(mutexe) }