Tema 06: Programación Concurrente Sincronización con Espera Activa

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

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

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

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

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)

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 ');

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 ');

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 ');

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

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

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

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

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

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

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

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;

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

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

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)

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

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 …

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

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 …

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

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 …

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.

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

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;

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

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

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

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”

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.

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,

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

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

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

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

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

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

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.

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

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

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;

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

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

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

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

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

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)

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

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

Para implementar la Espera Pasiva, un proceso en un sistema en multiprogramación puede estar en los siguientes estados Preparado Ejecución Bloqueado

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

Tema 06: Programación Concurrente Sincronización con Espera Activa

Presentaciones similares

Presentación del tema: "Tema 06: Programación Concurrente Sincronización con Espera Activa"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Tema 06: Programación Concurrente Sincronización con Espera Activa

Presentaciones similares

Presentación del tema: "Tema 06: Programación Concurrente Sincronización con Espera Activa"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback