You are on page 1of 41

Programacin Concurrente y

Tiempo Real

Tema 4. Otros Mecanismos de Sincronizacin


D. Vallejo, M.A. Redondo, C. Villarrubia,
F.J. Villanueva, J. Ruiz

Escuela Superior de Informtica


Universidad de Castilla-La Mancha

Curso 2016/2017 Grado en Ingeniera Informtica


Tema 4. Otros Mecanismos de Sincronizacin

1. Introduccin [Burns 8]
2. Monitores [Burns 8]
3. Concurrencia en Ada 95 [Burns 7, Burns 9]
4. Objetos Protegidos [Burns 8, Burns 11]

Curso 2016/2017 Grado en Ingeniera Informtica


Tema 4. Otros Mecanismos de Sincronizacin

1. Introduccin [Burns 8]
2. Monitores [Burns 8]
3. Concurrencia en Ada 95 [Burns 7, Burns 9]
4. Objetos Protegidos [Burns 8, Burns 11]

Curso 2016/2017 Grado en Ingeniera Informtica


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Introduccin
Semforos
Son variables globales
Son 'engorrosos'
Conceptualmente de bajo nivel
Flexibles pero poco escalables

Error-prone

Paso de mensajes
No modela, de forma natural, el acceso a un
recurso compartido
Bajo nivel

T4 Otros Mecanismos de Sincronizacin Trp 4


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Introduccin
Semforos, v.m.c., mensajes Llamadas al SO
Lenguajes que no necesitan del SO
Mecanismos ms avanzados y de alto nivel
En este tema...
Monitores
Ada 95 y su modelo de tareas
Objetos protegidos

T4 Otros Mecanismos de Sincronizacin Trp 5


Tema 4. Otros Mecanismos de Sincronizacin

1. Introduccin [Burns 8]
2. Monitores [Burns 8]
3. Concurrencia en Ada 95 [Burns 7, Burns 9]
4. Objetos Protegidos [Burns 8, Burns 11]

Curso 2016/2017 Grado en Ingeniera Informtica


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores
TAD con operaciones en exclusin mutua
Encapsulacin
Normalmente manejan una cola FIFO interna

No hay espera activa

T4 Otros Mecanismos de Sincronizacin Trp 7


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores
Slo un proceso activo en cada momento
La exclusin mutua la genera el compilador
Generalmente mediante semforos
Bloqueo dentro del monitor
Ejemplo: Productor/Consumidor
Productor inserta y buffer est lleno
Antes interbloqueo

T4 Otros Mecanismos de Sincronizacin Trp 8


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Variables de Condicin
Operativa
Sobre las cuales los procesos ejecutan wait y signal
Bloqueo con wait
Otro proceso puede entrar en el monitor
Desbloqueo con signal sobre variable de condicin
Asocia variable de condicin sobre cualquier
seal que permite bloqueo/desbloqueo
Ej. variable espacio_libre en el productor/consumidor

T4 Otros Mecanismos de Sincronizacin Trp 9


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX
Biblioteca Pthreads
Necesarios mecanismos para exclusin mutua y

la sincronizacin
Mutex
Variables de condicin

Ejemplo del buffer limitado con monitores


Tamao del buffer

1 7 3

primero ltimo

T4 Otros Mecanismos de Sincronizacin Trp 10


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

class Buffer {
public:
Buffer();
~Buffer();
void produce(int item);
int consume();

private:
int _n_data;
int _first, _last;
int _data[MAX_SIZE];

pthread_mutex_t _mutex;
pthread_cond_t _buffer_not_full;
pthread_cond_t _buffer_not_empty;
};

T4 Otros Mecanismos de Sincronizacin Trp 11


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX
Constructor/Destructor
Buffer::Buffer():
_n_data(0), _first(0), _last(0)
{
pthread_mutex_init(&_mutex, NULL);
pthread_cond_init(&_buffer_not_full, NULL);
pthread_cond_init(&_buffer_not_empty, NULL);
}

Buffer::~Buffer()
{
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_buffer_not_full);
pthread_cond_destroy(&_buffer_not_empty);
}

T4 Otros Mecanismos de Sincronizacin Trp 12


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

