PCTR T4 Otros Mecanismos Sincronizacion

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

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


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

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


Monitores
TAD con operaciones en exclusin mutua
Encapsulacin
Normalmente manejan una cola FIFO interna
No hay espera activa

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

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

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

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

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

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

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

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

Monitores en POSIX
for (i = 0; i < NUM_THREADS; i++) {

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

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

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

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


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

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

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;

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;

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

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;

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

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;

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;


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

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

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


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;


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;


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;


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


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;


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;

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

PCTR T4 Otros Mecanismos Sincronizacion

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PCTR T4 Otros Mecanismos Sincronizacion

Uploaded by

Copyright:

Available Formats

Programacin Concurrente y

Tema 4. Otros Mecanismos de Sincronizacin

Escuela Superior de Informtica

Curso 2016/2017 Grado en Ingeniera Informtica

Curso 2016/2017 Grado en Ingeniera Informtica

Curso 2016/2017 Grado en Ingeniera Informtica

T4 Otros Mecanismos de Sincronizacin Trp 4

T4 Otros Mecanismos de Sincronizacin Trp 5

Curso 2016/2017 Grado en Ingeniera Informtica

No hay espera activa

T4 Otros Mecanismos de Sincronizacin Trp 7

T4 Otros Mecanismos de Sincronizacin Trp 8

T4 Otros Mecanismos de Sincronizacin Trp 9

Ejemplo del buffer limitado con monitores

T4 Otros Mecanismos de Sincronizacin Trp 10

T4 Otros Mecanismos de Sincronizacin Trp 11

T4 Otros Mecanismos de Sincronizacin Trp 12

void Buffer::produce(int item) {

// Update the buffer state

T4 Otros Mecanismos de Sincronizacin Trp 13

// Acquire the mutex for mutual exclusion

// Update the buffer state

T4 Otros Mecanismos de Sincronizacin Trp 14

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

// Create the threads

T4 Otros Mecanismos de Sincronizacin Trp 15

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

T4 Otros Mecanismos de Sincronizacin Trp 16

static void *producer_func (void *arg) {

while (i < 10) {

T4 Otros Mecanismos de Sincronizacin Trp 17

static void *consumer_func (void *arg) {

while (i < 10) {

T4 Otros Mecanismos de Sincronizacin Trp 18

T4 Otros Mecanismos de Sincronizacin Trp 19

Curso 2016/2017 Grado en Ingeniera Informtica

T4 Otros Mecanismos de Sincronizacin Trp 21

Ada 95: Un programa en Ada

Se compila mediante el comando gnatmake

T4 Otros Mecanismos de Sincronizacin Trp 22

Ada 95. Tareas

T4 Otros Mecanismos de Sincronizacin Trp 23

Ada 95. Lanzamiento de tareas

with Ada.Text_IO; use Ada.Text_IO;

T4 Otros Mecanismos de Sincronizacin Trp 24

Ada 95. Tareas

T4 Otros Mecanismos de Sincronizacin Trp 25

Ada 95. Sincronizacin (citas)

Llamada desde otra tarea:

Bloqueante en llamada y en ejecucin.

Bloqueante hasta que alguien la llame.

accept E (N: Integer) do

T4 Otros Mecanismos de Sincronizacin Trp 26

T4 Otros Mecanismos de Sincronizacin Trp 27

T4 Otros Mecanismos de Sincronizacin Trp 28

T4 Otros Mecanismos de Sincronizacin Trp 29

Curso 2016/2017 Grado en Ingeniera Informtica

T4 Otros Mecanismos de Sincronizacin Trp 31

T4 Otros Mecanismos de Sincronizacin Trp 32

Filsofos con objetos protegidos

T4 Otros Mecanismos de Sincronizacin Trp 33

Filsofos con objetos protegidos

procedure Get(C: in out Stick); Procedimientos

type TState is (FREE, TAKEN);

static void producer_func (void arg) {

static void consumer_func (void arg) {