Programación Concurrente. Tema 1 - Departamento de Lenguajes y

Tema 1. Introducción a la
Programación Concurrente
Programación Concurrente
Depto. de Lenguajes y Sistemas Informáticos
Universidad de Granada
Contenidos
1. Concepto de concurrencia y programa
concurrente.
2. Sincronización y exclusión mutua. Propiedades
de corrección.
3. Consideraciones sobre el hardware. Sistemas
multicore y clusters.
4. Introducción a los mecanismos de sincronización
y comunicación de bajo nivel.
5. Algoritmos de Exclusión Mutua en sistemas con
memoria compartida.
1. Concurrencia y programa
concurrente
Programa concurrente y Concurrencia
• Programa secuencial: Declaraciones de datos + instrucciones
(ejecución secuencial).
• Programa concurrente: Conj. de programas secuenciales ordinarios
ejecutados como procesos paralelos (paralelismo abstracto).
• Proceso: Ejecución de un programa secuencial.
• Concurrencia: describe el potencial para ejecución paralela.
– Solapamiento real o virtual de varias actividades en el tiempo
1. Concurrencia y programa
concurrente
Programación concurrente
Programación Concurrente
• PC: Notaciones y técnicas de programación usadas para expresar
paralelismo potencial y solucionar los problemas de sincronización y
comunicación.
• Abstracción: La PC es independiente de la implementación del
paralelismo.
Justificación de la PC
• Eficiencia: Obvia.
• Calidad: Más natural especificar algunos sistemas en términos de varios
procesos secuenciales ejecutándose concurrentemente.
– Ej.: Transacciones de reservas de vuelos.
• Cada terminal se controla con un programa secuencial
1. Concurrencia y programa
concurrente
Modelo abstracto. Entrelazamiento
• Modelado del paralelismo
•
– P: Programa concurrente consistente
en 2 procs.: P1 y P2.
– P ejecuta cualquiera de las secuencias
de ejecución obtenidas entrelazando
secuencias de P1 y P2.
P: Posibles comp.
P1
P2
…
…
I11
I12
I13
I14
I21
I22
I23
I24
I11
I21
I12
I22
I23
I13
I24
…
I11
I12
I13
I21
I22
I23
I14
…
I21
I11
I22
I12
I13
I14
I23
…
Independencia del entorno de
ejecución: El entrelazamiento preserva la
corrección.
– No importa cómo sea la ejecución, el
resultado debe ser consistente. En caso
contrario, no sería posible razonar
sobre la corrección.
P: I1||I2
I1≡ M=1
I2≡ M=2
Resultado
consistente
M=1 ó M=2
– Análisis de programas difícil.
– Nº ejecuciones posibles ≈ ∞
– Se requieren métodos formales
1. Concurrencia y programa
concurrente
Modelo abstracto. Hipótesis del progreso finito
• No suposición acerca velocidades absolutas/relativas de ejecución de los
procesos salvo que el tiempo de ejecución >0
– Entender programa concurrente en base a:
• sus procesos secuenciales + las interacciones entre ellos.
– Ej.: Disco es más lento que una CPU pero el programa no debería asumir eso
– Razones para diseñar un sistema indep. de suposiciones temporales:
• Difícil detectar y corregir fallos
• Naturaleza dinámica de la configuración
• Hipótesis del Progreso Finito
– Globalmente: Existe al menos 1 proc. preparado, es decir, eventualmente se
permitirá la ejecución de algún proceso.
– Localmente: Se le permite la ejecución de una sección de código a un proceso
por lo que completará su ejecución en un tiempo finito.
2. Sincronización y Exclusión
mutua. Corrección
Notaciones para expresar ejec. concurrente