void Buffer::produce(int item) {


// Acquire the mutex for mutual exclusion
pthread_mutex_lock(&_mutex);
// Control overflows
while (_n_data == MAX_SIZE) {
// Synchronization
pthread_cond_wait(&_buffer_not_full, &_mutex);
}

// Update the buffer state


_data[_last % MAX_SIZE] = item;
++_last;
++_n_data;

// Synchronization
pthread_cond_signal(&_buffer_not_empty);

pthread_mutex_unlock(&_mutex);
}

T4 Otros Mecanismos de Sincronizacin Trp 13


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

int Buffer::consume() {
int item;

// Acquire the mutex for mutual exclusion


pthread_mutex_lock(&_mutex);
while (_n_data == 0) { // Empty buffer?
// Synchronization
pthread_cond_wait(&_buffer_not_empty, &_mutex);
}

// Update the buffer state


item = _data[_first % MAX_SIZE];
++_first; --_n_data;

pthread_cond_signal(&_buffer_not_full); // Synchronization
pthread_mutex_unlock(&_mutex);

return item;
}

T4 Otros Mecanismos de Sincronizacin Trp 14


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX
Create
static void *producer_func (void *arg); threads
static void *consumer_func (void *arg);

int main (int argc, char *argv[]) {


Buffer *buffer = new Buffer;
pthread_t tids[NUM_THREADS];
int i;
srand((int)getpid());

// Create the threads


for (i = 0; i < NUM_THREADS; i++)
if ((i % 2) == 0)
pthread_create(&tids[i], NULL, producer_func, buffer);
else
pthread_create(&tids[i], NULL, consumer_func, buffer);

T4 Otros Mecanismos de Sincronizacin Trp 15


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

for (i = 0; i < NUM_THREADS; i++) {


pthread_join(tids[i], NULL);
}
Wait for
the children

T4 Otros Mecanismos de Sincronizacin Trp 16


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

static void *producer_func (void *arg) {


Buffer *buffer = (Buffer *)arg;
int i = 0, item;

while (i < 10) {


sleep(rand() % 2);
item = rand() % 10;
buffer->produce(item);
std::cout << "[Producer " << pthread_self()
<< "]:\t" << item << std::endl;
++i;
}
return (void *)true;
}

T4 Otros Mecanismos de Sincronizacin Trp 17


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Monitores en POSIX

static void *consumer_func (void *arg) {


Buffer *buffer = (Buffer *)arg;
int i = 0, item;

while (i < 10) {


sleep(rand() % 5);
item = buffer->consume();
std::cout << "[Consumer " << pthread_self()
<< "]:\t" << item << std::endl;
++i;
}
return (void *)true;
}

T4 Otros Mecanismos de Sincronizacin Trp 18


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Crticas
No soluciona bien las sincronizaciones de condicin
fuera del monitor
Crticas de los semforos aplicables a variables de
condicin
Cuidado! Slo un proceso activo dentro del monitor
(signal como ltima instruccin)
Cdigo menos legible con variables de condicin

T4 Otros Mecanismos de Sincronizacin Trp 19


Tema 4. Otros Mecanismos de Sincronizacin

1. Introduccin [Burns 8]
2. Monitores [Burns 8]
3. Concurrencia en Ada 95 [Burns 7, Burns 9]
4. Objetos Protegidos [Burns 8, Burns 11]

Curso 2016/2017 Grado en Ingeniera Informtica


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

ADA
OO, fuertemente tipado, multi-propsito y gran
soporte concurrencia
Sistemas de tiempo real crticos muy fiables y
mantenibles
Estructuras propias del lenguaje
Concurrencia; Sincronizacin; Tiempo Real
Cuatro versiones: 83, 95, 2005 y 2012
Necesidades expresadas por la industria

T4 Otros Mecanismos de Sincronizacin Trp 21


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Ada 95: Un programa en Ada


Hola Mundo! Procedimiento ppal (ejecutable)
with Text_IO; use Text_IO;
Estructura de archivos: .ads
procedure hello is
begin (declaracin) .adb (implementacin)
Put_Line(Hello World);
end holamundo; Funciones, procedimientos y
paquetes son unidades de
compilacin
Para compilar se usa el compilador GNAT
$sudoaptgetinstallgnat

Se compila mediante el comando gnatmake


$gnatmakehello.adb

T4 Otros Mecanismos de Sincronizacin Trp 22


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Ada 95. Tareas


Tarea T
task [type] T;

task body T is
a:Duration := Duration(4);
ID_T:Task_Id := Null_Task_Id;
begin
ID_T := Current_Task;
loop
delay a;
Put("I am the task ");
Put_Line(Image(ID_T));
end loop;
end T;

T4 Otros Mecanismos de Sincronizacin Trp 23


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Ada 95. Lanzamiento de tareas


Variable del tipo tarea
Activacin automtica
El procedimiento espera a sus tareas

with Ada.Text_IO; use Ada.Text_IO;


with Ada.Task_Identification;
use Ada.Task_Identification;

procedure tasks is
- Definition of the previous slide
F:T; -- Variable of T class
X:T; -- Another task
begin
null;
end tasks;

T4 Otros Mecanismos de Sincronizacin Trp 24


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Ada 95. Tareas


Tareas dinmicas mediante punteros (access) y
la sentencia new
Existen atributos asociados a las tareas...
Variable_Tarea'Callable indica falso si la tarea est
completada o terminada, en otro caso (ejecutndose o
suspendida), verdadero.
Variable_Tarea'Terminated indica verdadero si la
tarea ha terminado.
Para terminar abort

T4 Otros Mecanismos de Sincronizacin Trp 25


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Ada 95. Sincronizacin (citas)


Se declara en la especificacin:
task T is Punto de entrada,
entry E(N: Integer); con argumentos, como
end;
un procedimiento.

Llamada desde otra tarea:


T.E(6);

Bloqueante en llamada y en ejecucin.


El cuerpo de entrada (accept) se define en el cuerpo de la tarea.

Bloqueante hasta que alguien la llame.

accept E (N: Integer) do


-- Sentences
end E;

T4 Otros Mecanismos de Sincronizacin Trp 26


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Problema Productor/Consumidor
Modelo del buffer
task Buffer is
entry Write(D: Data);
entry Read(D: out Data);
end Buffer;

T4 Otros Mecanismos de Sincronizacin Trp 27


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Problema Productor/Consumidor
Modelo del buffer
task body Buffer is Estructura potente en Ada.
ElemLocal : Data; Espera de forma
begin concurrente cualquiera de los
entry (evita bloqueo
loop en un slo accept)
select
accept Write(D: Data) do
ElemLocal := D; -- Store the element
end Write;
or
accept Read(D: out Dato) do
D := ElemLocal; -- Get the element
end Read;
end select;
end loop;
end Buffer;

T4 Otros Mecanismos de Sincronizacin Trp 28


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Problema Productor/Consumidor
Modelo del buffer limitado
task body Buffer is
MaxSize: constant := 100
Data: array(1..MaxSize) of TElement;
i,j: integer range 1..MaxSize := 1;
NData: integer range 0..MaxSize := 0;
begin
loop
select when NData < MaxSize =>
accept Write(D: TElement) do
Data(i) := D;
end Write;
i := i mod MaxSize + 1;
NData := NData + 1;
or when NData > 0 =>
accept Read(D: TElement) do
D := Data(j);
end Read;
j := j mod N+1;
NData := NData - 1;
end select;
end loop;
end Buffer;

T4 Otros Mecanismos de Sincronizacin Trp 29


Tema 4. Otros Mecanismos de Sincronizacin

1. Introduccin [Burns 8]
2. Monitores [Burns 8]
3. Concurrencia en Ada 95 [Burns 7, Burns 9]
4. Objetos Protegidos [Burns 8, Burns 11]

Curso 2016/2017 Grado en Ingeniera Informtica


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Objetos Protegidos
Tipo especfico de Ada
Permite definir estructuras complejas privadas
(accesibles mediante procedimientos, funciones
o entradas)
Definen guardas o barreras en las definiciones
de las entradas
Ms fciles de entender e implementar
Guarda o barrera: condicin que se debe
cumplir para que el proceso entre en el
procedimiento
Exclusin mutua en la llamada al procedimiento
Bloqueos en la guarda

T4 Otros Mecanismos de Sincronizacin Trp 31


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Objetos Protegidos
Procedimientos, funciones y entradas
Elementos del lenguaje (no llamadas al SO)
Procedimientos proporcionan exclusin mutua
Funciones permiten acceso concurrente
Para operaciones de slo lectura
Mantienen exclusin mutua con procedimientos
E.j. lectura concurrente pero escritura en exclusin
mutua
Entradas. Procedimientos con barreras
booleanas
Exclusin mutua y adems condicin de barrera

T4 Otros Mecanismos de Sincronizacin Trp 32


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos

T4 Otros Mecanismos de Sincronizacin Trp 33


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Objeto protegido Stick
package Sticks is
Encapsulacin
type Stick is limited private;

procedure Get(C: in out Stick); Procedimientos


procedure Drop(C: in out Stick); pblicos
private

type TState is (FREE, TAKEN);

protected type Stick(Stick_State: TState := FREE) is


entry Get;
entry Drop;
private Tipo
State: TState := Stick_State; protegido
end Stick;

end Sticks;
http://es.wikibooks.org/wiki/Programacion_en_Ada/Tareas/Ejemplos

T4 Otros Mecanismos de Sincronizacin Trp 34


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Cuerpo objeto protegido Stick
package body Sticks is

procedure Get(C: in out Stick) is


begin
C.Get;
end Get;

procedure Drop(C: in out Stick) is


begin
C.Drop;
end Drop;

T4 Otros Mecanismos de Sincronizacin Trp 35


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Cuerpo objeto protegido Stick
protected body Stick is
entry Get when State = FREE is
begin
State := TAKEN;
end Get;

entry Drop when State = TAKEN is


begin
State := FREE;
end Drop;

end Stick;

end Sticks;

T4 Otros Mecanismos de Sincronizacin Trp 36


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Philosopher
type PStick is access Stick; -- Pointer
task type TPhilosopher(Id: Character;
Stick1: PStick; Stick2 : PStick);

task body TPhilospher is Objeto protegido


procedure Eat is gestiona
begin concurrencia
Get(Stick1.all);
Get(Stick2.all);
put(Id & c );
delay 1.0; -- eating...
Drop(Stick1.all);
Drop(Stick2.all);
end Eat;

T4 Otros Mecanismos de Sincronizacin Trp 37


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Philosopher
procedure Think is
begin
put(Id & p );
delay 3.0; -- thinking...
end Think;

begin
loop
Eat;
Think;
end loop;

end TPhilosopher;

T4 Otros Mecanismos de Sincronizacin Trp 38


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Modelado del problema
begin
Put("Number of philosophers: ");
Get(Num_Sticks); New_line;

declare
type PTPhilosopher is access TPhilosopher;
P: PTPhilosopher;
C: Character := 'A';
StickList: array (1..Num_Sticks)
of PStick;

T4 Otros Mecanismos de Sincronizacin Trp 39


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Filsofos con objetos protegidos


Modelado del problema
begin
-- Create the sticks
for i in 1..Num_Sticks loop
StickList(i) := new Stick;
end loop;
-- Create the philosophers
for i in 1..Num_Sticks - 1 loop
P := new TPhilosopher(C,
StickList(i), StickList(i+1));
C := Character'Succ(C);
end loop;
P := new TPhilosopher(C, StickList(1),
StickList(Num_Sticks));
end;
end Philosophers;

T4 Otros Mecanismos de Sincronizacin Trp 40


Intro | Monitores | Concurrencia en Ada 95 | Objetos Protegidos

Barreras booleanas
Cundo se evala una barrera para saber si se
ha cambiado su estado?
Se desbloquean las tareas bloqueadas en ella?
Se evalan siempre que...
Nueva tarea evala la barrera y sta hace
referencia a una variable o atributo relevante.
Tarea abandona procedimiento o entrada y hay
tareas bloqueadas en barreras que referencian a
variables o atributos relevantes
No puedes usar variables globales en barreras
ni ejecutar operaciones potencialmente
bloqueantes

T4 Otros Mecanismos de Sincronizacin Trp 41