seminario de lenguajes a – opción ada

Seminario de Lenguajes A – Opción Ada

Seminario de Lenguajes A – Opción Ada – Raúl Champredonde 1

• Hasta ahora:– Un conjunto de instrucciones que

se ejecutan una después de otra• Existe otra posibilidad:

– Varios conjuntos de instruccionesejecutando al mismo tiempo

– Concurrencia y paralelismo• En Ada, el mecanismo de especificación de

concurrencia se llama TASK (tarea)• Un task es una entidad que se ejecuta

simultáneamente con el resto del programa

Tasking


• Task– Especificación

• Declara la parte visible desde el exterior

• Define cuáles son los “servicios” que provee

– Cuerpo• Determina el comportamiento

de la tarea

task Nombre;

task Nombre is -- entriesend Nombre;

task body Nombre is -- declaracionesbegin Sentencias;end Nombre;

Seminario de Lenguajes A – Opción Ada Tasking


• Ejemplo:– sumar los elementos de las columnas de una

matriz deenteros generando un vector de enteros

subtype Filas is integer range 1..7;subtype Columnas is integer range 1..5;type Vector is array (Columnas) of integer;type Matriz is array (Filas) of Vector;----------------------------------M: Matriz := (others => (others => 1));V: Vector := (others => 0);----------------------------------task Sumador1;task body Sumador1 isbegin for I in Filas loop V(1) := V(1) + M(I)(1); end loop;end Sumador1;

X X ... X

X X ... X

... ... ... ...

X X ... X

Y Y Y Y



• Si se precisan varias variables array, entonces se define un tipo array

• De igual manera, si se precisan varias tareas iguales, entonces se define un “tipo tarea”

• Ejemplo:– Programa y tareas que escriben “Hola Mundo”

task type Tarea;

task body Tarea isbegin Put_Line("Hola Mundo 1 (Tarea)"); Put_Line("Hola Mundo 2 (Tarea)"); Put_Line("Hola Mundo 3 (Tarea)");end Tarea;



• Ejemplo: Trenes– 2 Trenes

• Para entrar al cruce, cada tren debepedir permiso al guarda barrera

• Al salir del cruce, el tren debeavisar al guarda barrera

– 1 Guarda barrera• Publica 2 servicios

– Pedido de permiso para entrar al cruce– Aviso de salida del cruce



• Ejemplo: Trenes

task type Tren;

task GuardaBarrera is entry EntrarAlCruce; entry SalirDelCruce;end GuardaBarrera;

Tren1: Tren;Tren2: Tren;

task body Tren isbegin loop -- girando GuardaBarrera.EntrarAlCruce; -- pasando por el cruce GuardaBarrera.SalirDelCruce; -- salío del cruce end loop; end Tren;

task body GuardaBarrera isbegin loop accept EntrarAlCruce; accept SalirDelCruce; end loop;end GuardaBarrera;



• Los entries pueden tener parámetrosCantTrenes: constant integer := 5;subtype TrenId is integer range 1..CantTrenes;

task type Tren is entry Identificacion(Id: in TrenId);end Tren; task GuardaBarrera is entry EntrarAlCruce(Id: in TrenId); entry SalirDelCruce(Id: in TrenId);end GuardaBarrera;

Trenes: array (TrenId) of Tren;



• Los entries pueden tener parámetrostask body Tren is MiId: TrenId;begin accept Identificacion(Id: in TrenId) do MiId := Id; end Identificacion; loop -- girando GuardaBarrera.EntrarAlCruce(MiId); -- pasando por el cruce GuardaBarrera.SalirDelCruce(MiId); -- salío del cruce end loop;end Tren;



• Los entries pueden tener parámetrostask body GuardaBarrera isbegin loop accept EntrarAlCruce(Id: in TrenId) do Put("Entro al cruce "); Put(Id); end EntrarAlCruce; accept SalirDelCruce(Id: in TrenId) do Put(" Salio del cruce "); Put(Id); New_Line; end SalirDelCruce; end loop;end GuardaBarrera;



• Los entries pueden tener parámetroswith Text_IO;use Text_IO;procedure Clase9_Trenes2 is

.......

begin for I in TrenId loop Trenes(I).Identificacion(I); end loop;end Clase9_Trenes2;