Propuestas Iniciales: No separan definición proc. de la sincronización.
Posteriores Propuestas: Separan conceptos e imponen estructura.
Declaración de procesos: Rutinas específicas de programación concurrente 
Estructura del programa concurrente más clara.
Sistemas Estáticos : Nº fijo de procesos/hebras.
−
−
Activación: sólo en la iniciación del programa
Ej.: Message Passing Interface (MPI-1).
Sistemas Dinámicos: Nº variable de procesos/hebras
−
−
Activación: En cualquier momento de la ejecución
Ej.: OpenMP, Java Threads, Parallel Virtual Machine (PVM), MPI-2.
2. Sincronización y Exclusión
mutua. Corrección
Creación de procesos
Creación de procesos no estructurada: FORK-JOIN
program P1;
...............
fork P2;
...............
join P2;
...............
program P2;
...............
...............
end;
Fork: Especifica que la rutina invocada puede
comenzar su ejecución.
Join: Sincroniza la terminación rutina invocada
Ventajas: práctica y potente, Creación dinámica
(UNIX)
Inconvenientes: no estructuración. Bucles, condicionales, etc.
Creación de procesos estructurada: COBEGIN-COEND
cobegin S1 | S2 | ... | Sn coend; ⇒ Ejecución concurrente de S1, S2,…, Sn
•
•
•
Termina cuando terminen todos los Si
Hace explícito qué rutinas van a ejecutarse concurrentemente
Estructura: 1 única entrada y 1 única salida  Más fácil de entender
2. Sincronización y Exclusión
mutua. Corrección
Exclusión mutua
Asegura que una secuencia de sentencias (sección crítica) se trata
como una operación indivisible.
A1: Actividad del proceso P1
A1 y A2 se excluyen mutuamente
A2: Actividad del proceso P2
− La ejecución de A1 no puede solaparse con la ejecución de A2
− Si ambas intentan ejec. simultáneamente  Sólo una avanza, la otra se bloquea.
Ej.: Asignación de recursos en S.O.
Descripción Abstracta del problema
resto
pre-protocolo
sección crítica (corta)
post-protocolo
• Aseguran la E.M.
• Baja sobrecarga
2. Sincronización y Exclusión
mutua. Corrección
Sincronización
Sincronización
Un proceso no debe continuar su ejecución hasta que se cumpla otra
condición más general → Sincronizar el proceso con la condición.

Generalización de la E.M.
−

Se pueden usar técnicas similares para la solución
Grafo de sincronización: muestra las restricciones de precedencia que determinan
cuándo una actividad puede empezar.
−
−
Cada flecha en el grafo es un paso de sincronización.
Tiene que ser acíclico.
A
B
C
D
E
F
G
H
I
2. Sincronización y Exclusión
mutua. Corrección
Propiedades de corrección. Tipos
Corrección en Sistemas concurrentes: Las propiedades de corrección se definen en
términos de propiedades de sus secuencias de ejecución.
−
•
Propiedades de seguridad (safety): deben cumplirse “siempre”.
−

“Para todas las posibles ejecuciones de P …………”
Requeridas en especificaciones estáticas: “Nunca pasará nada malo”

E.M. : 2 procesos nunca entrelazan ciertas subsecuencias de operaciones.

Ausencia Interbloqueo (Deadlock): Un programa que no termina siempre realizará trabajo útil.
Propiedades de Vivacidad (liveness): deben cumplirse “eventualmente”.
−
Son propiedades dinámicas difíciles de probar: “Realmente sucede algo”

−
Ausencia de inanición (starvation): los procesos no son indefinidamente pospuestos.
Tipo particular de propiedad de vivacidad : Equidad (fairness): Un proceso que desee
progresar debe hacerlo con justicia relativa con respecto a los demás.
−
Más ligado a la implementación y a veces incumplida: distintos grados
3. Consideraciones sobre el
hardware
Arquitecturas para programación concurrente
•
Arquitecturas básicas para programación concurrente
Red de interconexión
CPU
Mem
Monoprocesador
CPU alterna instrucciones
de distintos procesos
Paralelismo Virtual

CPU
CPU
CPU
CPU
Memoria
Multiprocesador de
memoria compartida
Datos comunes
CPU
CPU
CPU
Mem
Mem
Mem
Sistema Distribuido
• No memoria común
• Red de interconexión
Paralelismo Real (o híbrido)
Mecanismos de implementación de la concurrencia
−
−
Dependen fuertemente de la arquitectura
Consideran una máquina virtual que representa un sistema multiprocesador o un sistema
distribuido,

