EXCLUSIÓN MUTUA

PROGRAMACIÓN PARALELA
Introducción
• La exclusión mutua –o sección crítica– es un problema básico y
fundamental de sincronización entre procesos con memoria
compartida; se trata de asegurar el acceso ordenado a recursos
compartidos para impedir errores e inconsistencias.
• El problema de los trabajos de impresión.
Definición
• Un conjunto de procesos independientes que pueden ser
considerados cíclicos ejecutan en cada ciclo una parte de código que
accede y modifica recursos o zonas de memoria compartidas, la
sección crítica. La intercalación de instrucciones en esas secciones
críticas provocan condiciones de carrera que pueden generar
resultados erróneos dependiendo de la secuencia de ejecución.
• Debemos asegurar la exclusión mutua de la ejecución de esas
secciones críticas; mientras se ejecuta una de ellas no se debe
permitir la ejecución de las secciones críticas de otros procesos.
• El modelo separa al código en
secciones críticas y resto del
•while forever:
código. La solución se basa en • # ...
desarrollar los algoritmos que se
insertan justo antes y después • cs_entry()
de las secciones críticas: • critical_section()
• Pre-protocolo o entrada a la
sección crítica. • cs_exit()
• Pos-protocolo o salida de la
sección crítica. • # ...
Requisitos
• Exclusión mutua
• Se debe asegurar que solo uno de los procesos ejecuta instrucciones de la
sección crítica.
• Progreso o libre de interbloqueos (deadlock free o lock-free)
• Si varios procesos desean entrar a la sección crítica al menos uno de ellos
debe poder hacerlo.
• Espera limitada o libre de inanición (starvation free o wait-free)
• Cualquier proceso debe poder entrar a la sección crítica en un tiempo finito.
Esta condición es deseable pero no siempre se puede asegurar.
Requisitos de Dijkstra
• La solución debe ser simétrica: no se permiten soluciones que
cambien el comportamiento o la prioridad estática de algún proceso.
• No se deben hacer suposiciones de la velocidad relativa de los
procesos, ni se puede suponer que las velocidades sean constantes.
• Entrada inmediata o no interferencia: un proceso que se interrumpe
en el resto del código no debe interferir ni bloquear a los demás
procesos.
• Si varios procesos desean entrar simultáneamente, la decisión en la
entrada de la sección crítica debe tomar un número finito de pasos.
Concurrencia en competencia de recursos

 Dos o mas procesos necesitan acceder a uno o mas recursos durante

sus ejecuciones.
 Los procesos no saben de la existencia de otros procesos y sus
operaciones no deben ser afectadas por la ejecución de otros
procesos.
 Entonces los procesos no deben afectar el estado de los recursos.
Concurrencia en competencia de recursos

 Problemas potenciales de control:

 Exclusión mutua (secciones criticas): Solo un programa a la vez puede ejecutar su
sección critica
 Deadlock (abrazo mortal):
 Starvation (inanición): Es posible que un proceso esperando por un recurso
bloqueado nunca lo obtenga
Exclusión mutua – Visión Abstracta

Proceso 1 Proceso 2
• void P1( ) • void P2( )
 {  {
• while(true){ • while(true){
• codigo antes de la SC • codigo antes de la SC
• enterCritical (Ra); • enterCritical (Ra);
• SC; • SC;
• exitCritical(RA); • exitCritical(RA);
• codigo despues de la SC • codigo despues de la SC
• } • }
 }  }
Algoritmos – Convenciones de prog.
• Los programas tienen secciones críticas y resto del código. No
podemos modificar las secciones críticas ni interesa lo que se hace en
el resto; de este último tampoco tenemos información del tiempo
que tarda o cómo se ejecuta.
• Finalmente, suponemos que el tiempo de ejecución de las secciones
críticas es finito.
• Nuestra responsabilidad será desarrollar los algoritmos para el pre y
pos protocolo.
Requerimientos para exclusión mutua

 Solo un proceso puede estar ejecutando su Sección Crítica (SC)

 Solo un proceso que no se encuentra en su SC no debe interferir con otros procesos que
