Sitra Tema3

Sistemas Informticos de Tiempo Real
Tema 3: Programacin concurrente

Alfons Crespo
Universidad Politcnica de Valencia
Instituto de Automtica e Informtica Industrial
http://www.gii.upv.es/personal/alfons
acrespo@disca.upv.es
Objetivos
Estudiar los conceptos generales de la
programacin concurrente
Saber realizar aplicaciones concurrentes en el
lenguaje Ada
Reconocer y saber utilizar los mecanismos de
comunicacin entre tareas
Saber desarrollar una aplicacin con tareas
Sistemas Informticos de tiempo real.
Indice
Conceptos
generales
Procesos
Concurrencia
en Ada
Comunicacin
y sincronizacin
Comunicacin
por memoria compartida
Tipos
protegidos
Comunicacin
por paso de mensajes
Cita
Conceptos generales
La programacin concurrente no es el modelo comn de

programacin
Exige un esfuerzo mayor para la comprensin de los
programas y su depuracin
Gran potencia expresiva
Muy til en los sistemas de control
Todos las aplicaciones estn diseadas con un modelo
concurrente
Procesos: Introduccin
Se pueden ejecutar en uno de los siguientes entornos:
Multiplexando sus ejecuciones en un solo procesador

Multiplexando sus ejecuciones en varios procesadores con memoria
compartida
Multiplexando sus ejecuciones en varios procesadores que no
comparten memoria (sistema distribuido)
Solo en el segundo y tercer caso existe paralelismo real
Procesos: Definiciones
Proceso:
Un proceso es una unidad de ejecucin que tienen un

estado definido por un conjunto de variables que
describiremos posteriormente
Un proceso es un elemento activo del sistema y cambiante
frente al programa que es un elemento esttico (fichero en
disco).
Un proceso es un programa en ejecucin
Concepto de proceso
with TEXT_IO; use TEXT_IO;
with ASCII_UTILITIES;
procedure Valdemo is
TEXT : string(1..80);
LENGTH : natural;
F : float; fich.exe
begin
put_line("VALDEMO");new_line;
put_line("Enter some real numbers ");
.
new_line; put_line("Done.");
end Valdemo;
Programas y procesos
CPU
P.P.
C.P.
pila
pila
dkjfdsljf
dsldldjf
ds9u094
3nc32049
reks-0e
cargar
R0
R2
R4
R1
R3
R5
P.E.
datos
cdigo
datos
cdigo
Memoria
7
Procesos: Ciclo de Vida
Un proceso es un elemento dinmico del sistema, y

cambia de estado.
nuevo
terminado
ejecucin
preparado
espera
Procesos
CPU's virtuales
pila
P.P.
dades
C.P.
Cdigo
P.E.
pila
P.P.
Datos
C.P.
Cdigo
R0
R2
R4
R1
R3
R5
CPU
P.P.
R0
R2
R4
R1
R3
R5
R0
R2
R4
R1
R3
R5
C.P.
R0
R2
R4
R1
R3
R5
P.E.
P.E.
pila
P.P.
Datos
C.P.
Cdigo
Memoria
P.E.
Procesos: Representacin
PCB: conjunto de atributos que le caracterizan y describen a un

proceso en un instante dado
Se crea uno por cada proceso en el sistema
Informacin de tres tipos:
Identificacin
Informacin de estado
Informacin de control
10
Procesos: Multiplexacin
Para conseguir la ejecucin concurrente de los procesos en el

sistema, se multiplexa la CPU
Esto significa intercambiar los valores que caracterizan y

