Tema 06: Programación Concurrente Sincronización con Espera Activa UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN E S P G MAESTRÍA EN INGENIERIA DE SISTEMAS E INFORMÁTICA ADMINISTRACIÓN DE TECNOLOGÍAS DE INFORMACIÓN Tema 06: Programación Concurrente Sincronización con Espera Activa Prof: Alberto E. Cohaila Barrios acohailab@unjbg.edu.pe, acohailab@hotmail.com, acohailab@speedy.com.pe

Sincronización con Espera Activa Introducción Sincronización Condicional Exclusión Mutua Espera Activa vs. Espera Pasiva Conclusiones

Introducción 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 ¿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 Escrituras 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

Introducción Relaciones entre procesos Actividades entre procesos Hay diferentes tipos Sincronización Condicional Se lleva a cabo mediante Competencia Sincronización Exclusión Mutua A veces necesita Cooperación Comunicació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

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

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 PA1 PA2 Proceso A Proceso B PB1 PB2 Diagrama de Precedencia

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: Algunas Salidas Posibles: PA1 PA2 PB1 PB2 PA1 PA2 PB1 PB2 Proceso A Proceso B PA1 PB1 PA2 PB2 PB1 PA1 PA2 PB2 PB1 PA1 PB2 PA2 Salidas No Posibles: PB1 PB2 PA1 PA2 * La escritura en pantalla con write es una instrucción atómica en PascalFC

Sincronización Condicional program sinccond; process tPA(var continuar:boolean); begin write('PA1 '); continuar := true; write('PA2 '); end; process tPB(var continuar:boolean); write('PB1 '); while not continuar do; write('PB2 '); var continuar: boolean; procA:tPA; procB:tPB; continuar := false; cobegin procA(continuar); procB(continuar); coend; end. Sincronización Condicional 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 continuar Saldrá del bucle cuando valga true y continuará ejecutando PB2 BLP (06-07)

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 '); 3 continuar := true; true 4 write('PA2 '); 5 while not continuar 6 write('PB2 ');

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 3 4 5 write('PA1 '); 6 continuar := true; true 7 write('PA2 '); 8 9 write('PB2 ');

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 '); 4 write('PB1 '); 5 while not continuar 6 write('PB2 ');

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

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 process type proceso; begin repeat seccion_critica; seccion_no_critica; forever end;

Exclusión Mutua Sección Crítica Sección No 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 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 process type proceso; begin repeat preprotocolo; seccion_critica; postprotocolo; seccion_no_critica; forever end; La terminación de la ejecución fuera de la sección crítica asegura que el proceso ha ejecutado su postprotocolo antes de acabar. De otra forma la sección crítica seguiría asociada al proceso que ha finalizado, y ningún otro podría entrar. 21

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

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

1ª Aproximación Alternancia Obligatoria 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 c.turno 1 while c.turno <> 1 2 write('SC1 '); 3 while c.turno <> 2 4 write('SC2 '); 5 c.turno := 2; 6 7 write('SNC1 '); 8 9 write('SNC2 '); 10 11 12 13 c.turno := 1; 14 15 16 17 18 … 1ª Aproximación Alternancia Obligatoria

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)

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

2ª Aproximación No Exclusión Mutua 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 2 c.p1sc := true; true 3 while c.p1sc 4 write('SC1 '); 5 6 write('SC2 '); 7 8 c.p1sc := false; 9 10 write('SNC1 '); 11 c.p2sc := true; 12 13 write('SNC2 '); 14 15 16 17 c.p2sc := false; 18 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 2 while c.p1sc 3 c.p1sc := true; true 4 c.p2sc := true; 5 write('SC1 '); 6 7 write('SC2 '); 8 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

3ª Aproximación Interbloqueo 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 3 c.p2p := true; 4 while c.p1p 5 write('SC1 '); 6 7 write('SC2 '); 8 c.p1p := false; 9 10 write('SNC1 '); 11 write('SNC2 '); 12 13 14 15 16 c.p2p := false; 17 18 19 …

3ª Aproximación Interbloqueo Requisitos que cumple Exclusión Mutua Requisitos que no cumple Ausencia de interbloqueos p1 p2 c.p1p c.p2p 1 c.p1p := true; true false 2 c.p2p := true; 3 while c.p2p 4 while c.p1p 5 6 7 El estudio de los demás requisitos no tiene sentido: el interbloqueo es un problema que invalida la solución.

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

4ª Aproximación Espera Indefinida process p1(var c: tControl); begin repeat (* Preprotocolo *) c.p1p := true; while c.p2p do c.p1p := false; end; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) acceso.p1p := false; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever type tControl = record p1p,p2p: boolean; 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 Interbloqueo p1 p2 c.p1p c.p2p 1 c.p1p := true; true false 2 c.p2p := true; 3 while c.p2p 4 while c.p1p 5 c.p1p := false; 6 c.p2p := false; 7 8 9 10 11 12

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; 3 while c.p1p 4 c.p2p := false; 5 while c.p2p 6 7 write('SC1 '); 8 9 write('SC2 '); 10 11 c.p1p := false; 12 write('SNC1 '); 13 write('SNC2 '); 14 15 16 17 18 19

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”

Solución Algoritmo de Dekker process p1(var c: tControl); begin repeat (* Preprotocolo *) c.p1p := true; while c.p2p do if c.turno <> 1 then c.p1p := false; while c.turno <> 1 do; end; (* Sección Crítica *) write('SC1 '); write('SC2 '); (* Postprotocolo *) c.turno := 2; (* Sección No Crítica *) write('SNC1 '); write('SNC2 '); forever type tControl = record p1p,p2p: boolean; turno: integer; end; El turno ayuda a desempatar. Cuando los dos quieren entrar, se mira de quién es el turno: ese entra y el otro se queda esperando. El que entró al salir de su sección crítica le da el turno al otro, con lo que se evita el problema de la espera indefinida y de la inanición: la siguiente vez el turno es del otro y se esperará el que acaba de entrar. No hay retrasos innecesarios, porque mientras P1 no lo pida, P2 puede entrar las veces que lo desee. El turno sólo entra en juego cuando hay conflicto: los dos quieren entrar.

Solución Algoritmo de Dekker Requisitos que cumple Exclusión Mutua Ausencia de Interbloqueos Ausencia de Retrasos Innecesarios Ausencia de Inanición 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

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 Instrucciones Atómicas Sentencia LOAD R,x ADD R,#1 STR R,x x:=x+1

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

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

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 Ejercicio del museo.

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); x:=x-1; var x:integer; pInc:inc; pDec:dec; begin x:=0; cobegin pInc(x); pDec(x); coend; writeln(x) end. 65

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 Ejercicio del museo. 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 Ejercicio del museo. 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” Ejercicio del museo. 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 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

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

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)

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

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, …

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 Preparado Ejecución Bloqueado

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