deseen ingresar SC
 No se permite que un proceso que desea entrar en su SC espere indefinidamente: No
deadlock o inanición.
 Cuando ningún proceso esta en su SC, la solicitud de cualquier proceso para ingresar a su
SC no debe ser denegada.
 No se puede asumir nada respecto de la velocidad relativa y orden de la ejecución de
procesos
 Un proceso permanece en SC por un tiempo finito.
Algoritmo de Dekker
• El algoritmo de Dekker es un algoritmo de programación concurrente
para exclusión mutua, que permite a dos procesos o hilos de
ejecución compartir un recurso sin conflictos. Fue creado por el
matemático holandés Theodorus Jozef Dekker e implementado por
Edsger Dijkstra.
• Si ambos procesos intentan acceder a la sección critica
simultáneamente, el algoritmo elige un proceso según una variable
denominada turno. Si el otro proceso esta ejecutando en su sección
critica, el proceso deberá esperar que el otro finalice su ejecución de
la sección crítica.
Algoritmo de Dekker - Versiones
• Versión 1. Alternancia, su desventaja es que acopla los procesos
fuertemente, significa que los procesos lentos atrasan a los procesos
rápidos.
• Versión 2. Problema de interbloqueo, no existe alternancia, aunque
ambos procesos caen en un mismo estado y nunca salen de ahí.
Algoritmo de Dekker - Versiones
• Versión 3. Colisión de región critica, no garantiza la exclusión mutua,
este algoritmo no evita que dos procesos puedan ingresar al mismo
tiempo a la SC.
• Versión 4. Postergación indefinida, aunque los procesos no están en
interbloqueo, un proceso o varios se quedan esperando a que suceda
un evento que tal vez nunca suceda.
• Versión 5. Es la versión optimizada y no presenta los problemas
anteriores, el algoritmo esta basada de acuerdo al orden de prioridad
de desempeño y funcionamiento de las cuatro anteriores.
• PROGRAMA v5Dekker;
• Variables
• P1QE, P2QE: Bool;
• turno: Entero;
• Inicialización
• P1QE = false;
• P2QE = false;
• turno = 1;
Algoritmo de Dekker – Versión 5
• Repeat
• Hace_Cosas();
• P1QE = true;
• While P2QE Do
• Begin
• if (turno = 2)
• Begin
• P1QE = false;
• Delay (random());
• P1QE = true;
• end;
• end;
• REGION_CRITICA();
• turno = 2;
• P1QE = False;
• Hace_mas_cosas();
• Until Fin
• Repeat
• Hace_Cosas();
• P2QE = true;
• While P1QE Do
• Begin
• if (turno = 1)
• Begin
• P2QE = false;
• Delay (random());
• P2QE = true;
• end;
• end;
• REGION_CRITICA();
• turno = 1;
• P2QE = False;
• Hace_mas_cosas();
• Until Fin
Algoritmo de Peterson
• Desarrollo el primer algoritmo para dos procesos (1981) que fue una
simplificación del algoritmo de Dekker para dos procesos.
Posteriormente este algoritmo fue generalizado para n procesos.
• Dicho algoritmo también es conocido como solución de Peterson, es
un algoritmo de programación concurrente para exclusión mutua,
que permite dos o mas procesos o hilos de ejecución compartir un
recurso sin conflictos, utilizando solo memoria compartida para la
comunicación.
Algoritmo de Peterson
Inicialización
bandera[0] = 0
bandera[1] = 0
turno = 0

• bandera[0] = 1 • Bandera[1]=1
• turno = 1 • turno = 0
• while( bandera[1] && turno == 1 • while( bandera[0] && turno == 0
); );
• SC() • SC()
• bandera[0] = 0 • bandera[1] = 0