describen al proceso saliente por los del entrante: cambio de
contexto
Esta operacin interesa que sea breve
11
Procesos: Multiplexacin
El resultado es que cada proceso posee una CPU virtual, lo cual
da la sensacin de que est permanentemente en ejecucin.
CPU's virtuales
CPU's virtuales
CPU's virtuales
P.P.
P.P.
P.P.
C.P.
R0
R2
R4
R1
R3
R5
P.E .
P.P.
C.P.
P.P.
R0
R2
R4
R1
R3
R5
C.P.
R0
R2
R4
CPU
C.P.
R1
R3
R5
P.E .
P.E.
P.E .
P.P.
C.P.
P.P.
C.P.
R0
R2
R4
R1
R3
R5
P.P.
R0
R2
R4
R1
R3
R5
P.E .
R0
R2
R4
R1
R3
R5
P.E .
P.P.
C.P.
P.E .
C.P.
P.E.
R0
R2
R4
CPU
C.P.
R1
R3
R5
P.E .
P.P.
C.P.
R0
R2
R4
R1
R3
R5
CPU
P.P.
R0
R2
R4
R1
R3
R5
R0
R2
R4
R1
R3
R5
C.P.
R0
R2
R4
R1
R3
R5
P.E.
P.E .
R0
R2
R4
R1
R3
R5
P.P.
C.P.
P.E .
12
Cambio de contexto
CPU
P.P.
j
C.P.
pila
datos
cdigo
S.O.
R0
R2
R4
R1
R3
R5
P.E.
Tabla de procesos
PCB
pila
datos
cdigo
j
13
Cambio de contexto
1. Est en ejecucin el proceso i
2. Se produce una interrupcin
3. Salva el contexto del proceso i en su posicin de la PCB
4. Se resuelve la interrupcin
5. Se selecciona el siguiente proceso a ejecutar (j)
6. Se carga el contexto de del proceso j PCBj
j
i
S.O.
P.P.
C.P.
pila
datos
cdigo
R0
R2
R4
P.P.
R1
R3
R5
P.E.
datos
cdigo
PCB
j
C.P.
pila
pila
datos
CPU
CPU
CPU
R0
R2
R4
P.P.
R1
R3
R5
datos
P.E.
cdigo
j
datos
PCB
R1
R3
R5
P.E.
Taula_Proces
pila
j
cdigo
cdigo
pila
i
C.P.
pila
R0
R2
R4
datos
cdigo
j
14
Planificacin
cola_preparados
e/s
cola_bloqueados
CPU
peticin de e/s
expulsin forzosa
evento
espera un evento
planificador
Permite la ejecucin concurrente (alternada) de los procesos.
Un
es el elemento encargado de seleccionar el
proceso mas adecuado para ser ejecutado
15
Concurrencia en lenguajes de programacin

n
La concurrencia puede estar soportada por el

lenguaje o solo por el sistema operativo
q
q
Ventajas
q
q
q
q
Ada y Java tienen concurrencia

C no incluye la concurrencia en el lenguaje
Programas ms legibles y fciles de mantener
Programas ms porttiles
Se pueden detectar errores al compilar
No hace falta sistema operativo
Inconvenientes
q
q
q
Distintos modelos de concurrencia segn lenguajes

Puede ser difcil de realizar eficientemente
Se puede mejorar la portabilidad con SO
normalizados
16
Cmo se ejecutan las tareas
La poltica de planificacin define la

secuencia de ejecucin
n Tipos de planificadores
n
Secuencial: un proceso no accede a la CPU

hasta que el otro no ha terminado
Turno de llegada: En el mismo orden que llegan
a la cola de preparados
Turno rotatorio: asignacin por intervalos de
tiempo
Basado en prioridades: primero los ms
prioritarios
Adems pueden ser expulsivos o no

expulsivos (desalojo)
17
Planificacin: Turno de llegada

Nuevo
Cola de procesos
preparados
(FCFS, First came first served)
Procesador
Cola de procesos
bloqueados
Termina
T3
T2
T1
18
Planificacin: turno rotatorio

fin del turno (expulsion)
Nuevo
Cola de procesos
preparados
Procesador
Termina
Los procesos se ejecutan

durante un quantum () de
tiempo hasta su finalizacin.
Cola de procesos
bloqueados
T3
T2
T1
19
Planificador basado en prioridades

Expulsion
Cola de procesos
preparados
Procesador
Nuevo
Termina
Primero el que ms prioridad tiene
Cola de procesos
bloqueados
20
Planificacin de sistemas de tiempo real

Se utilizan planificadores basados en prioridades asignadas por el
usuario: prioridades fijas.
La planificacin se realiza atendiendo a criterios fijos, p.e. prioridad de un
proceso.
Periodo T. Lmite Prioridad
Es fundamental la asignacin de
prioridades para que un sistema
funcione correctamente (cumpla
las restricciones temporales).
Ui
21
Concurrencia en ADA: Tareas
Ada permite la programacin de actividades concurrentes.