−
proporciona una base homogénea para el sistema de procesos concurrentes.
El tipo de paralelismo afecta a la eficiencia pero no a la corrección
3. Consideraciones sobre el
hardware
Procesadores multinúcleo (multicore)
●
●
Arquitectura multicore: cada procesador contiene dos
o más núcleos que pueden ejecutar instrucciones de
forma simultánea.
Multiprocesador en un solo chip: el sistema operativo
percibe cada núcleo como procesador independiente.
–
●
●
●
Teóricamente, paralelismo perfecto.
Ventajas:
–
Menor consumo y mejor disipación calor.
–
Mejor aprovechamiento multithreading.
Ejemplos: AMD Athlon dual core (2), AMD Opteron
Barcelona (4), Intel core duo (2), Intel quad core (4),
SUN UltraSparc T1 Niagara(8), IBM Cell (8+1), ...
Futuro inmediato: Ordenadores basados en esta
tecnología y adaptación software al nuevo hardware.
Procesadores
visibles al Sist.
Operativo
Thread 1
P
Thread 2
P
Productividad
+
3. Consideraciones sobre el
hardware
Clusters de ordenadores
Conexión de ordenadores mediante red de
interconexión:
●
Cada ordenador con su memoria local y
espacio de direcciones propio
●
Red de interconexión: envío/recepción de
mensajes.
●
El conjunto se ve como un único
ordenador
●
–
●
Ventajas sobre multiprocesador específico
● Disponibilidad a bajo costo de potentes
estaciones de trabajo y PCs
● Fácil incorporación de últimos avances en
CPUs y redes
● Es posible usar software ya existente o
modificarlo
Inconveniente: Latencia significativa
Red de Interconexión
4. Mecanismos de bajo nivel
Sistemas con memoria compartida
Mecanismos de bajo nivel en sistemas con memoria común

E.M. y sincronización: Los mecanismos dependen de la naturaleza síncrona
del hardware.


Métodos de sincronización por el procesador
−
Hacer los procesadores ininterrumpibles.
−
Sólo para procesadores individuales.
Métodos de sincronización por la memoria (almacenamiento)
−
La memoria puede servir sólo una petición de acceso al mismo tiempo.
−
mayor rango de aplicabilidad.
4. Mecanismos de bajo nivel
Inhibición de interrupciones
Interrupciones inhibidas: Se posponen las nuevas interrupciones.

Forzar E.M.: hacer ininterrumpible al proceso que ejecuta sección crítica.

Ventaja: muy rápido, 1 instrucción máquina
Inconvenientes

Impide tratar eventos de tiempo real.

Evitar S.C. largas.

Excluye actividades no conflictivas

No esperas en una S.C.

Falla en multiprocesadores

Seguridad: S.C. anidadas
−
procedure BeginRegion;
{ DisableInterrupts }
procedure EndRegion;
{ EnableInterrupts }
PROTOCOLOS
PARA E.M.
E.M. relajada
A
BeginRegion
…….
…….
…….
…….
EndRegion
B
…….
BeginRegion
…….
EndRegion
…….
4. Mecanismos de bajo nivel
Cerrojos. Locks
Instrucción atómica de sincronización por mem.: TestAndSet
- Lee una variable
- Le asigna un nuevo valor

Cerrojos: Mecanismo de E.M.
−
Cada región se asocia a un grupo de variables compartidas

−
atomic function TestAndSet (Lock : Bool) : Bool;
{TestAndSet := Lock;
Lock := true; /* No importa el valor antiguo */}
Asociar un cerrojo con cada grupo.
Se necesitan varios cerrojos:

Adquirir en orden jerárquico.
P1
P2
Bloqueo
BeginRegion (L1)
BeginRegion (L2)
BeginRegion (L2)
BeginRegion (L1)
S.C.
S.C.
….
….
type Lock = Boolean;
procedure BeginRegion ( var L : Lock);
{ while TestAndSet(L) do null; }
procedure EndRegion ( var L : Lock);
{ L := false }
4. Mecanismos de bajo nivel
Cerrojos. Propiedades
Propiedades de los Cerrojos
Ventajas



Cualquier nº de procesos y procesadores con almacenamiento compartido.
Simple y fácil de verificar.
Liberal.
Inconvenientes

Permite inanición: Elección de proceso arbitraria.

Usa espera ocupada: afecta a la eficiencia.
4. Mecanismos de bajo nivel
Semáforos(Dijkstra, 1965)
Mecanismo exitoso
Var s: semaphore; // Variable con valores enteros positivos
Inicialización: Asignar un entero positivo
P(s), wait::
If (s>0) s-- else suspender proceso llamador
V(s), signal:: If (Hay algún proceso P suspendido en s) despertar P else s++


Tipos de semáforos
– Binarios: Valores 0 ó 1 para implementar Exclusión Mutua
– Generales: enteros>=0 para Sincronización de condición
E.M. con semáforos
Program EjemploMutex
Proc. P1 {
Var s: semaphore
while (true) {P(s); S.C.; V(s); …} }
Proc. P1 {…}
Proc. P2 {…}
Main {s=1;cobegin P1;P2; coend;}
Proc. P2 {
while (true) {P(s); S.C.; V(s); …} }
4. Mecanismos de bajo nivel
Mecanismos en sistemas distribuidos
• No existe memoria común: No sincronización por almacenamiento.

