Upload
ynez-veras
View
14
Download
5
Embed Size (px)
Citation preview
Tema 06: Programación Concurrente
Sincronización con Espera Activa
MAESTRÍA EN INGENIERIA DE SISTEMAS E INFORMÁTICA ADMINISTRACIÓN DE TECNOLOGÍAS DE INFORMACIÓN
E S P GE S P G
[email protected], [email protected], [email protected]
Prof: Alberto E. Cohaila Barrios
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva Conclusiones
2
Introducción
3
Vamos a estudiar la programación concurrente con el Modelo Concurrencia de Memoria Compartida
El Modelo de Concurrencia de Paso de Mensajes se estudia en Redes y Sistemas Distribuidos
Introducción
Modelo de Memoria Compartida Los procesos pueden acceder a una
memoria común Existen variables compartidas que
varios procesos pueden leer y escribir
4
¿Qué ocurre si dos procesos leen o escriben de forma simultánea en la misma variable?
Introducción
Modelo de Memoria Compartida La abstracción de la programación
concurrente nos dice que hay que estudiar las intercalaciones de las instrucciones atómicas de cada proceso
La lectura y la escritura de variables de tipo simple (boolean, integer, char…) son instrucciones atómicas en PascalFC
Introducción
Lectura simultáneas Ambos procesos leen el valor de la variable
Escrituras simultáneas El resultado de la escritura simultánea sobre una variable
compartida de tipo simple será el valor escrito por uno u otro proceso
Nunca una mezcla de las dos escrituras Lectura y Escritura simultáneas
Si un proceso lee sobre una variable compartida de tipo simple y simultáneamente otro escribe sobre ella, el resultado de la lectura será o bien el valor de la variable antes de la escritura o bien el valor de la variable después de la escritura
Nunca un valor intermedio
6
Introducción
7
Relaciones entre procesos
Actividades entre procesos
Comunicación
SincronizaciónCondicional
ExclusiónMutua
Se lleva a cabo
mediante
A veces necesita
Hay diferentes
tipos
Competencia
Cooperación
Sincronización
Introducción
Actividades entre procesos con el Modelo de Memoria Compartida
Comunicación Se utilizan las variables compartidas para
compartir información Un proceso escribe un valor en la variable y
otro proceso lee ese valor
8
Introducción
Actividades entre procesos con el Modelo de Memoria Compartida Sincronización
Si sólo se usan variables compartidas para la sincronización se tiene Espera Activa
Se pueden usar también herramientas específicas de sincronización de procesos del lenguaje de programación, por ejemplo los Semáforos
Tipos de sincronización Sincronización condicional Exclusión mutua
9
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva Conclusiones
10
Sincronización Condicional
Se produce cuando un proceso debe esperar a que se cumpla una cierta condición para proseguir su ejecución
Esta condición sólo puede ser activada por otro proceso
11
PA1 PA2
PB1 PB2
Diagrama de Precedencia
Proceso A
Proceso B
Sincronización Condicional
Si los procesos muestran por pantalla* el nombre de la acción que han realizado, el resultado de ejecutar el programa concurrente del diagrama podría ser cualquiera de los siguientes:
PA1 PA2
PB1 PB2
Proceso A
Proceso B
PA1 PA2 PB1 PB2
PA1 PB1 PA2 PB2
PB1 PA1 PA2 PB2
Algunas Salidas Posibles:
Salidas No Posibles:
PB1 PB2 PA1 PA2 * La escritura en pantalla con write es una instrucción atómica en PascalFC
PB1 PA1 PB2 PA2
SincronizaciónCondicional
BLP (06-07) 13
program sinccond;
process tPA(var continuar:boolean); begin write('PA1 '); continuar := true; write('PA2 '); end; process tPB(var continuar:boolean); begin write('PB1 '); while not continuar do; write('PB2 '); end;
var continuar: boolean; procA:tPA; procB:tPB;begin continuar := false; cobegin procA(continuar); procB(continuar); coend;end.
Se declara una variable continuar
procA la pondrá a true cuando haya ejecutado PA1 y continuará ejecutando PA2
procB ejecutará PB1 y comprobará constantemente en un bucle el valor de continuarSaldrá del bucle cuando valga true y continuará ejecutando PB2
Sincronización Condicional
Intercalación de instrucciones que obtiene la salida
PA1 PB1 PA2 PB2
procA procB continuar
1 write('PA1 '); false
2 write('PB1 '); false
3 continuar := true; true
4 write('PA2 '); true
5 while not continuar true
6 write('PB2 '); true
Sincronización Condicional
Intercalación de instrucciones que obtiene la salida
PB1 PA1 PA2 PB2
procA procB continuar
1 write('PB1 '); false
2 while not continuar false
3 while not continuar false
4 while not continuar false
5 write('PA1 '); false
6 continuar := true; true
7 write('PA2 '); true
8 while not continuar true
9 write('PB2 '); true
Sincronización Condicional
Intercalación de instrucciones que obtiene la salida
PA1 PA2 PB1 PB2
procA procB continuar
1 write('PA1 '); false
2 continuar := true; true
3 write('PA2 '); true
4 write('PB1 '); true
5 while not continuar true
6 write('PB2 '); true
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
17
Exclusión Mutua
¿Qué es la Exclusión Mutua? Desde un punto de vista general la exclusión mutua
se tiene cuando varios procesos compiten por un recurso común de acceso exclusivo
Sólo uno de los procesos puede estar accediendo al recurso a la vez y los demás tienen que esperar
Cuando un proceso libera el recurso de acceso exclusivo y otro proceso estaba esperando, el proceso que espera accederá al recurso
De forma mas concreta, para comprender su funcionamiento se estudia El Problema de la Exclusión Mutua
18
Exclusión Mutua
El problema de la Exclusión Mutua Se tienen dos o más procesos concurrentes, que
ejecutan indefinidamente una secuencia de instrucciones dividida en dos secciones
Sección crítica Sección no crítica
19
process type proceso;begin repeat seccion_critica; seccion_no_critica; foreverend;
Exclusión Mutua
Sección Crítica Secuencia de instrucciones que acceden a un recurso
compartido de acceso exclusivo Puesto que el recurso es de acceso exclusivo y solo un
proceso puede acceder a él al mismo tiempo, cada proceso debe ejecutar las instrucciones de la sección crítica sin que haya intercalación de instrucciones de la sección crítica de otros procesos
Se pueden intercalar instrucciones que no hagan uso del recurso, es decir, instrucciones fuera de la sección crítica de otros procesos
Sección No Crítica Secuencia de instrucciones que pueden ser ejecutadas
concurrentemente por todos los procesos Se pueden intercalar con las instrucciones de la sección crítica
y de la sección no crítica de otros procesos
Exclusión Mutua
21
process type proceso;begin repeat preprotocolo; seccion_critica; postprotocolo; seccion_no_critica; foreverend;
El preprotocolo y postprotocolo son las secuencias de instrucciones que deben ejecutar los procesos para garantizar que las instrucciones de la sección crítica se ejecutan cumpliendo los requisitos
Se asume que los procesos finalizan su ejecución fuera de la sección crítica, de forma que siempre hayan ejecutado el postprotocolo
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
22
Propiedades de Corrección
Pese a que pueda parecer sencillo, implementar correctamente un programa para El Problema de la Exclusión Mutua es complejo y hay que tener en cuenta que se deben cumplir ciertas propiedades de corrección
Se estudian con detenimiento porque las tendremos que cumplir siempre que desarrollemos cualquier programa concurrente, no sólo en este problema concreto
Una propiedad de un programa concurrente es una característica que se debe cumplir en cualquier posible intercalación de las instrucciones atómicas
23
Propiedades de Corrección
Exclusión Mutua En cada instante solo puede estar un proceso ejecutando
su sección crítica porque sólo un proceso puede acceder al recurso compartido a la vez
Ausencia de Retrasos Innecesarios Si un proceso intenta entrar en su sección crítica y no hay
otro proceso que también quiera entrar, entonces deberá entrar sin retrasos
Ausencia de Inanición (starvation) Todo proceso que quiera entrar en la sección crítica en
algún momento deberá conseguirlo Se produce inanición cuando un proceso quiere entrar en
la sección critica pero sistemáticamente es otro proceso el que entra en ella
Propiedades de Corrección
Ausencia de Interbloqueos Si varios procesos intentan entrar simultáneamente a su
sección crítica, al menos uno de ellos debe lograrlo. Un interbloqueo se produciría si ambos procesos quedaran esperando
Interbloqueo activo (livelock) Cuando los procesos ejecutan instrucciones que no
producen un avance real del programa, son inútiles Interbloqueo pasivo (deadlock)
Cuando todos los procesos están esperando Como todos están esperando, ninguno de ellos podrá
cambiar las condiciones para que dejen de esperar
Propiedades de Corrección
Las propiedades se dividen en dos tipos De seguridad (safety)
Si alguna de estas propiedades se incumple en alguna ocasión, el programa se comportará de forma errónea
Aseguran que nada malo sucederá durante la ejecución y deben cumplirse siempre
De Vida (liveness) Si alguna de estas propiedades se incumple en
“alguna” ocasión, el programa se comportara de forma correcta pero será lento y desaprovechará los recursos
Aseguran que algo bueno ocurrirá alguna vez durante la ejecución del programa
26
Propiedades de Corrección
Propiedades de seguridad (safety) Exclusión Mutua Ausencia de Interbloqueo pasivo
Propiedades de Vida (liveness) Ausencia de Retrasos innecesarios Ausencia de inanición (starvation) Ausencia de interbloqueo activo (livelock)
Propiedades de Corrección
La Ausencia de Inanición es una propiedad que asegura que todos los procesos pueden acceder a la sección crítica
Es posible que unos procesos accedan en muchas ocasiones a la sección crítica y otros sólo accedan de vez en cuando
El acceso a la sección crítica se puede especificar con más Justicia (fairness)
Espera lineal: Si un proceso quiere entrar en la sección crítica, entrará antes de que otro proceso entre más de una vez
Espera FIFO: Si un proceso quiere entrar en la sección crítica, entrará antes de que entre otro proceso que lo solicite después que él
28
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
29
1ª Aproximación
Alternancia Obligatoria
Utilizar una variable turno que indique el proceso que puede entrar en la región crítica
Cuando un proceso va a entrar en la sección crítica, en el preprotocolo se comprueba si es su turno
Al salir de la sección crítica, en el postprotocolo se indica que el turno es del otro proceso
30
1ª Aproximación
Alternancia Obligatoria
31
type tControl = record turno: integer;end;
process type tP1(var c: tControl); begin repeat (* Preprotocolo *) while c.turno <> 1 do; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.turno := 2; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
process type tP2(var c: tControl); begin repeat (* Preprotocolo *) while c.turno <> 2 do; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.turno := 1; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
1ª Aproximación
Alternancia Obligatoria
A continuación se muestra una posible intercalación de las instrucciones
Se supone que el turno comienza en 1 Se puede observar cómo las instrucciones
de la sección crítica del proceso p1 no se intercalan con las instrucciones de la sección crítica de p2
Se puede observar cómo las instrucciones que no están en la sección crítica se pueden intercalar con instrucciones de la sección crítica
1ª Aproximación
Alternancia Obligatoria
p1 p2 c.turno
1 while c.turno <> 1 1
2 write('SC1 '); 1
3 while c.turno <> 2 1
4 write('SC2 '); 1
5 c.turno := 2; 2
6 while c.turno <> 2 2
7 write('SNC1 '); 2
8 write('SC1 '); 2
9 write('SNC2 '); 2
10 write('SC2 '); 2
11 while c.turno <> 1 2
12 while c.turno <> 1 2
13 c.turno := 1; 1
14 while c.turno <> 1 1
15 write('SC1 '); 1
16 write('SNC1 '); 1
17 write('SC2 '); 1
18 …
1ª Aproximación
Alternancia Obligatoria
Requisitos que cumple Exclusión Mutua Ausencia de Interbloqueos Ausencia de Inanición
Requisitos que no cumple Ausencia de Retrasos Innecesarios
(debido a que la alternancia es obligatoria y no debería serlo)
34
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
35
2ª Aproximación
No Exclusión Mutua
Para evitar la alternancia obligatoria, podemos usar una variable booleana por cada proceso que indique si dicho proceso está en la región crítica
Un proceso al entrar en la región crítica comprueba si ya hay otro proceso y si no hay nadie, indica que entra él
Al salir de la región crítica indica que ya no está en la región crítica
36
2ª Aproximación
No Exclusión Mutua
37
type tControl = record p1sc,p2sc: boolean; end;
process type tP1(var c: tControl); begin repeat (* Preprotocolo *) while c.p2sc do; c.p1sc := true; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.p1sc := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
process type tP2(var c: tControl); begin repeat (* Preprotocolo *) while c.p1sc do; c.p2sc := true; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.p2sc := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
p1 p2 c.p1sc c.p2sc
1 while c.p2sc false false
2 c.p1sc := true; true false
3 while c.p1sc true false
4 write('SC1 '); true false
5 while c.p1sc true false
6 write('SC2 '); true false
7 while c.p1sc true false
8 c.p1sc := false; false false
9 while c.p1sc false false
10 write('SNC1 '); false false
11 c.p2sc := true; false true
12 write('SC1 '); false true
13 write('SNC2 '); false true
14 while c.p2sc false true
15 write('SC2 '); false true
16 while c.p2sc false true
17 c.p2sc := false; false false
18 while c.p2sc false false
19 …
2ª Aproximación
No Exclusión Mutua
Aunque existan intercalaciones que cumplen con los requisitos, existen intercalaciones en las que no se tiene la exclusión mutua
Los dos procesos pueden ejecutar las instrucciones de la sección crítica de forma intercalada
2ª Aproximación
No Exclusión Mutua
Requisitos que no cumple Exclusión Mutua
p1 p2 c.p1sc c.p2sc
1 while c.p2sc false false
2 while c.p1sc false false
3 c.p1sc := true; true false
4 c.p2sc := true; true true
5 write('SC1 '); true true
6 write('SC1 '); true true
7 write('SC2 '); true true
8 write('SC2 '); true true
9 …
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
41
3ª Aproximación
Interbloqueo
El problema de la aproximación anterior es que los dos procesos miran y después entran, pudiendo entrar los dos a la vez
En la 3ª aproximación, antes de comprobar si hay alguien dentro, vamos a hacer una petición
Si alguien lo ha pedido ya, nos esperamos
42
3ª Aproximación
Interbloqueo
43
type tControl = record p1p,p2p: boolean; end;
process type tP1(var c: tControl); begin repeat (* Preprotocolo *) c.p1p := true; while c.p2p do; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.p1p := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
process type tP2(var c: tControl); begin repeat (* Preprotocolo *) c.p2p := true; while c.p1p do; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.p2p := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
p1 p2 c.p1p c.p2p
1 c.p1p := true; true false
2 while c.p2p true false
3 c.p2p := true; true true
4 while c.p1p true true
5 write('SC1 '); true true
6 while c.p1p true true
7 write('SC2 '); true true
8 c.p1p := false; false true
9 while c.p1p false true
10 write('SNC1 '); false true
11 write('SNC2 '); false true
12 write('SC1 '); false true
13 c.p1p := true; true true
14 while c.p2p true true
15 write('SC2 '); true true
16 c.p2p := false; true false
17 while c.p2p true false
18 write('SC1 '); true false
19 …
3ª Aproximación
Interbloqueo
Requisitos que cumple Exclusión Mutua
Requisitos que no cumple Ausencia de interbloqueos
45
p1 p2 c.p1p c.p2p
1 c.p1p := true; true false
2 c.p2p := true; true true
3 while c.p2p true true
4 while c.p1p true true
5 while c.p1p true true
6 while c.p1p true true
7 while c.p2p true true
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
46
4ª Aproximación
Espera Indefinida
La 3ª aproximación falla porque los dos procesos, una vez que anuncian su intención de entrar en su sección crítica, insisten en su derecho de entrar en ella
La 4ª aproximación cede su derecho a entrar en la sección crítica si descubre que hay competencia con otro proceso
47
4ª Aproximación
Espera Indefinida
48
type tControl = record p1p,p2p: boolean; end;
process p1(var c: tControl); begin repeat (* Preprotocolo *) c.p1p := true; while c.p2p do begin c.p1p := false; c.p1p := true; end; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) acceso.p1p := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
4ª Aproximación
Espera Indefinida
Requisitos que cumple Exclusión Mutua
Requisitos que no cumple Interbloqueo
Hay intercalaciones en las que ningún proceso entra en la sección crítica
4ª Aproximación
Espera Indefinida
p1 p2 c.p1p c.p2p
1 c.p1p := true; true false
2 c.p2p := true; true true
3 while c.p2p true true
4 while c.p1p true true
5 c.p1p := false; false true
6 c.p2p := false; false false
7 c.p1p := true; true false
8 c.p2p := true; true true
9 while c.p2p true true
10 while c.p1p true true
11 c.p1p := false; false true
12 c.p2p := false; false false
Interbloqueo
4ª Aproximación
Espera Indefinida
Requisitos que no cumple Inanición
Hay intercalaciones en las que un proceso no entra nunca en la sección crítica mientras que otro proceso entra repetidas veces
p1 p2 c.p1p c.p2p
1 c.p1p := true; true false
2 c.p2p := true; true true
3 while c.p1p true true
4 c.p2p := false; true false
5 while c.p2p true false
6 c.p2p := true; true true
7 write('SC1 '); true true
8 while c.p1p true true
9 write('SC2 '); true true
10 c.p2p := false; true false
11 c.p1p := false; false false
12 write('SNC1 '); false false
13 write('SNC2 '); false false
14 c.p2p := true; false true
15 c.p1p := true; true true
16 while c.p1p true true
17 c.p2p := false; true false
18 while c.p2p true false
19 write('SC1 '); true false
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
53
Solución
Algoritmo de Dekker
Es una combinación de la 1ª y 4ª aproximación
Las variables booleanas aseguran la exclusión mutua (como en la 4ª aproximación)
Al detectar competencia, una variable turno se encarga del “desempate”
54
Solución
Algoritmo de Dekker
55
type tControl = record p1p,p2p: boolean; turno: integer; end;
process p1(var c: tControl); begin repeat (* Preprotocolo *) c.p1p := true; while c.p2p do if c.turno <> 1 then begin c.p1p := false; while c.turno <> 1 do; c.p1p := true; end; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.p1p := false; c.turno := 2; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever end;
Solución
Algoritmo de Dekker
Requisitos que cumple Exclusión Mutua Ausencia de Interbloqueos Ausencia de Retrasos Innecesarios Ausencia de Inanición
56
Una demostración más rigurosa se puede encontrar en el libro Ben-Ari, M. Principles of Concurrent and Distributed Programming. Ed. Prentice Hall, 1.990.
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua
Propiedades de Corrección 1ª Aproximación: Alternancia Obligatoria 2ª Aproximación: No Exclusión Mutua 3ª Aproximación: Interbloqueo 4ª Aproximación: Espera indefinida Solución: Algoritmo de Dekker Uso de la Exclusión Mutua
Espera Activa vs. Espera Pasiva Conclusiones
57
Uso de la Exclusión Mutua
Una instrucción atómica es aquella que se ejecuta como una unidad indivisible
El lenguaje de programación y el hardware definen las instrucciones atómicas en las que se divide cada sentencia
x:=x+1LOAD R,xADD R,#1STR R,x
Instrucciones Atómicas
Sentencia
Uso de la Exclusión Mutua
Supongamos que dos procesos quieren usar una variable común para contar las acciones realizadas
Según hemos visto, si dos procesos quieren incrementar la misma variable existen intercalaciones de las instrucciones atómicas que producen errores en la cuenta
Para el desarrollador sería muy interesante que el incremento de una variable fuese una instrucción atómica
Uso de la Exclusión Mutua
Tipos de instrucciones atómicas De grano fino
Ofrecidas por el lenguaje de programación y el hardware al desarrollador
Habitualmente se corresponden con las instrucciones máquina del procesador
De grano grueso Conjunto de sentencias que ejecuta un proceso sin
interferencias de otros procesos Los lenguajes de programación y el sistema
hardware disponen de mecanismos para hacer que un grupo de sentencias se ejecuten como una instrucción atómica de grano grueso
BLP (06-07) 60
Uso de la Exclusión Mutua
La sección crítica de la exclusión mutua es una instrucción atómica de grano grueso
Es indivisible en el sentido de que ningún otro proceso puede interferir en el uso del recurso compartido de acceso exclusivo
Si dentro de la sección crítica se incrementa una variable, ningún otro proceso podrá interferir en esa sentencia
Pero es divisible en el sentido de que se pueden intercalar instrucciones atómicas de la sección no crítica
61
Uso de la Exclusión Mutua
Se ha visto un algoritmo de Exclusión Mutua para dos procesos. El algoritmo de Lamport es un algoritmo que permite tener una exclusión mutua para más de dos procesos
Este algoritmo es complejo y no vamos a ver su implementación
62
Uso de la Exclusión Mutua
Para simplificar el estudio teórico de la exclusión mutua y de las secciones críticas de un programa, en lugar de poner el código completo del preprotocolo y del postprotocolo usaremos comentarios
Cuando un proceso entra en la sección crítica para hacer uso de un recurso compartido de acceso exclusivo usaremos el comentario
Cuando sale usaremos el comentario
(*preprotocolo(recurso)*)
(*postprotocolo(recurso)*)
Uso de la Exclusión Mutua
Se dice que un recurso “está bajo exclusión mutua” si se ejecuta el preprotocolo antes de usar dicho recurso y el postprotocolo una vez finalizado el uso
Varios recursos pueden estar bajo exclusión mutua en un mismo programa
Puede haber diferentes secciones críticas de acceso a un mismo recurso bajo exclusión mutua Por ejemplo, incrementar y decrementar una variable
son códigos diferentes pero hacen uso del mismo recurso
Las secciones críticas pueden anidarse si es necesario
64
Uso de la Exclusión Mutua
Variable x bajo exclusión mutua con dos secciones críticas
program incdec;
process type inc(var x:integer); begin (*preprotocolo(x)*) x:=x+1; (*postprotocolo(x)*) end; process type dec(var x:integer); begin (*preprotocolo(x)*) x:=x-1; (*postprotocolo(x)*) end;
var x:integer; pInc:inc; pDec:dec;begin x:=0; cobegin pInc(x); pDec(x); coend; writeln(x)end.
Uso de la Exclusión Mutua
El resultado de este programa siempre será 0
No se pueden producir errores al contar porque no se pueden intercalar instrucciones que usan la variable x
Ejercicio 1
Existen 5 personas en el mundo, 1 museo, y sólo cabe una persona dentro del museo
Las personas realizan tres acciones dentro del museo Cuando entran al museo saludan: “hola?” Cuando ven el museo se sorprenden: “qué
bonito!” y “esto es alucinante!!!” Cuando se van del museo se despiden: “adiós”
Al salir les ha gustado tanto que vuelven a entrar
67
Ejercicio 1
Se pide Tipos de procesos Número de procesos del programa concurrente
y de qué tipo son Escribir lo que hace cada proceso Identificar los recursos compartidos Identificar la sección o secciones críticas
Indicar el inicio con (*preprotocolo(recurso)*) Indicar el fin con (*preprotocolo(recurso)*)
Escribir el programa completo
Ejercicio 2
Considerar que caben infinitas personas dentro del museo
Las personas no pueden hablar a la vez
Se pide: Identificar los recursos compartidos Implementar el programa
69
Ejercicio 3
Considerar que caben infinitas personas dentro del museo
Las personas no pueden hablar a la vez Cada persona al entrar tiene que saludar
diciendo cuántas personas hay en el museo: “hola, ya somos 5”
Al despedirse tiene que decir el número de personas que quedan tras irse: “Me voy, adiós a los 4”
70
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva
Problemas de la Espera Activa Herramientas de Espera Pasiva Implementación de la Multiprogramación
Conclusiones
71
Problemas de la Espera Activa
Se ha trabajado en el modelo de Memoria Compartida usando variables compartidas para la sincronización
Se denomina Espera Activa porque los procesos están ejecutando instrucciones (están activos) incluso cuando tienen que esperar para poder continuar su ejecución
72
while not continuar do;
Problemas de la Espera Activa
La Espera Activa tiene bastantes problemas Multiprogramación
Los procesos que están esperando están malgastando el procesador que podría usarse por otros procesos que realmente estén realizando un trabajo útil
Multiproceso Un procesador ejecutando instrucciones consume
energía y por tanto disipa calor Si las instrucciones no son útiles, el procesador
podría estar en reposo
La Espera Activa es muy ineficiente
Problemas de la Espera Activa
Para solucionar estos problemas, surgió la Espera Pasiva
En la espera pasiva, cuando un proceso no puede continuar ejecutando las sentencias se bloquea y deja de ejecutar sentencias hasta que otro proceso lo desbloquea cuando se cumplen las condiciones para que siga ejecutando
Esto permite aprovechar de forma mucho mas adecuada los recursos (capacidad de cómputo, energía, …)
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva
Problemas de la Espera Activa Herramientas de Espera Pasiva Implementación de la Multiprogramación
Conclusiones
75
Herramientas de Espera Pasiva
Puesto que la espera activa es ineficiente se han diseñado herramientas que permiten sincronizar procesos con espera pasiva
Algunas de estas herramientas de sincronización permiten la sincronización con un mayor grado de abstracción de forma que el desarrollo de aplicaciones concurrentes es más sencillo y, por tanto, la probabilidad de fallo es menor
76
Herramientas de Espera Pasiva
En la programación funcional y en la programación orientada a objetos, la gran mayoría de los lenguajes de programación implementan los mismos conceptos Funcional: Funciones, listas, patrones… Orientación a Objetos: Clases, objetos, métodos,
atributos… En la programación concurrente no ocurre lo
mismo y cada lenguaje de programación implementa solo algunas herramientas concurrentes
Herramientas de Espera Pasiva
Herramientas de Espera Pasiva Modelo de Memoria Compartida
Semáforos Monitores Regiones Críticas Regiones Críticas Condicionales Sucesos Buzones Recursos
Modelo de Paso de Mensajes Envío asíncrono Envío síncrono o cita simple Invocación Remota o cita extendida
78
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva
Problemas de la Espera Activa Herramientas de Espera Pasiva Implementación de la Multiprogramación
Conclusiones
79
Implementación de la Multiprogramación
Cuando se ejecuta un programa concurrente en multiprogramación, sólo un proceso puede estar ejecutándose en el procesador a la vez
Para coordinar a todos los procesos que comparten el procesador Planificación (Scheduling) Despacho (Dispatching)
80
Implementación de la Multiprogramación
Planificación (Scheduling) Política que determina la asignación, en
cada instante, de los procesos a los procesadores disponibles
FIFO: El primero que llegó Lineal: No puede volver el mismo proceso
hasta que no hayan ejecutado los demás Prioridades: El más prioritario Aleatoria
81
Implementación de la Multiprogramación
Despacho (Dispatching) Configuración del procesador para que ejecute el proceso que ha determinado la
planificación El proceso debe ejecutarse con las mismas condiciones en las que abandonó el
procesador Para ello el sistema dispone de un Descriptor de Proceso (Process Control Block)
por cada proceso que alberga toda la información necesaria Identificador del proceso (Process ID, PID) Estado Entorno, Memoria, …
82
Implementación de la Multiprogramación
Para implementar la Espera Pasiva, un proceso en un sistema en multiprogramación puede estar en los siguientes estados
83
Bloqueado
Preparado Ejecución
Sincronización con Espera Activa
Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva Conclusiones
84
Conclusiones
Se han descrito las propiedades de corrección que debe cumplir un programa concurrente
Propiedades de seguridad (safety) Exclusión Mutua Ausencia de Interbloqueo pasivo
Propiedades de Vida (liveness) Ausencia de Retrasos innecesarios Ausencia de inanición (starvation) Ausencia de interbloqueo activo (livelock)
Conclusiones
Condición de carrera Se dice que se ha producido una
condición de carrera (race condition) cuando un programa concurrente se comporta de una forma anómala debido a que los procesos no están bien sincronizados entre si
Habitualmente las condiciones de carrera ocurren solo ocasionalmente y aparecen en ciertas intercalaciones de instrucciones
Conclusiones
La Espera Activa es una técnica muy ineficiente
No debe usarse nunca para desarrollar programas concurrentes