El documento describe varios algoritmos para resolver el problema de la sección crítica en sistemas concurrentes. Introduce el problema de la carrera y presenta soluciones de software como los algoritmos de Peterson y Bakery que garantizan exclusión mutua y progreso para dos y más procesos respectivamente. También cubre soluciones de hardware como desactivar interrupciones y usar instrucciones de prueba y establecimiento atómico.

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

2. 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.

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

4. 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

5. 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

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

7. 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)

8. Exclusión Mutua

9. 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.

10. 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.

11. 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

12. 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.

13. 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

14. 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

15. 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

16. 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.

17. Algoritmo Bakery
 N procesos
 Antes de entrar a su SC, los procesos reciben un
número.
 Si los procesos Pi
y Pj
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….

18. 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.

19. 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

20. 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.

21. Soluciones por Hardware
 Deshabilitar interrupciones
Proceso Pi
repeat
disable interrupts
SC
enable interrupts
RS
until false

22. 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

23. 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

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

25. 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 Pj
quien debería
entrar es arbitraria. Espera no acotada
Por lo que starvation es posible.
No deadlock. Garantiza progreso.

26. 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;
}

27. 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
}