No monoprocesador : No sincronización por procesador.

Paso de mensajes: Mecanismo para:

−
Transmitir datos (comunicación): Los procesos envían/reciben mensajes en lugar
de escribir/leer en variables compartidas
−
Sincronizar procesos: la recepción de un mensaje es posterior al envío.
Ventajas:
−
Portabilidad: Implementable en cualquier arquitectura ( multiproc, sist. distribuido).
−
No son necesarios mecanismos de E.M.
4. Mecanismos de bajo nivel
Mecanismos en sistemas distribuidos
Mecanismos de bajo nivel en sistemas distribuidos
• Primitivas básicas
−
−
Envío:
send (<lista-expresiones> , <identificador_destino>)
Recepción: receive (<lista-variables>, <identificador_fuente>)
• Esquema General
mensaje
Emisor
CANAL
Receptor
4. Mecanismos de bajo nivel
Esquemas de identificación
Esquemas de Identificación en la comunicación

¿Cómo identifica el emisor al receptor del mensaje y viceversa?

Dos posibilidades:
– Denominación directa:

Emisor identifica explícitamente al receptor y viceversa

Se utilizan los identificadores de los procesos
– Denominación indirecta:

Los mensajes se depositan en almacenes intermedios que son globales a los
procesos (buzones).
4. Mecanismos de bajo nivel
Esquemas de identificación.
Denominación Directa
Denominación Directa

Ventajas:
−
No hay retardo para
establecer la identificación


Process P1
Process P2
{dato:integer;
{dato:integer;
Produce (dato);
receive (dato , P1);
send (dato , P2);}
Consume (dato);}
Inconvenientes
−
Cambios en la identificación requiere Recompilar
−
Sólo enlaces 1-1
P1
P2
Existen esquemas asimétricos
−
emisor identifica al receptor, pero el receptor no indica emisor

Receive (dato, Id): En Id se devuelve el emisor del mensaje recibido.
4. Mecanismos de bajo nivel
Esquemas de identificación.
Denominación Indirecta
CHANNEL OF INT Buzón
Denominación Indirecta

Flexibilidad: permite comunic. varios procs.

Declaración estática/dinámica:
−
Estática: fija fuente/destino en tiempo de compilación.

−
•
Process P1
Process P2
{dato:integer;
{dato:integer;
Produce (dato);
receive (dato , Buzón);
send (dato , Buzón);}
Consume (dato);}
No apropiada en entornos cambiantes.
Buzón
P1
P2
Dinámica: + potente pero – eficiente
Tipos
Canales (1 a 1)
P1
A
P2
P1
B
P2
• Tipo fijo
Buzones generales (n a n)
P1
P2
B
Puertos (n a 1)
P3
P1
P4
P2
• Destino: send de cualquier proc.
• Fuente: receive de cualquier proc.
• Implementación complicada.
•Enviar mensaje y transmitir todos los lugares.
•Recibir mensaje y notificar recepción a todos.
B
P3
• Destino: send de cualquier proc.
• Fuente: receive de un proc.
• Implementación más sencilla.
4. Mecanismos de bajo nivel
Sincronización en sistemas distribuidos
Sincronización

Coincidencia temporal emisor/receptor: com. síncrona/asíncrona

Paso de mensajes Síncrono: emisor se bloquea hasta receptor listo y viceversa.
−
Intercambio de mensaje: punto de sincronización emisor/receptor.
El emisor podrá hacer aserciones acerca del estado del receptor.
−
Análogo: com. telefónica y chat.  cita entre ambos.
−
Sentencias bloqueantes: pueden retardar al invocador.
−

Más fáciles de implementar pero menos flexibles.
send (A,m)
send (A,m)
Proceso A
Proceso A
Cita
Cita
Proceso B
espera
receive(A,m)
espera
Proceso B
receive(A,m)
4. Mecanismos de bajo nivel
Sincronización en sistemas distribuidos (2)
– Paso de mensajes Asíncrono: Llamadas no bloqueantes

Existe Buffer para almacenar los mensajes

Send nunca retrasa.

Análogo: Correo electrónico y foro.
send (A,m)
Proceso A
Buffer
Proceso B
receive(A,m)
4. Mecanismos de bajo nivel
Sincronización en sistemas distribuidos(3)
•
Send con buffer lleno

Receive con buffer vacío
• Retrasar send hasta que haya espacio
• Devolver código al invocador. (Chequeo)
• Retrasar receive: es lo más frecuente
• Devolver código.