• Rendezvouz (primero entry call)

Running asynchronously

RequestorSuspended Suspended



Running synchronously


Entrycall

Acceptstatement

Server

Rendezvouz



• Rendezvouz (primero accept)


Requestor

Suspended

SuspendedRunning

asynchronously



Acceptstatement

Server

Entrycall

Rendezvouz


Running synchronously


• Estados de ejecución de las tareas

Executing Suspended

Completed

Terminated

Activation

Reach endof task body

Dependenttasks terminated

Delay completeRendezvouz complete

Rendezvouz starts

Delay statementWait for accept

Wait for entry call



• Los recursos compartidos entre tareas deberían ser administrados (ej: variable compartida)

task CountingTask is entry Add(Amount: in integer);end CountingTask;

task body CountingTask is Runningtotal: integer := 0;begin loop accept Add(Amount: in integer) do Runningtotal := Runningtotal + Amount; end Add; end loop;end CountingTask;



• Si pueden llegar dos posibles entries call => Selective accept

task CountingTask is entry Add(Amount: in integer); entry CurrentTotal(Total: out integer);end CountingTask;

task body CountingTask is RunningTotal: integer := 0;begin loop select accept Add(Amount: in integer) do RunningTotal := RunningTotal + Amount; end Add; or accept CurrentTotal(Total: out integer) do Total := RunningTotal; end CurrentTotal; end select; end loop;end CountingTask;



• Guarda: un entry call se acepta o no según una condición

task CountingTask is entry Add(Amount: in integer); entry CurrentTotal(Total: out integer);end CountingTask;

task body CountingTask is RunningTotal: integer := 0;begin loop select when RunningTotal > 1000 then accept Add(Amount: in integer) do RunningTotal := RunningTotal + Amount; end Add; or accept CurrentTotal(Total: out integer) do Total := RunningTotal; end CurrentTotal; end select; end loop;end CountingTask;



• Alternativa accept

task T1 is entry A; entry B; entry C; entry D;end T1;

-- A y B se aceptan siempre-- C se acepta si el último fue A-- D se acepta si el último fue B o C

task body T1 is Ult: character := 'B';begin select accept A do Ult := 'A'; end A; or accept B; Ult := 'B'; or when Ult = 'A' => accept C; Ult := 'A'; or when Ult = 'B' => accept D; Ult := 'D'; or when Ult = 'C' => accept D; Ult := 'C'; end select;end T1;



• Más alternativas del select: temporizada

select accept A do Ult := 'A'; end A;or accept B; Ult := 'B';or when Ult = 'A' => accept C; Ult := 'A';

or when Ult = 'B' => accept D; Ult := 'D';or when Ult = 'C' => accept D; Ult := 'C';or delay 1.1; Ult := 'A';or when Ult = 'A' => delay 0.5; Ult := 'B';end select;



• Más alternativas del select: else


or when Ult = 'B' => accept D; Ult := 'D';or when Ult = 'C' => accept D; Ult := 'C';else Ult := 'A';end select;



• Más alternativas del select: terminación


or when Ult = 'B' => accept D; Ult := 'D';or when Ult = 'C' => accept D; Ult := 'C';or when Ult = 'A' => terminate;end select;



• Resumen sintáctico del selectselective_accept ::= select [guard] select_alternative {or [guard] select_alternative} [else sequence_of_statements] end select;guard ::= when condition =>select_alternative ::= accept_alternative | delay_alternative | terminate_alternative

accept_alternative ::= accept_statement [sequence_of_statements]


delay_alternative ::= delay_statement [sequence_of_statements]

terminate_alternative ::= terminate;accept_statement ::=accept entry_name [parameters] [do sequence_of_statementsend [entry_identifier]];delay_statement ::= delay_until_statement | delay_relative_statement

delay_until_statement ::= delay until duration_type_value;delay_relative_statement ::= delay time_type_value;


• Hasta acá => selective accept• Pero en realidad, las sentencias select

tienen tres formas distintas:

select_statement ::=selective_accept |conditional_entry_call |timed_entry_call



• Conditional entry calls– Si el entry call no es aceptado inmediatamente, se cancela y

se ejecutan las sentencias del else


