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 Deposito2local cantidad= 100 local cantidad =50load reg1,micuentaadd reg1,cantidad load reg1,micuentastore 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 Pi 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 Progresoprocesses 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.

Pi no puede entrar a SC solamente, looping en el

while con flag[j]=true y turn=j

Si Pj no esta listo para entrar a SC flag[j]=false, por

lo que Pi 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 Pi es servido primero, en caso

contrario Pj.

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 Pi

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 Pi 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 TSLImplement “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 = test_and_set(lock);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;}

SwapDefinición void swap(boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp; }Solución usando swapVariable global lock = FALSECada proceso tiene una variable local key

Pi: while (TRUE) { key = TRUE; while ( key == TRUE) swap ( &lock, &key); SC lock = FALSE; RS}