Sincronización de Procesos Conceptos Problema SC Soluciones Software Soluciones Hardware Emely Arráiz Ene-Mar 08

Conceptos Acceso concurrente de datos compartidos puede resultar en inconsistencia de datos. Mantener consistencia de la data requiere de mecanismos para asegurar orden de ejecución de los procesos cooperante. Exclusión Mutua: mecanismo que asegura que solamente un proceso está haciendo cierta cosa en el tiempo. Sección Crítica: una parte del código en la cual solamente un proceso puede estar ejecutándose. Sincronización: el uso de operaciones atómicas para asegurar la operación correcta de los procesos colaboradores.

Problema S C. Race Condition Procedure Deposito(cantidad: integer)‏ begin micuenta := micuenta + cantidad end Parbegin Deposito(100)‏ Deposito(50)‏ Parend

Problema S C Load reg1,micuenta add reg1,cantidad store reg1,micuenta Valor inicial de micuenta = 1000 Deposito1 Deposito2 local cantidad= 100 local cantidad =50 load reg1,micuenta add reg1,cantidad load reg1,micuenta store reg1,micuenta add reg1,cantidad store reg1,micuenta

Problema Sección Crítica N procesos todos compitiendo por el uso de algún dato compartido. Cada proceso tiene un segmento de código, llamado sección crítica, en el cual los datos compartidos son accesados. Problema: diseñar un protocolo que los procesos puedan usar, de forma tal que su acción no dependa del orden de sus ejecuciones

Problema Sección Crítica (cont.)‏ Estructura del proceso P While (TRUE) { entrada a la SC SC salir de la SC resto del bloque }

Solución al Problema SC Exclusión Mutua: Si el proceso P i se está ejecutando en su SC, ningún otro proceso puede estar ejecutandose en su SC. Progreso: Si ningún proceso se está ejecutando en su SC y existe alguno que desea entrar, se le debe garantizar su entrada sin demora. Espera Acotada: Ningún proceso debe esperar indefinidamente para entrar a su SC. El número de veces que un proceso se le puede colear a otro es acotada. (No deadlock,No starvation)‏

Exclusión Mutua

Problema Solamente 2 Procesos P0,P1 Estructura del Proceso P0 (P1)‏ while (TRUE) { entrada SC SC salir SC resto del bloque } Proceso pueden compartir algunas variables comunes, para sincronizarse.

Soluciones Soluciones por Software Algoritmos que garantizan la solución Soluciones por hardware Basadas en instrucciones de máquinas Soluciones del Sistema de Operación proveen algunas funciones y estructuras de datos para el programador.

Algoritmo 1 Variables compartidas –var turn: 0..1 – turn = 0 –turn = i => Pi puede entrar a su SC Proceso Pi repeat while turn != i do no-op SC turn := j resto del bloque (RS)‏ until false

Algoritmo 1 (cont.)‏ Satisface exclusión Mutua. No Satisface Progreso, ya que requiere estricta alternabilidad entre procesos. process blocked by another process outside its critical section!!. Ej. Supongamos que P0 tiene un largo RS y P1 lo tiene pequeño. Si turn=0, P0 entra a la SC y luego turn=1 y entra en su largo RS. P1 entra a su SC y luego turn=0 y a su corto RS de la cual sale. Trata de vuelta de entrar a SC. Requerimiento rechazado, el debe espera hasta que P0 deje su RS.

Algoritmo 2 Variables compartidas –var flag: array[0..1] of boolean – flag[0] = flag[1] = false –flag[i] = true => Pi listo para entrar en la SC Proceso Pi repeat flag[i] := true while flag[ j ] do no-op SC flag[i] := false RS until false

Algoritmo 2 (cont.)‏ Satisface exclusión Mutua. No Satisface Progreso processes can wait forever for each other!! Si un proceso falla dentro de su SC, el otro proceso se queda bloqueado. Si ambos proceso colocan su flags en verdad antes de ejecutar el while, cada uno de ellos piensa que el otro esta en su SC, causando un DEADLOCK

Algoritmo 3 (Peterson´s)‏ Combina 1 y 2 flag[0]=flag[1]=false; turn=0 o 1 Proceso Pi repeat flag[i] := true; turn := j; while( flag[ j ] and turn = j ) do no-op SC flag[i] := false RS until false

Algoritmo 3 (cont.)‏ Satisface exclusión Mutua. Satisface Progreso. P i no puede entrar a SC solamente, looping en el while con flag[j]=true y turn=j Si P j no esta listo para entrar a SC flag[j]=false, por lo que P i puede entrar. Satisface Espera acotada. Resuelve el problema de SC pero para dos procesos.

Algoritmo Bakery N procesos Antes de entrar a su SC, los procesos reciben un número. Si los procesos P i y P j reciben el mismo número, si i<j, entonces P i es servido primero, en caso contrario P j. El esquema de numeración siempre genera números en orden creciente. Ej 1,2,3,3,3,4,5….

Algoritmo Bakery (# ticket, # procid)‏ (a,b) < (c,d) si a < c o si a = c y b< d max(a0,…..an-1) es un número k tal que k >= ai para i= 0,…..n-1 datos compartidos var choosing: array[0,..n-1] of boolean number: array[0,…n-1] of integer las estructura son inicializadas en falso y cero respectivamente.

Bakery (cont.)‏ repeat choosing[i] := true; number[i] := max(number[0],... number[n-1] )+1; choosing[i] := false; for j:=0 to n-1 do begin while(choosing[ j ] ) do no-op while number[j] != 0 and (number[j],j) <(number[i],i) do no-op end SC number[i] := 0 RS until false

Desventajas por Software Los procesos que están solicitando entrar en su SC están consumiendo tiempo de procesador innecesariamente. Si sus SC son grandes, debería ser mas eficiente bloquear a estos procesos que estar esperando.

Soluciones por Hardware Deshabilitar interrupciones Proceso P i repeat disable interrupts SC enable interrupts RS until false

Soluciones por Hardware Exclusión Mutua es preservada sobre un procesador; pero la eficiencia de ejecución es degradada ya que todos los otros procesos están prohibidos de interrumpir Sobre multiprocesadores no se cumple Exclusión Mutua

Soluciones por Hardware TSL (Test and set lock)‏ Probar y modificar el contenido de una palabra atómicamente. Function Test-and-Set(var target:boolean):boolean; begin Test-and-Set := target target := true end

Test and Set var lock: boolean. Inicializada en false Proceso P i repeat while Test-and-Set(lock) do no-op SC lock := false RS until false

Test and Set Si Pi entra en SC, el otro Pj esta en busy waiting. Cumple Exclusión Mutua Puede ser usado para cualquier número de procesos. Cuando P i sale, la selección del P j quien debería entrar es arbitraria. Espera no acotada Por lo que starvation es posible. No deadlock. Garantiza progreso.

Implement “fairness” with TSL test_and_set(int flag) test_and_set(int flag) - TSL #1,flag and return(flag)‏ { interested(i) = TRUE; test = TRUE; while(interested(i) == TRUE && test == TRUE) test_and_set(lock); test = test_and_set(lock); interested(i) = FALSE; }... critical section... { j = i+1 % n; while(j != i && !(interested(j))) j++ % n; if(j == i) lock = FALSE; else interested(j) = FALSE; }

Swap Definición void swap(boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp; } Solución usando swap Variable global lock = FALSE Cada proceso tiene una variable local key Pi: while (TRUE) { key = TRUE; while ( key == TRUE) swap ( &lock, &key); SC lock = FALSE; RS }