select entry_name [actual_parameter_part]; [sequence_of_statements]else sequence_of_statementsend select;

loop select R.Seize; exit; else I := I + 1; end select;end loop;


• Timed entry calls– Se ejecuta el entry call el cual es cancelado si no es

aceptado antes de la expiración del tiempo. Si el tiempo expira, se ejecutan las sentencias del or delay


select entry_name [actual_parameter_part]; [sequence_of_statements]or delay_statement [sequence_of_statements]end select;

select Maquinista.Despierto;or delay 30.0; -- el maquinista se -- debe haber dormido Tren.Frenar;end select;

delay_statement ::= delay_until_statement | delay_relative_statement

delay_until_statement ::= delay until duration_type_value;delay_relative_statement ::= delay time_type_value;


• Atributos de tareas y entries– Siendo T una tarea:

• T’Callable: true si es callable y false si no. Una tarea es callable a menos que esté completada o haya terminado anormalmente

• T’Terminated: true si T está terminada, false en caso contrario

– Siendo E un entry de una tarea:• E’Count: cantidad de entry calls encolados en el entry

E



• Concurrencia. Conceptos– Deadlock: abrazo mortal

• Un subconjunto de procesos no puede continuar su ejecución pues cada uno de ellos espera por un evento que sólo puede producir otro de ellos

– Inanición• En la competencia entre procesos por obtener acceso

exclusivo a algún recurso, siempre resulta perjudicado el mismo proceso

– Fairness• Acceso equilibrado o equitativo a los recursos



• Problemas clásicos: Filósofos– Problema

• Propuesto por Dijkstra en 1965• Una mesa con 5 plato y 5 palillos• Alrededor de la mesa, 5 filósofos generalmente

piensan, pero cada tanto les agarra hambre• Para comer necesitan los 2 palillos

– Primera solución• Tomar el palillo derecho y luego el izquierdo

=> Posible deadlock



• Familia de entries– entry identifier [(discrete_subtype)][parameters];


type Enum is (Uno, Dos, Tres);

task NTask is entry NEntry(Enum)(P: in integer);end NTask;

task NTask isbegin ... accept NEntry(Uno)(P: in integer) do ... end NEntry; ... accept NEntry(Dos)(P: in integer) do ... end NEntry;...end Ntask;

Variable: Enum;begin ... NTask.NEntry(Uno)(10); ... NTask.NEntry(Variable)(9); ...End;


• Problemas clásicos: Filósofos– Otra solución: con familia de entries


task Tenedores is entry Tomar(TId); entry Devolver(Id: in TId);end Tenedores;select when Libres(0) and Libres(1) => accept Tomar(0); Libres(0) := false; Libres(1) := false;or ...or accept Devolver(Id: in TId) do Libres(Id) := true; Libres((Id + 1) mod 5) := true; end Devolver;end select;

-- pensandoTenedores.Tomar(MiId);-- comiendoTenedores.Devolver(MiId);


• Problemas clásicos: Lectores y Escritores– Problema

• Propuesto por Courtois en 1971• Control de acceso a base de datos compartida por

procesos lectores y procesos escritores– Pueden acceder varios lectores simultáneamente– Un escritor accede en forma exclusiva con respecto tanto a

los lectores como a los escritores

– Primera aproximación• Administrador de acceso

– Permiso a lectores si no hay escritor accediendo– Permiso a escrito si no hay lectores ni otro escritor

accediendo



• Problemas clásicos: Lectores y EscritoresSeminario de Lenguajes A – Opción Ada Tasking

task type Lector(Ident: TIdLect); task body Lector isbegin loop ... Admin.ComLect(Ident); ... Admin.TerLect(Ident); end loop;end Lector;

task type Escritor(Ident: TIdEscr); task body Escritor isbegin loop ... Admin.ComEscr(Ident); ... Admin.TerEscr(Ident); end loop;end Escritor;


• Problemas clásicos: Lectores y EscritoresSeminario de Lenguajes A – Opción Ada Tasking

task Admin is entry ComLect(Id: in TIdLect); entry ComEscr(Id: in TIdEscr); entry TerLect(Id: in TIdLect); entry TerEscr(Id: in TIdEscr);end Admin;