En un programa en Ada, el usuario puede definir un nmero de
procesos internos (task) para cada uno de los cuales se define un hilo
de ejecucin y comparten memoria entre ellas.
Por cada programa Ada se crea un hilo de ejecucin (padre) y tantos
procesos hijos como tareas se han definido
task <nombre> is
-- variables locales
begin
<instrucciones>;
end <nombre>;
22
Concurrencia en ADA: Tareas
Denicin de tarea: task P;

Tipos de tareas task type P;
Discriminantes en tareas
task type P(p1 : Integer; .);
Comunicacin y sincronizacin de tareas
23
Tareas: Creacin
Las tareas en Ada pueden declararse en cualquier nivel de la aplicacin y
son creadas de forma implcita cuando se entra en el mbito de la
declaracin.
Procedure Ejemplo_1 is
task A;
task body A is
--declaraciones.
begin
--codigo de la tarea
end A;
begin
-- cdigo del principal
end Ejemplo_1;
24
Tareas: Ejemplo Bsico

with Gnat.Io; use Gnat.Io;
procedure P2t is
task Una;
task Dos;
task body Una is ....
task body Dos is ....
begin
Put_Line("soy el proceso principal y empiezo");
for I in 1..5 loop
delay 2.0;
Put("soy el proceso y estoy en mi iteracion n. : ");
Put(I); New_Line;
end loop;
Put_Line("soy el proceso y termino");
end P2t;
25

task body Una is
begin
Put_Line("soy la tareas 1 y empiezo");
for I in 1..5 loop
delay 1.0;
Put("soy la tareas 1 y estoy en mi iteracion n. : ");
Put(I); New_Line;
Calcular(I);
end loop;
Put_Line("soy la tareas 1 y termino");
end Una;
task body Dos is
begin
Put_Line("soy la tareas 2 y empiezo");
for I in 1..5 loop
delay 1.0;
Put("soy la tareas 2 y estoy en mi iteracion n. : ");
Put(I); New_Line;
Calcular(I);
end loop;
Put_Line("soy la tareas 2 y termino");
end Dos;
26

procedure Calcular ( N : Integer ) is
X,Y : Float;
begin
for K in 1..N * 10000 loop
X := 1.1234;
for I in 1..10 loop
for J in 1..200 loop
Y := X * X * X;
Y := X * X * X;
end loop;
end loop;
end loop;
end Calcular;
27
Tareas: Ejemplo
Productores y Consumidores
4
5
2
3
Almacn
1
P
28
Tareas: Ejemplo
4
5
2
Almacn
1
5
1
6
6
P
C
29
Tareas: Ejemplo
4
5
2
3
task body Productor is

I : Integer := 0;
begin
delay 1.0; -- Retardo (1)
1
loop I := I + 1;
exit when I > Veces;
Item := Item + 1;
2
delay Espera; -- Retardo (2)
delay 1.0;
---- Retardo (3)
while Lleno loop
delay 1.0;
4
end loop;
Anyadir(Mi_Cola1, Item);
delay 1.0; -- Retardo(5)
5
end loop;
delay 1.0; -- Retardo(6)
6
end Productor;
Almacn
1
P
30
Tareas: Ejemplo
task body Consumidor is
X : Integer; I : Integer := 0;
begin
delay 1.0; 1
loop
I := I + 1;
while Vacio loop
delay 1.0; 2
end loop;
Sacar(Mi_Cola1, X);
delay 1.0;
3
delay Espera;
4
5
delay 1.0;
end loop;
6
delay 1.0;
end Consumidor;
Productores y
Consumidores
4
2
3
5
1
6
C
31
Tareas: Creacin
with Text_Io; use Text_Io;
with Tampones; use Tampones;
procedure Test is
T: Tampon_Circular;
task Productor;
task Consumidor;
begin
Inicializar;
Put_Line("Programa de test del tampon concurrente");
end Test;
32
Tareas: Creacin
I : Integer:= 0;
begin
loop
I := I + 1;
exit when I > 30;
delay 0.7;
while Lleno loop
delay 1.0;
end loop;
Anyadir(T, I);
Put(" He anyadido el item: ");
Put(I); New_Line;
end loop;
end Productor;