Simulación esquema síncrono con operaciones asíncronas
Process P1
Process P2
{dato:integer;
{dato:integer;
send (P2 , dato); receive (P2,confimación)}


receive (P1 , dato); send (P1,confimación)}
Combinaciones:
−
Envío-recepción bloqueantes/no bloqueantes,
−
Envío NO bloq.-recepción bloq.: muy útil que emisor pueda continuar después del envío.
Recepción no bloqueante con tiempo de espera: Útil para evitar inanición
5. Algoritmos de Exclusión mutua
Introducción


Existen soluciones hardware
1965 : Aparecen soluciones software
−
−
Sucesión de soluciones + mejoras (eficiencia, calidad)
Valor didáctico: Propiedades de los algoritmos concurrentes
Tipos de algoritmos
−
Centralizados (para arquitecturas con memoria compartida)
−
Variables de estado + variable/s crítica/s (compartida/s) + Espera ocupada

Nos centraremos en este tipo
Distribuidos (para arquitecturas distribuidas)

Soluciones para : Distribuir soluciones centralizadas

Variables de estado + paso de mensajes (no hay variables compartidas)


Equidad: propiedad de la implementación → Evita inanición
5. Algoritmos de Exclusión mutua
Solución con variable compartida y espera
ocupada
Espera ocupada: Enfoque para conseguir exclusión mutua
−
−
−
Procesos esperan a la entrada de región hasta continuación segura.
Utilizan recursos computacionales sin ningún progreso (p.e. ejecutando
continuamente un bucle vacío).
No cambian si no hay otro trabajo a realizar durante espera.
VAR MutEx : Boolean = false;
proc BeginRegion;
{while MutEx do nothing;
MutEx = true;}
proc EndRegion;
{MutEx = false;}
• Sincronización por almacenamiento
• Falla propiedad de seguridad
5. Algoritmos de Exclusión mutua
Refinamiento sucesivo de Dijkstra
Condiciones que ha de verificar un solución correcta
–
–
Dijkstra (1965) : Condiciones + pasos didácticos (prop. patológicas)
Derivación por refinamiento sucesivo del Algoritmo de Dekker
iii. No suposición acerca nº instrucciones o nº de procs. soportados
–
–
Excepto que instrucciones básicas tienen ejecución atómica.
Ejecución simultánea 2 insts. → Ejecución secuencial orden conocido
•
No suposición acerca velocidad entre competidores:
•
Un proc. en S. no C. no puede evitar que otro entre en su S.C.
•
Alcanzabilidad (No interbloqueo):
–
•
excepto que NO es cero.
Los procs. requiriendo acceso a S. C. no pueden ser indefinidamente retrasados.
5. Algoritmos de Exclusión mutua
Refinamiento sucesivo de Dijkstra. Etapa 1
1ª Etapa
• Garantiza E.M.
• No garantiza iii).
–
Alternancia
•
•
Procs. sólo pueden
entrar en sucesión
Procesos con tasas de
utilización dispares.
Variables Compartidas
VAR turn:{0,1} = 0 ó 1
Protocolo para Pi:
While (turn!=i) do nothing;
<sección crítica>
turn=j;
Solución
•
Propuesta de Solución
–
No garantiza E.M.
Protocolo para Pi:
turn=i;
While (turn!=i) do nothing;
<sección crítica>
turn=j;
5. Algoritmos de Exclusión mutua
Refinamiento sucesivo de Dijkstra. Etapa 2
2ª Etapa
•
Problema 1ª etapa
–
–
Almacena el nº del proc.
que debe entrar.
Debe almacenar info. de
estado para decidir
•
–
flag[i]=true → Pi en S.C.
No garantiza E.M.
•
•
Si Pi y Pj avanzan simultáneamente
No satisface ii): depende de la velocidad
Variables Compartidas
VAR flag:boolean [0..1] = false;
Protocolo para Pi:
While (flag[j]) do nothing;
flag[i]=true;
<sección crítica>
flag[i]=false;
5. Algoritmos de Exclusión mutua
Refinamiento sucesivo de Dijkstra. Etapa 3
3ª Etapa
•
•
Problema 2ª etapa
–
Pi puede comprobar flag[j]
antes de que Pj lo modifique
Solución:
–
Intercambio 2 primeras líneas
•
Garantiza E.M.
•
No garantiza iv)
–
Variables Compartidas
VAR flag:boolean [0..1] = false;
Protocolo para Pi:
flag[i]=true;
While (flag[j]) do nothing;
<sección crítica>
flag[i]=false;
Si Pi y Pj avanzan simultáneamente → Interbloqueo
5. Algoritmos de Exclusión mutua
Refinamiento sucesivo de Dijkstra. Etapa 3
4ª Etapa
•
Problema 3ª etapa
–
Cuando Pi fija su estado,
no conoce estado de Pj.
•
Solución: Pi pone flag[i] a true para
indicar intención de entrar.
•
No garantiza iv) ni ii)
•
Conclusión:
–
–
–
Si Pi y Pj avanzan
simultáneamente : Interbloqueo
No basta con el estado de los procs.
Hace falta turno.
Variables Compartidas
VAR flag:boolean [0..1] = false;
Protocolo para Pi:
flag[i]=true;
While (flag[j])
{flag[i]=false;
while flag[j] do nothing;
flag[i]=true;}
<sección crítica>
flag[i]=false;
5. Algoritmos de Exclusión mutua
Algoritmo de Dekker
Algoritmo de Dekker
Variables Compartidas
VAR flag: boolean [0..1] = false;
turn: {0,1} = 0 ó 1 /* Establece cortesía*/
Protocolo para Pi:
flag[i]=true;
While (flag[j]) { if (turn==j) {flag[i]=false;
while (turn==j) do nothing;
flag[i]=true;}
}
<sección crítica>
turn=j;
flag[i]=false;
5. Algoritmos de Exclusión mutua
Algoritmo de Dekker. Excl. mutua
Prueba de corrección. E.M.
•
•
•
No utiliza instrucciones especiales
–
Respeta ii)
Demostrar manteniendo ii)
–
–
¿Garantiza E.M.?
¿Alcanzabilidad?
E.M.
–
–
–
–
–
Protocolo para Pi:
flag[i]=true;
While (flag[j]) {
if (turn==j)
{ flag[i]=false;
while (turn==j)
do nothing;
flag[i]=true; }
}
<sección crítica>
turn=j;
flag[i]=false;
Pi en S.C. → flag[j]=false.
Sólo Pi modifica flag[i].
Pi comprueba flag[j] sólo cuando flag[i]=true.
Pi en S.C. → (flag[i]=true → flag[j]=false).
(Pi en S.C) y (Pj en S.C.) → Falso
: ABSURDO
5. Algoritmos de Exclusión mutua
Algoritmo de Dekker. Alcanzabilidad
Prueba de Alcanzabilidad
•
Caso A: Único Pi desea entrar → Encuentra flag[j]=false y entra
•
Caso B: P0 y P1 desean entrar (turn=0)
•
B.1.: P1 encuentra flag[0]=false → Entra
•
B.2.: P1 encuentra flag[0]=true → turn=0
–
–
–
–
Pasa a bucle interno y pone flag[1]=false
P0 encuentra flag[1]=true → turn=0
Sigue en bucle externo hasta flag[1]=false
P0 entra antes que P1
Protocolo para Pi:
flag[i]=true;
While (flag[j]) {
if (turn==j)
{ flag[i]=false;
while (turn==j)
do nothing;
flag[i]=true; }
}
<sección crítica>
turn=j;
flag[i]=false;
5. Algoritmos de Exclusión mutua
Algoritmo de Dekker. No inanición
Prueba de Inanición
•
•
•
•
•
•
Existe escenario de inanición
Depende hardware
–
Prioridad escritura sobre lectura memoria
P1 rápido y repetitivo||P0 en bucle interno
P1 sale de S.C. → pone turn=0
P0 encuentra turn≠1 → Sale bucle interno
P1 pone flag[1]=false
–
–
–
Vuelve flag[1]=true
Encuentra flag[0]=false
Entra en S.C. → Impide a P0 poner flag[0]=true
•
Acceso a flag[0] en E.M.
Protocolo para Pi:
flag[i]=true;
While (flag[j]) {
if (turn==j)
{ flag[i]=false;
while (turn==j)
do nothing;
flag[i]=true; }
}
<sección crítica>
turn=j;
flag[i]=false;
5. Algoritmos de Exclusión mutua
Generalización a N procesos. Alg. De Dijkstra
Algoritmo de Dijkstra para N procesos (1965)
Variables Compartidas
VAR flag : array[0..n-1] of (passive, requesting, in_cs); /* inic. a passive */
turn : 0..n-1;
Protocolo para Pi ( i=0..n-1)
var j:0..n-1; /*Variable local*/
repeat { flag[i] = requesting;
while (turn != i) if flag[turn] = passive then turn = i;
flag[i] = in_cs;
j = 0; while (j < n) and (j = i or flag[j] != in_cs) j++}
until j  = n;
/* Ahora se cumple: (flag[j] ≠ in_cs, para todo j≠i) y flag[i]=in_cs */ testd(i)
<sección crítica>
flag[i] = passive;
5. Algoritmos de Exclusión mutua
Algoritmo de Dijkstra. Excl. mutua
Prueba de corrección. E.M.
•
Pi sólo puede entrar si testd(i)
–
(flag[j]≠in_cs, para todo j≠i) y
(flag[i]=in_cs)
•
Sólo Pi puede poner flag[i]=in_cs
•
Sólo se comprueban los flag[...]
después de asignar
Protocolo para Pi ( i=0..n-1)
var j:0..n-1; /*Variable local*/
repeat {
flag[i] = requesting;
while (turn != i) if flag[turn] =
passive
then turn = i;
flag[i] = in_cs;
until testd(i);
<sección crítica>
flag[i] = passive;
•
Sólo Pi puede entrar a su S.C.
5. Algoritmos de Exclusión mutua
Algoritmo de Dijkstra. Alcanzabilidad
•
•
•
•
Prueba de corrección. Alcanzabilidad
Pi intenta entrar → flag[i]≠passive
flag[i] == in_cs no implica turn=i
Varios Pi entran simult. bucle interno
–
–
Ponen turn=i (el último turn=k)
Ponen flag[i]=in_cs
Los que lleguen después
–
–
–
flag[turn]≠passive
No se asignan turn
Se quedan en primer bucle
Protocolo para Pi ( i=0..n-1)
var j:0..n-1; /*Variable local*/
repeat {
flag[i] = requesting;
while (turn != i) if flag[turn] =
passive
then turn = i;
flag[i] = in_cs;
until testd(i);
<sección crítica>
flag[i] = passive;
•
•
Todos Pi abandonan 2º bucle interno: No cumplen testd(i)
–
–
Pi (i≠k) ponen flag[i]=requesting y vuelven al primer bucle interno
Pk vuelve bucle externo y al 2º bucle interno (turn=k)
Pk único con flag[k]=in_cs → Pk entra en S.C.
5. Algoritmos de Exclusión mutua
Algoritmo de Dijkstra. Inanición?
Prueba de corrección. Inanición
Varios Pi piden entrar S.C. constantemente
–
–
Puede que siempre sea el mismo el último en hacer turn=i
No evita el peligro de inanición
Condición Adicional Solución
(v) Un proceso que intente entrar en su sección crítica será capaz de hacerlo en
un tiempo finito.
Otra Formulación
–
–
Debe  un límite en el nº de veces que otros procesos pueden entrar en S.C. entre
el momento en que un proc. hace su petición para entrar en su propia S.C. y el
momento en que realmente entra.
Tiempo máximo de espera =f(número de veces).
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para 2 procesos
Algoritmo de Peterson
Versión para 2 procesos
Variables Compartidas
flag : array[0..1] of boolean; /* inicializado a false */
turn : 0..1; /* resuelve conflictos de simultaneidad */
Protocolo para Pi ( i=0,1; j=(i+1) mod 2 )
flag[i] = true;
turn = i;
while (flag[j] and turn==i) do;
<sección crítica>
flag[i] = false;
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para 2 procesos (2)
Prueba de corrección. E.M.
Supongamos P0 y P1 en S.C.
flag[0]=flag[1]=true
Condiciones no pueden ser falsas al mismo
tiempo
Uno de ellos, Pi, entró primero
Encontró turn=j
Pj no puede entrar, turn=j lo impide
Variables Compartidas
flag : array [0..1] of boolean;
turn : 0..1;
Protocolo para Pi
flag[i] = true;
turn = i;
while (flag[j] and turn==i) do;
<sección crítica>
flag[i] = false;
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para 2 procesos (3)
Prueba de corrección. Alcanzabilidad + Equidad
Suponer P0 esperando continuamente
•
P1 sale de S.C.
•
•
P1 esperando entrar
•
•
flag[1]=false → P0 entra a S.C.
IMPOSIBLE: Pturn debe entrar
P1 monopoliza acceso a S.C.
•
P1 pone turn=1 al intentar entrar de
nuevo → P0 entra a S.C.
Variables Compartidas
flag : array [0..1] of boolean;
turn : 0..1;
Protocolo para Pi
flag[i] = true;
turn = i;
while (flag[j] and turn==i) do;
<sección crítica>
flag[i] = false;
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos
Algoritmo de Peterson para N procesos

Generalización: Iterar solución para 2 procs., eliminando 1 proc. cada vez.
Variables Compartidas
flag : array[0..N-1] of -1..n-2; /* inicializada a –1 */
turn : array[0..N-2] of 0..n-1; /* inicializada a 0 */
Protocolo para Pi ( i=0,...,N-1)
j:0..N-2; /* variable local indicando la etapa */
for j = 0 to N-2
{flag[i] = j;
turn[j] = i;
while [(∃ k ≠ i : flag[k] ≥ j) ∧ (turn[j] == i)] do; }
<sección crítica>
flag[i] = -1;
-1 ⇒ Pi no ha entrado en su
protocolo de entrada.
j>=0 ⇒ Pi está en la j-ésima
etapa del protocolo.
Pi1 precede a Pi2 ⇔ flag[i1]>flag[i2].
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos (2)
Lema 1. Un proc. que precede a todos los demás puede avanzar al menos 1
etapa.
Demostración:
Supongamos Pi llega a bucle interno y se verifica:
(No ∃ k ≠ i : flag[k] ≥ j)
(1)
• (1) se mantiene ⇒ Pi puede avanzar a etapa j+1.
• (1) deja de ser cierta ⇒ algún Pr hace flag[r]←j.
En cuanto, turn[j]=r ⇒ Pi podría continuar.
Pi ( i=0,...,N-1)
for j = 0 to N-2
{flag[i] = j;
turn[j] = i;
while [(∃ k ≠ i : flag[k] ≥ j)
∧ (turn[j] == i)]
do;}
<sección crítica>
flag[i] = -1;
Si más de un proceso adicional se une a etapa j, Pi podría ser
adelantado.
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos (3)
Lema 2. Cuando un proceso avanza de la etapa j a la etapa j+1, se mantiene
exactamente una de las siguientes condiciones:
(a) el proceso precede a todos los demás procesos, o
(b) el proceso no está solo en la etapa j.
Nota: "Pi avanza una etapa" se refiere al instante de almacenar nuevo valor en
flag[i].
Demostración:
Si Pi está a punto de avanzar flag[i]. Entonces ocurre una de estas cosas:

Se cumple (1) ⇒ (a), o

turn[j] ≠ i ⇒ Pi no último en etapa j ⇒ ∃ Pr tal que turn[j]=r ⇒ (b).
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos (4)
Lema 3. Si hay (al menos) dos procesos en la etapa j, habrá (al menos)
un proceso en cada etapa k, 0 ≤ k ≤ j-1.
Demostración: Inducción sobre j.



(j=0): Condición nula.
(j=1): Si hay al menos 2 procs. en etapa 1, el último que entrara en la
etapa tuvo que dejar, por Lema 2, a otro en etapa 0.
(j → j+1)?: Supongamos  al menos 2 procesos en etapa j+1, cuando el
último se unió, por Lema 2, había al menos 2 procs. en etapa j. Por la
hipótesis de inducción, las etapas precedentes estaban ocupadas y, por
Lema 2, estas etapas no pudieron haber sido desocupadas desde
entonces.
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos (4)
Lema 4. El número máximo de procs. en etapa j es n-j, 0<=j<=n-2.
Demostración:


Supongamos hay al menos dos procesos en etapa j. Por Lema 3, las etapas
0 hasta j-1 contienen al menos un proceso por lo que podría haber n-j
como máximo en la etapa j.
Si alguna de estas etapas estuviera vacía, el Lema 3 implica que como
máximo hay un proceso en la etapa j.
5. Algoritmos de Exclusión mutua
Algoritmo de Peterson para N procesos.
Corrección
Prueba de corrección. Algoritmo de Peterson
Exclusión Mútua
La etapa n-2 contiene como mucho 2 procesos (Lema 4). Si hay sólo uno allí, y
otro está en su S.C., Lema 2 dice que no puede avanzar para entrar en su S.C..
Cuando la etapa n-2 contiene 2 procs., no hay ninguno en la etapa n-1 (S.C.), y
uno de los 2 puede entrar. Para el proc. que queda no se cuple condición del
bucle interno.
Alcanzabilidad
Siempre existirá un proc. que precede a todos los demás → puede avanzar por
Lema 1 o está acompañado en la etapa ocupada más alta → si no fue el último
en entrar, avanzará.
Equidad
Si un proceso intenta continuamente avanzar, en el peor de los casos, el número
máximo de turnos que tiene que esperar sería: d(N)=N(N-1)/2.