task body Admin is Leyendo: Natural := 0; Escribiendo: boolean := false;begin

end Admin;

loop select when not Escribiendo => accept ComLect; Leyendo := Leyendo + 1; or when Leyendo = 0 and not Escribiendo => accept ComEscr; Escribiendo := true; or accept TerLect; Leyendo := Leyendo - 1; or accept TerEscr; Escribiendo := false; end select;end loop;


• Problemas clásicos:Lectores y Escritores– Con la primera

aproximación losescritores pueden sufrir de inanición

– Segunda aproximación• Se incorpora un “turno”


select when not Escribiendo and TurnoLectores => accept ComLect; Leyendo := Leyendo + 1;or when Leyendo = 0 and not Escribiendo and not TurnoLectores => accept ComEscr; Escribiendo := true;or accept TerLect; Leyendo := Leyendo - 1; TurnoLectores := false;or accept Terminar_Escritura; Escribiendo := false; TurnoLectores := true;end select;


• Problemas clásicos:Lectores y Escritores– Pero si no hay procesos

del turno correspondienteesperando acceder a labase de datos?

– Tercera aproximación• Turno y cantidad de

procesos en espera

Seminario de Lenguajes A – Opción Ada Taskingselect when not Escribiendo and (ComEscr'Count = 0 or TurnoLectores) => accept ComLect; Leyendo := Leyendo + 1;or when Leyendo = 0 and not Escribiendo and (ComLect'Count = 0 or not TurnoLectores) => accept ComEscr; Escribiendo := true;or accept TerLect; Leyendo := Leyendo - 1; TurnoLectores := false;or accept Terminar_Escritura; Escribiendo := false; TurnoLectores := true;end select;


• Problemas clásicos: Productores/consumidores– Problema

• Buffer limitado• Procesos productores ponen elementos en el buffer

– Si no hay lugares libres, deben esperar a que haya• Procesos consumidores quitan elementos del buffer

– Si el buffer está vacío, deben esperar que haya algún elemento



• Problemas clásicos: Productores/consumidoresSeminario de Lenguajes A – Opción Ada Tasking

subtype TIdProd is integer range 1..CantProd;

task type Productor(Id: TIdProd := 1);

task body Productor is Item: integer := Id;begin loop -- produce un elemento Item := (Item + 1) mod 17; delay TiempoProd * duration(Id); Admin.Write(Item); end loop;end Productor;

subtype TIdCons is integer range 1..CantCons;

task type Consumidor(Id: TIdCons := 1);

task body Consumidor is Item: integer;begin loop Admin.Read(Item); delay TiempoCons * duration(Id); -- consume el elemento end loop;end Consumidor;


• Problemas clásicos: Productores/consumidoresSeminario de Lenguajes A – Opción Ada Tasking

task Admin is entry Read(I: out integer); entry Write(I: in integer);end Admin;

task body Admin is Buffer: TBuffer; Count: RangoInd := 0; In_Index: RangoBuf := 1; Out_Index: RangoBuf := 1;begin

end Admin;

loop select when Count < Buffer'Length => accept Write(I: in integer) do Buffer(In_Index) := I; end Write; Count := Count + 1; In_Index := (In_Index mod Buffer'length) + 1; or when Count > 0 => accept Read(I: out integer) do I := Buffer(Out_Index); end Read; Count := Count - 1; Out_Index := (Out_Index mod Buffer'length) + 1; end select;end loop;


• Problemas clásicos: Productores/consumidores con pares e impares– Problema

• Buffer limitado• Procesos productores ponen elementos en el buffer

– Si no hay lugares libres, deben esperar a que haya

• Procesos consumidores quitan elementos pares del buffer– Si el buffer está vacío, deben esperar que haya algún elemento y que el

próximo sea par

• Procesos consumidores quitan elementos impares del buffer– Si el buffer está vacío, deben esperar que haya algún elemento y que el

próximo sea impar



• Problemas clásicos: Productores/consumidores con pares e impares


subtype TIdProd is integer range 1..CantProd;

task type Productor( Id: TIdProd := 1);

task body Productor is Item: integer := Id;begin loop -- produce un elemento Item := (Item + 1) mod 17; delay TiempoProd * duration(Id); Admin.Write(Item); end loop;end Productor;

subtype TIdCons is integer range 1..CantCons;

task type Consumidor( Id: TIdCons := 1; Par: boolean := true);

task body Consumidor is Item: integer;begin loop Admin.Read(Par)(Item); delay TiempoCons * duration(Id); -- consume el elemento end loop;end Consumidor;


• Problemas clásicos: Productores/consumidores con pares e impares


task Admin is entry Read(boolean) (I: out integer); entry Write(I: in integer);end Admin;

or when (Count > 0) and (Buffer(Out_Index) mod 2 = 0) => accept Read(true)(I:out integer)do I := Buffer(Out_Index); end Read; Count := Count - 1; Out_Index := (Out_Index mod Buffer'Length) + 1; or when (Count > 0) and (Buffer(Out_Index) mod 2 = 1) => accept Read(false)(I:out integer)do I := Buffer(Out_Index); end Read; Count := Count - 1; Out_Index := (Out_Index mod Buffer'Length) + 1;end select;

select when Count < Buffer'Length => accept Write(I: in integer) do Buffer(In_Index) := I; end Write; Count := Count + 1; In_Index := (In_Index mod Buffer'length) + 1;