X : Item;
I : Integer:= 0;
begin
loop
I := I + 1;
exit when I > 30;
while Vacio loop
delay 1.0;
end loop;
Sacar(T, X);
Put(" He sacado el item: ");
Put(X); New_Line;
delay 1.1;
end loop;
end Consumidor;
33
Tareas: Declaracin de Tareas tipo

n
Uno de los problemas con la definicin de una tarea es cuando

se requieren varias instancias de una actividad de
caractersticas similares
q
Por ejemplo: Queremos tener 3 Productores y 2
Consumidores
Una opcin es replicar la tarea PRODUCTOR y la CONSUMIDOR

N veces. (poco eficiente)
Otra alternativa es definir tipos tarea y realizar instancias de
estas tareas.
Definicin de tipo tares:
task type Productor;

task type Consumidor;
P1, P2 : Productor;
C1, C2 : Consumidor;
34
Tareas: declaracin de tareas tipo

I : Integer:= 0;
begin
delay 2.0;
loop
I := I + 1;
exit when I > 30;
delay 0.7;
while Tampones.Lleno(T) loop
Put_Line("Productor: esta lleno y me espero");
delay 1.0;
end loop;
Anyadir(T, I);
Put(" He anyadido el item: ");
Ada.Integer_Text_Io.Put(I);
New_Line;
end loop;
end Productor;
35

X : Integer;
I : Integer:= 0;
begin
loop
I := I + 1;
exit when I > 30;
while Tampones.Vacio(T) loop
Put_Line("Consumidor: esta vacio y me espero");
delay 1.0;
end loop;
Sacar(T, X);
Put(" He sacado el item: ");
Ada.Integer_Text_Io.Put(X);
New_Line;
delay 1.1;
end loop;
end Consumidor;
36

with Text_Io; use Text_Io;
with Ada.Integer_Text_Io;
with Tampones; use Tampones;
procedure Prueba2 is
T: Tampon_Circular;

P1, P2 : Productor;
C1,C2: Consumidor;
-- codigo de las tareas productor y consumidor
begin
Inicializar(T);
Put_Line("Programa de test del tampon concurrente");
end Prueba2;
37
Tareas: Discriminantes
Otro de los problemas que se puede presentar es el de

identificar cada tarea:
task type PRODUCTOR(pid: INTEGER);
task type CONSUMIDOR(cid: INTEGER);
P1: PRODUCTOR(pid => 1);
P2: PRODUCTOR(pid => 2);
C1: CONSUMIDOR(cid => 1);
task type PRODUCTOR(pid: INTEGER; veces: INTEGER;
retardo: NATURAL);
task type CONSUMIDOR(cid: INTEGER; veces: INTEGER;
retardo: NATURAL);
P1: PRODUCTOR(pid => 1, veces => 10, retardo => 1);
P2: PRODUCTOR(2, 5, 2);
C1: CONSUMIDOR(1, 15, 2);
38
Problema: Identificacin del quin es quin?

task type Productor(Pid: Integer;
Veces: Integer; Retardo: Natural);
I : Integer:= 0;
Espera : Duration;
begin
Espera := To_Duration(Milliseconds(Retardo));
loop
I := I + 1;
delay Espera;
Item := Item + 1;
Anyadir(T, Item);
end loop;
Put("Productor"); Put(Pid);
end Productor;
Put(" Termino "); New_Line;
39
Problema: Identificacin del quin es quin?

