Tema 06: Programación Concurrente Sincronización con Espera Activa MAESTRÍA EN INGENIERIA DE...

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


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



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


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


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



PB1 PA1 PA2 PB2


1 write('PB1 '); false

2 while not continuar false










PA1 PA2 PB1 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

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





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


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





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


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


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


p1 p2 c.turno

1 while c.turno <> 1 1

2 write('SC1 '); 1


4 write('SC2 '); 1

5 c.turno := 2; 2


7 write('SNC1 '); 2

8 write('SC1 '); 2

9 write('SNC2 '); 2

10 write('SC2 '); 2



13 c.turno := 1; 1


15 write('SC1 '); 1

16 write('SNC1 '); 1

17 write('SC2 '); 1

18 …

1ª Aproximación


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





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




8 c.p1sc := false; 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


16 while c.p2sc false true

17 c.p2sc := false; 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



3 c.p1sc := true; true false

4 c.p2sc := true; true true

5 write('SC1 '); true true




9 …





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




8 c.p1p := false; false true

9 while c.p1p false true







16 c.p2p := false; 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












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






6 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














14 c.p2p := true; false true










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.





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


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

61


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


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

64


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.


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


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;


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




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


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

78




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


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


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


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

83

Bloqueado

Preparado Ejecución



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 MAESTRÍA EN INGENIERIA DE...

Documents

Transcript of Tema 06: Programación Concurrente Sincronización con Espera Activa MAESTRÍA EN INGENIERIA DE...