• Productores/consumidores en JavaSeminario de Lenguajes A – Opción Ada Tasking

class Buffer{ protected final int max; protected final Object[] data; protected int nextIn=0, nextOut=0, count=0; public Buffer( int max ){ this.max = max; this.data = new Object[max]; }

public synchronized void put(Object item) throws InterruptedException{ while (count == max) { wait(); } data[nextIn] = item; nextIn = (nextIn + 1) % max; count++; notify(); // a waiting consumer, if any } public synchronized Object get() throws InterruptedException{ while (count == 0) { wait(); } Object result = data[nextOut]; nextOut = (nextOut+1) % max; count--; notify(); // a waiting producer, if any return result; }}



class Producer implements Runnable { protected final Buffer buffer;

Producer(Buffer buffer) { this.buffer=buffer; }

public void run() { try { for (int j=1; j<=100; j++) { Thread.sleep(500); buffer.put(new Integer(j)); } } catch(InterruptedException e) { return; } }}

class Consumer extends Thread { protected final Buffer buffer;

public Consumer(Buffer buffer) { this.buffer = buffer; }

public void run() { try { for (int j=1; j<=100; j++) { Integer p = (Integer)(buffer.get()); int k = p.intValue(); Thread.sleep(1000); } } catch (InterruptedException e) { return; } }}



public class ProducerConsumer { static Buffer buffer = new Buffer(20);

public static void main(String[] args) { Producer p = new Producer(buffer); Thread pt = new Thread(p); Consumer c = new Consumer(buffer); pt.start(); c.start(); }}


• Comparación Concurrencia Ada - Java• Ada provee un modelo general de alto nivel, basado en la

comunicación explícita (rendezvouz)• Mientras que Java se basa en los monitores clásicos, siendo

entonces susceptible al problema de deadlock conocido como “nested monitor” y es propenso a errores.

• Aunque ciertos elementos del modelo de threads de Java proveen funcionalidad que no se encuentra en Ada (ej.: grupos de threads), la aproximación de Ada a la concurrencia es más confiable y más “portable” que la de Java.

• Ver “weblidi.info.unlp.edu.ar/catedras/ada/Brosgol_CRT.pdf”



• Problema: Concurrencia Recursiva• Buscar un elemento en un vector sin orden, utilizando búsqueda

binaria concurrente• El vector es dividido recursivamente en dos partes.• Cada parte del vector es procesada por una nueva tarea• Cada tarea se fija si el elemento buscado es el del medio del

vector, y si no lo es crea dos tareas y le asigna una mitad del vector a cada una



• Problema: Concurrencia Recursiva (2da. aproxim.)• En la solución anterior, la “rama” de tareas que no encuentra el

elemento, sigue procesando hasta el final• Entonces, ponemos una tarea “global” a la que todas las demás

le consultan si el elemento ya fue encontrado, y la que lo encuentra, le informa que ya se encontró

• Cada tarea, antes de crear a sus dos hijas, pregunta a la tarea global si ya se encontró el elemento buscado.


seminario de lenguajes a – opción ada

Documents