task type Productor(Pid: Integer;
task type Consumidor(Cid: Integer;
P1
P2
P3
P4
:
:
:
:
Productor(Pid
Productor(Pid
Productor(Pid
Productor(Pid
C1
C2
C3
C4
:
:
:
:
Consumidor(Cid
Consumidor(Cid
Consumidor(Cid
Consumidor(Cid
=>
=>
=>
=>
=>
=>
=>
=>
1,
2,
3,
4,
1,
2,
3,
4,
Veces
Veces
Veces
Veces
Veces
Veces
Veces
Veces
=>
=>
=>
=>
=>
=>
=>
=>
10, Retardo => 3000);

5, Retardo => 4000);
15, Retardo => 2100);
15, Retardo => 1000);
15,
10,
10,
10,
Retardo
Retardo
Retardo
Retardo
=>
=>
=>
=>
5000);
2000);
7000);
6000);
40
Tareas: Creacin
Una tarea termina cuando:
Ha terminado las instrucciones a ejecutar, es

decir termina la ejecucin de su cuerpo
Por una excepcin de su mbito. En este
caso la excepcin se asla en esta tarea.
Ejecuta una alternativa terminate en un
select
Es abortada por otra tarea
Cualquier tarea puede consultar si

otra est activa: T'Terminated
41
Comunicacin y sincronizacin entre

procesos
Normalmente los procesos no son

independientes
Necesita sincronizarse y comunicarse entre si
Esta es la mayor fuente de problemas en
sistemas concurrentes y hace el programa
difcil de depurar
La correccin de estos aspectos es critica
42
Comunicacin y sincronizacin entre

procesos
Sincronizacin: situar a dos procesos a unos estados
predefinidos simultneamente.
Comunicacin: paso de informacin entre procesos o tareas
Ambos conceptos estn fuertemente ligados
43
Comunicacin entre procesos

Hay dos modelos bsicos de comunicacin:
Memoria compartida
Mensajes
44
Comunicacin por memoria compartida
Nos encontramos con el problema de

garantizar un acceso excluyente a la
zona comn.
Si no se puede garantizar, la
informacin puede no ser correcta
Esto se debe a que las operaciones
no son atmicas
45
generic
N: Positive;
package variables is
type Variable is array(1..N) of Integer;
Incrementar
Mostrar
procedure Incrementar (V: in out Variable);

procedure Mostrar (V: in Variable);
procedure Iniciar (V: in out Variable);
end variables;
Iniciar
46

with GNAT.IO; use GNAT.IO;
package body variables is
task type Incrementador;

task Mostrador;
task body Incrementador is
Siguiente
: Time;
Periodo : Time_Span := Milliseconds(110);
begin
Siguiente := Clock;
loop
Incrementar(V);
Siguiente := Siguiente + Periodo;
delay until Siguiente;
end loop;
end Incrementador;
task body Mostrador is
Siguiente
: Time;
Periodo : Time_Span := Milliseconds(200);
begin
Siguiente := Clock;
loop
Mostrar(V);
Siguiente := Siguiente + Periodo;
delay until Siguiente;
end loop;
end Mostrador;
procedure Incrementar (V: in out Variable) is

begin
for i in reverse 2..N loop
V(i) := V(i-1);
end loop;
V(1) := V(1) + 1;
end Incrementar;
procedure Mostrar (V: in Variable) is
begin
Put("Variable = (");
for i in 1..N loop
Put(V(i));
Put(", ");
end loop;
Put_line(")");
end Mostrar;
procedure Iniciar (V: in out Variable) is
begin
for i in 1..N loop
V(i) := 0;
end loop;
end Iniciar;
begin
null;
end variables;
47
Tarea P1 x:=x+1
Tarea P2 x:=x-1
Resultado: el tampn tiene 5 objetos pero el

contador dice que son 4
48
Incluso esta solucin adolece de problemas: las condiciones de

carrera
Los lenguajes proveen de unos de estos tres mecanismos para
sincronizacin:
Semforos
Regiones criticas
Monitores
Ada ofrece los tipos protegidos
49
Tipos Protegidos
Ada permite eliminar los problemas de coordinacin y
comunicacin con datos suministrando una abstraccin como
es el tipo protegido.
Este tipo protegido es similar a los MONITORES y
REGIONES CRTICAS
Un tipo protegido de Ada encapsula unos datos,
proporcionando un acceso a los mismos mediante
subprogramas (function o procedure) y mediante
entradas (entry) protegidos
Se garantiza el acceso excluyente de las tareas
a los mismos
Nos permite la comunicacin y sincronizacin
entre las mismas
50
Tipos Protegidos
lectura/escritura
lectura
procedure
datos
function
Procedure: proporciona acceso de lectura/escritura excluyente a los datos.

Function: proporciona acceso concurrente de lectura de los datos. Procedures
y functions son excluyentes.
51
Tipos Protegidos
lectura/escritura
lectura
lectura/escritura
procedure
datos
function
entry
Procedure: proporciona acceso de lectura/escritura excluyente a los datos.

Function: proporciona acceso concurrente de lectura de los datos. Procedures
y functions son excluyentes.
Entry: Es un procedure sobre el que se identifica una condicin (guarda) de acceso.
Si la guarda = FALSE, la tarea invocante se suspende en la barrera (cola interna)
hasta que la guarda es CIERTA y no queda ninguna tarea ejecutando en el objeto
protegido
52
Tipos Protegidos
l Sincronizacin
l Proteger un recurso
l Compartir variables de forma segura
53
Tipos Protegidos
l Sincronizacin
Sincronizar las tareas para garantizar un
estado determinado.
Por ejemplo:
Control Marcha/Paro. Las tareas se
sincronizan y arrancan de una forma
coordinada.
54
Tipos Protegidos
l Proteger un recurso
Varias tareas acceden a un recurso comun (la
pantalla). Las lineas se entremezclan.
Opcin
tomar el recurso
Usarlo
Soltarlo
55
Ejemplo de sincronizacin: el semforo

package Semaforos is
package Recursos is
protected type Semaforo is

entry Entrar;
procedure Salir;
protected type Recurso is

entry Tomar;
procedure Soltar;
private
Abierto: Boolean := true;
end Semaforo;
private
Libre : Boolean := true;
end Recurso;
end Semaforos;
End Recursos;
Paquete de especificacin: ofrece un tipo

semaforo/recurso y unas acciones sobre el mismo
56
Ejemplo de sincronizacin: el semforo / Recurso

package body Semaforos is
protected body Semaforo is
package body Recursos is

protected body Recurso is
entry Entrar when Abierto is

begin
Abierto := False;
end Entrar;
entry Tomar when Libre is

begin
Libre := False;
end Tomar;
procedure Salir is
begin
Abierto := True;
end Salir;
procedure Soltar is
begin
Libre := True;
end Soltar;
end Semaforo;
end Semaforos;
end Recurso;
end Recursos;
57
Distintas versiones de semforos
Con control del nmero de

usuarios
Con control del sentido de los

usuarios
entry Entrar;
procedure Salir;
private
Contador: Integer := 0;
end Semaforo;
end Semaforos;
entry Entrar_Izquierda;
entry Entrar_Derecha;
procedure Salir_izquierda;
procedure Salir_derecha;
private
nizq_der, nder_izq: Integer:= 0;
end Semaforo;
end Semaforos;
58
Colas NO Protegidas
Generic
N: Positive; type Item is private;
with procedure Put(I1: Item); with function to_String(I: Item) return String;
package Colas is
type Cola_Circular is limited private;-- operaciones
function Vacia(C : in Cola_Circular) return Boolean;
function Llena(C : in Cola_Circular) return Boolean;
procedure Inicializar (C : in out Cola_Circular);
procedure Anyadir( C : in out Cola_Circular; I: in Item);
procedure Sacar (C : in out Cola_Circular; I: out Item);
procedure Listar(C : in Cola_Circular);
procedure Estado(C : in Cola_Circular);
Cola_Llena, Cola_Vacia: exception;
private
-- estructura
subtype Index is Integer range 0..N-1;
type Cola is array (Index) of Item;
type Cola_Circular is
record
Datos: Cola;
Entrada: Integer := 0;
Salida: Integer := -1;
Contador: Integer :=0;
end record;
end Colas;
59
Colas Protegidas
generic
N: Positive; type Item is private;
with procedure Put(I1: Item); with function To_String(I: Item) return String;
package Colas is
type Cola is array(0..N-1) of Item;
protected type Cola_Circular is
-- operaciones
function Vacia return Boolean;

function Llena return Boolean;
procedure Inicializar;
entry Anyadir(I: in Item);
entry Sacar (I: out Item);
procedure Listar;
procedure Estado;
private
-- estructura de datos
Datos : Cola;
end Cola_Circular;
end Colas;
60
Diferencias
No protegido
Protegido
Definicin del tipo
type Cola_Circular is limited private;
protected type Cola_Circular is
Objeto en los parmetros

function Vacia(C : in Cola_Circular)
return Boolean;
function Vacia return Boolean;
Algunos procedimientos son entry

procedure Anyadir( C : in out Cola_Circular;
I: in Item);
Definicin de la estructura de datos

private
type Cola_Circular is
record
Datos: Cola;
end record;
endSistemas
Colas; Informticos de tiempo real.
private
Datos : Cola;
end Cola_Circular;
61
Diferencias
No protegido
Protegido
Uso del tipo
C : Cola_Circular;
Anyadir(C, item);
procedure Anyadir( C : in out Cola_Circular;

I: in Item);
C : Cola_Circular;
C.Anyadir(item);
62
Comunicacin entre procesos
Hay dos modelos bsicos de comunicacin:
Memoria compartida
Mensajes
63
La Cita Extendida
La sincronizacin es implcita
Variantes segn la semntica del operador de
envo de mensaje:
Asncrono
Sncrono
Invocacin remota
Ada ofrece el modelo de invocacin remota o cita
extendida (extended rendevouz)
64
La Cita Extendida
La comunicacin es directa entre las tareas

Basado en un modelo cliente/servidor
La tareas declaran en su especificacin un conjunto
de servicios que ofrecen al resto. Esto se hace
mediante declaraciones de entradas (entry)
Cada entry tiene un nombre, una cantidad de
parmetros a pasar y un valor de salida o ms
65
La Cita Extendida
Declaracin de los servicios
task Control_Nivel is
entry Iniciar_Control;
entry Terminar_Control;
end Control_Nivel;
Cada servicio
es atendido en
un accept
Implementacin tarea
task body Control_Nivel is
begin
....
accept Iniciar_Control;
....
accept Terminar_Control;
....
end Control_Nivel;
66
La Cita Extendida
Para que se produzca la comunicacin debe darse la
cita:
tareas
cliente
servidor
servidor
ejecucin
bloqueo
accept
cita
accept
t
67
La Cita Extendida
Ejemplo: calculadora
task Servicio_Calculadora is
entry Suma (S1, S2: Integer; S : out Integer);
entry Resta (M, S: Integer; R : out Integer);
end Calculadora;
begin
Servicio_Calculadora.Suma(A, B, C);
exception
when Tasking_Error =>
-- El servidor ha terminado?
...
end;
Tarea llamante
68
La Cita Extendida
task body Servicio_Calculadora is
...
begin
-- Inicializacin del servicio
loop
select
accept Suma (S1, S2: Integer; S : out Integer) do
...
end Suma;
or
accept Resta (M, S: Integer; R : out Integer) do
...
end Resta;
end select;
end loop;
end Servicio_Calculadora;
69
La Cita Extendida
entryCOUNT es un atributo de la entrada que permite
conocer el nmero de tareas esperando en la cola de
peticiones
task Sensor is
begin
loop
accept Leer_Canal(1)(X: out Valor) do
Familia de entry
-- accede al sensor del canal 1
end Leer_Canal;
.......
accept Leer_Canal(2)(X: out Valor) do
-- accede al sensor del canal 2
task Sensor is
end Leer_Canal;
entry Leer_Canal(1..5)(X: out Valor);
.......
end Sensor;
end Sensor;
70
Seleccin indeterminista
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
else
...
end select
Permite ofrecer(acceder) distintos servicios al mismo

tiempo, slo se acepta uno de ellos (el primero en
llegar)
La clusula select puede usarse tanto en la aceptacin
de las llamadas en los servidores, como en las
llamadas de los clientes
En el servidor permite:
esperar ms de una cita en un momento de tiempo
temporizar la espera
dejar de ofrecer los servicios si no hay ninguna cita
posible
terminar la tarea si no hay clientes
71
Formas de select
select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
else
...
end select
when No_Vacia =>

accept Sacar_Item(Elmt : out Integer) do
Seleccionar_Ventana(0);
Sacar(Mi_Cola1, Elmt);
Anyadir(Mi_Cola2, Elmt);
end Sacar_Item;
or
when No_Llena =>
accept Anyadir_Item(Elmt : Integer) do
end Anyadir_Item;
end select;
72
Formas de select
select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
else
...
end select
when No_Vacia =>

accept Sacar_Item(Elmt : out Integer) do
Sacar(Mi_Cola1, Elmt);
end Sacar_Item;
or
when No_Llena =>
accept Anyadir_Item(Elmt : Integer) do
end Anyadir_Item;
else
-- realizar tareas de mantenimiento
end select;
73
Formas de select
select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
or
terminate
...
end select
when No_Vacia =>
or
when No_Llena =>
..
or
terminate;
end select;
Permite sincronizar la terminacin de las tareas para que terminen de forma

conjunta.
74
Formas de select
select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
or
delay tiempo
end select
when No_Vacia =>
or
when No_Llena =>
..
or
delay 2.0;
end select;
Espera temporizada.
Limita el tiempo de bloqueo en espera de la cita.
75
Formas de select
loop
select
[Guarda]
Tarea1.servicio1;
or
[Guarda ]
Tarea2.servicio2;
else
...
end select
Dibujar_Agente(Pid, 1, 0);
I := I + 1;
delay Espera * Factor;
Item := Item + 1;
select
Gestor_Cola.Anyadir_Item(Item);
or
end select;
delay 0.5 * Factor;
end loop;
76
Formas de select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
else
...
end select
loop
I := I + 1;
delay Espera * Factor;
Item := Item + 1;
select
Gestor_Cola1.Anyadir_Item(Item);
or
Gestor_Cola2.Anyadir_Item(Item);
else
Put(No he podido aadir);
end select;
delay 0.5 * Factor;
end loop;
77
Formas de select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
or
terminate
...
end select
loop
.
select
or
terminate;
end select;
..
end loop;
Permite sincronizar la terminacin de las tareas para que terminen de forma

conjunta.
78
Formas de select
select
[Guarda]
<Alternativa_1>
or
[Guarda ]
<Alternativa_2>
or
delay tiempo
end select
loop
.
select
or
delay 5.0;
end select;
..
end loop;
Espera temporizada.
Limita el tiempo de bloqueo en espera de la cita.
79
Conclusiones
n
Se han visto los siguientes conceptos:

q
q
q
Procesos y Tareas
Tareas en Ada
Tipo Tarea
Se han visto los mecanismos de

comunicacin y sincronizacin de tareas:
q
q
Tipos protegidos
Mensajes
80

Sitra Tema3

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Sitra Tema3

Caricato da

Copyright:

Formati disponibili

Sistemas Informticos de Tiempo Real

Tema 3: Programacin concurrente

Sistemas Informticos de tiempo real.

por memoria compartida

por paso de mensajes

Sistemas Informticos de tiempo real.

La programacin concurrente no es el modelo comn de

Sistemas Informticos de tiempo real.

Multiplexando sus ejecuciones en un solo procesador

Solo en el segundo y tercer caso existe paralelismo real

Sistemas Informticos de tiempo real.

Un proceso es una unidad de ejecucin que tienen un

Sistemas Informticos de tiempo real.

Procesos: Ciclo de Vida

Un proceso es un elemento dinmico del sistema, y

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

PCB: conjunto de atributos que le caracterizan y describen a un

Se crea uno por cada proceso en el sistema

Informacin de tres tipos:

Sistemas Informticos de tiempo real.

Para conseguir la ejecucin concurrente de los procesos en el

Esto significa intercambiar los valores que caracterizan y

Esta operacin interesa que sea breve

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

Concurrencia en lenguajes de programacin

La concurrencia puede estar soportada por el

Ada y Java tienen concurrencia

Distintos modelos de concurrencia segn lenguajes

Sistemas Informticos de tiempo real.

Cmo se ejecutan las tareas

La poltica de planificacin define la

Secuencial: un proceso no accede a la CPU

Adems pueden ser expulsivos o no

Sistemas Informticos de tiempo real.

Planificacin: Turno de llegada

(FCFS, First came first served)

Sistemas Informticos de tiempo real.

Planificacin: turno rotatorio

Los procesos se ejecutan

Sistemas Informticos de tiempo real.

Planificador basado en prioridades

Primero el que ms prioridad tiene

Sistemas Informticos de tiempo real.

Planificacin de sistemas de tiempo real

Sistemas Informticos de tiempo real.

Concurrencia en ADA: Tareas

Ada permite la programacin de actividades concurrentes.

Sistemas Informticos de tiempo real.

Concurrencia en ADA: Tareas

Denicin de tarea: task P;

Sistemas Informticos de tiempo real.

Tareas: Ejemplo Bsico

Tareas: Ejemplo Bsico

Tareas: Ejemplo Bsico

Sistemas Informticos de tiempo real.

task body Productor is

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.

Sistemas Informticos de tiempo real.