Concurrencia en Ada

Tareas En Ada, las actividades concurrentes se

describen por medio de tareas La forma de expresar una tarea en Ada

es similar a los paquetes:

task T is --especificaciónend T;task body T is --cuerpoend T;

Tareas Cada tarea consta de:

Una especificación que describe la interfaz que presenta a otras tareas

Un cuerpo que describe el comportamiento dinámico de la tarea

En algunos casos una tarea no presenta interfaz a otras tareas

task T is --especificaciónend T;task body T is --cuerpoend T;

task T;

task body T is --cuerpoend T;

Tareas Declaración Activación Terminación

Declaración de tareas Una tarea es un componente de

programa que puede declararse dentro de: subprogramas, bloques, paquetes o

dentro del cuerpo de otra tarea

Ejemplo

Arreglos en una casa: colocar pisos, colocar molduras, colocar cocina

Ejemploprocedure ARREGLAR_CASA is task ALBAÑIL; task body ALBAÑIL is begin COLOCAR_PISOS; end ALBAÑIL;

task YESISTA; task body YESISTA is begin COLACAR_MOLDURAS; end YESISTA;

task MONTADOR; task body MONTADOR is COLOCAR_COCINA; end MONTADOR;

begin SUPERVISAR_TRABAJOS;end ARREGLAR_CASA;

procedure ARREGLAR_CASA is COLOCAR_PISOS; COLACAR_MOLDURAS; COLOCAR_COCINA; SUPERVISAR_TRABAJOS;end ARREGLAR_CASA;

Activación de tareas La ejecución de una tarea puede entenderse como

un proceso que consta de dos fases: La primera fase, conocida como activación, consiste en la

elaboración de las declaraciones del cuerpo de la tarea La segunda fase consiste por supuesto en la ejecución de

sus sentencias La activación de una tarea es automática Las tareas “subordinadas” se activan

automáticamente cuando la unidad “progenitora” llega al begin siguiente a la declaración de las tareas

Activación de tareas Cuando una tarea se declara en un

paquete, su activación se produce en el begin del cuerpo del paquete

Activación de tareasprocedure ARREGLAR_CASA is task ALBAÑIL; task body ALBAÑIL is begin COLOCAR_PISOS; end ALBAÑIL;

task YESISTA; task body YESISTA is begin COLACAR_MOLDURAS; end YESISTA;

task MONTADOR; task body MONTADOR is COLOCAR_COCINA; end MONTADOR;

begin SUPERVISAR_TRABAJOS;end ARREGLAR_CASA;

•Activación de las tareas: albañil, yesista y montador•Un vez activadas la tareas existirán 4 tareas ejecutándose concurrentemente

Terminación de tareas Las tareas “terminan” cuando

llegan a su end final Regla importante:

“Una unidad no puede acabar hasta que todas las tareas dependientes de ella hayan terminado”

Terminación de tareas En general podemos decir que la

terminación se realiza en dos etapas: Diremos que una unidad se

completa cuando llega a su end final y finalmente terminará sólo cuando

todas las tareas dependientes, si las hay, hayan terminado también

Ejemploprocedure PRINCIPAL is --declaraciones ... task A; task body A is begin ...; end A;

task B; task body B is begin ...; end B;begin ...;end PRINCIPAL;

Principal

tarea A

tarea B

declaraciones

begin

end

declarada activación

declarada ejecución

activación

ejecución

La cita (rendez-vous) Generalmente las tareas

interaccionarán entre sí durante su tiempo de vida.

Esto se hace en Ada mediante un mecanismo conocido como la cita o rendez-vous (que significa sincronización e intercambio de información entre dos tareas dadas)

Puntos de entrada La cita entre dos tareas se produce como

consecuencia de la llamada de una tarea a un punto de entrada declarado en otra tarea

Se declara un punto de entrada en la especificación de una tarea de la misma manera que se declara un procedimiento en la especificación de un paquete

task EJEMPLO is entry SIN_PARAMETROS; entry CON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN);private entry .....;end EJEMPLO;

Puntos de entrada Un punto de entrada puede tener

parámetros in, out e in out Los parámetros son el medio para el

intercambio de información entre las tareas que se den en la cita

Si en la declaración de un punto de entrada no hay parámetros significa que estamos utilizando el punto de entrada únicamente para sincronización entre tareas

Sentencias accept Las sentencias que se ejecutarán durante una cita se describen

mediante las sentencias accept correspondientes Las sentencias accept se encuentran en el cuerpo de la tarea que

contiene la declaración del punto de entrada correspondientetask body EJEMPLO isbegin ... accept SIN_PARAMETROS do --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada SIN_PARAMETROS [exception:] end SIN_PARAMETROS; ... accept CON_PARAMETROS(A:in INTEGER;B:out FLOAT;C:in out BOOLEAN) do --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada CON_PARAMETROS end CON_PARAMETROS;end A;

Vista completatask EJEMPLO is entry SIN_PARAMETROS; entry CON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN);end EJEMPLO;

task body EJEMPLO isbegin ... accept SIN_PARAMETROS do --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada SIN_PARAMETROS end SIN_PARAMETROS; ... accept CON_PARAMETROS(A:in INTEGER;B:out FLOAT;C:in out BOOLEAN) do --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada CON_PARAMETROS end CON_PARAMETROS; ...end A;

Llamada a un punto de entrada Se llama a un punto de entrada de la

misma forma que a un procedimiento

...EJEMPLO.SIN_PARAMETROS;...EJEMPLO.CON_PARAMETROS(a,b,c);...

La cita o rendes-voustask PEON is entry PREPARAR_MEZCLA(cantidad:in INTEGER);end PEON;

task body PEON isbegin loop --Peón haciendo otros trabajos ... accept PREPARAR_MEZCLA(cantidad: in INTEGER) do --prepara la mezcla ... -mezcla preparada end PREPARAR_MEZCLA; end loop;end PEON;

task ALBAÑIL;

task body ALBAÑIL is cantidad: integer;begin loop --Trabajando ... PEON.PREPARAR_MEZCLA(cantidad); ... end loop;end ALBAÑIL;

Atributo COUNT El atributo E’COUNT da el número de

tareas que están en un momento determinado en la cola del punto de entrada E

¡ OJO al uso del atributo COUNT en las guardas ! Da el número de tareas encoladas en el

momento en que la guarda se evalúa, y este puede cambiar antes de que se acepte la cita

Temporización delay segundos;

Suspende la tarea al menos “segundos” segundos Si segundos<=0, no tiene efecto

segundos: Tipo Duration (coma fija) Rango de valores

Depende de la implementación Garantizan:

Precisión (Duration’small): no por encima de 20 milisegundos

Rango: al menos –86_400.0 a 86_400.0 (segundos de un día)

Temporización delay until tiempo;

Tiempo: Tipo Time Fecha Hora (segundos transcurridos desde la

media noche) Más operaciones:

paquete Ada.Calendar paquete Ada.Real_Time

Ada.Calendar package Ada.Calendar is type Time is private;

subtype Year_Number is integer range 1901..2099; subtype Month_Number is integer range 1..12;

subtype Day_Number is integer range 1..31; subtype Day_Duration is duration range 0.0..86_400.0;

function Clock return Time;

function Year(Date:Time) return Year_Number; function Month(Date:Time) return Month_Number; function Day(Date:Time) return Day_Number; function Second(Date:Time) return Day_Duration;

procedure Split(Date: in Time; Year: out Year_Number; Month: out Month_Number; Day: out Day_Number; Seconds: out Day_Duration);

Ada.Calendar function Time_Of(Year: Year_Number; Month: Month_Number; Day: Day_Number; Seconds: Day_Duration) return Time;

function “+”(Left: Time;Right: Duration) return Time; function “+”(Left: Duration; Right: Time) return Time; function “-”(Left: Time;Right: Duration) return Time; function “-”(Left: Time; Right: Time) return Duration; funciton “<“(Left,Right: Time) return Boolean; function “<=“(Left,Right: Time) return Boolean; function “>“(Left,Right: Time) return Boolean; function “>=“(Left,Right: Time) return Boolean; Time_Error: exception;

private --implementation dependentend Ada.Calendar;

Sentencia Selectselect accept A(X: out item) do --sentencias end; --más sentenciasor accept B(X:in item) do --sentencias end; --más sentenciasor ...end select;

Sentencia Select (con guardas)

select when condicion => accept A(X: out item) do --sentencias end; --más sentenciasor when condicion => accept B(X:in item) do --sentencias end; --más sentenciasor ...end select;

OJO! No es seguro que una guarda esté todavía a cierto cuando se realice la cita correspondiente

Si todas las guardas son falsas se eleva la excepción PROGRAM_ERROR

Si una guarda no existe se considera como cierta

Sentencia Select (con delay)

select [when condicion =>] accept A(X: out item) do --sentencias end; --más sentenciasor ...or ...or [when condicion =>] delay 10*MINUTOS;end select;

Sentencia Select (con else)

select [when condicion =>] accept A(X: out item) do --sentencias end; --más sentenciasor ...or ...else --sentenciasend select;

Una sentencia select no puede tener una rama else y otra delay (aunque la rama else si puede empezar con una sentencia delay)

Las sentencias accept pueden ir guardadas salvo la rama else

Llamada temporizada

select Peon.Preparar_Mezcla(cantidad);or delay 1*MINUTE; --HAGO OTRAS COSAS Y ME OLVIDO --DE LA MEZCLAend select;

La sentencia select sólo puede tener una llamada a un punto de entrada y sin guarda

Llamada condicional

select Peon.Preparar_Mezcla(cantidad);else --HAGO OTRAS COSAS Y ME OLVIDO --DE LA MEZCLAend select;

La sentencia select sólo puede tener una llamada a un punto de entrada y sin guarda

Tipos Tareaprocedure principal is task type T is --especificación entry E(...); end T; task body T is --cuerpo end T; X:T; vector: array(1..10) of T; type REC is record CT:T; ... end record;

Y:REC; type REF_T is access T; RX: REF_T; --otras declaracionesbegin X.E(...); vector(I).E(...); Y.CT.E(...); RX=new T; RX.E(...);end principal;

Dependencia y terminación Una unidad no puede acabar hasta que

todas las tareas dependientes de ella hayan terminado

Toda tarea depende de una unidad Bloque, subprograma o cuerpo de tarea que

la engloba y dentro del cual se declara, salvo:

Declaración de tareas en paquetes Tareas creadas con el operador new

Dependencia Declaración de tareas en paquetes

Dependerán del bloque, subprograma o cuerpo de tarea donde se declare el paquete

Tareas creadas con el operador new Dependerán del bloque, subprograma

o cuerpo de tarea donde se declaró el tipo acceso

Terminacióntask type progenitora;task body progenitora is task type T; task body T is loop --cuerpo end loop; end T; tarea:T;begin ...end progenitora;

¿ Cuándo termina la tarea “progenitora” ?

Select con alternativa terminate

Terminación

select ...or ...or terminate;end select;

Se toma la alternativa terminate si la unidad de la que la tarea depende ha llegado al final, y por tanto, está completada

y además todas las tareas hermanas y tareas dependientes han terminado o pueden análogamente seleccionar una alternativa terminate

Puede estar guardada, pero no puede aparecer en una sentencia select que tenga una alternativa delay o else

Terminación La selección de una sentencia

alternativa terminate se entiende como una terminación normal La tarea controla la situación y

termina voluntariamente La sentencia abort termina una o

más tareas incondicionalmente

Terminación Si se aborta una tarea, entonces

todas las tareas que dependen de ella, o de un subprograma o bloque llamados en ese momento por ella, se abortan también

Terminación Situaciones

Tarea suspendida No suspendida

Caso especial: Se intenta abortar una tarea durante una cita

tarea llamada -> TASKING_ERROR tarea llamante -> se completa la cita (la tarea

permanece en un estado “anormal” y solo cuando se completa la cita, la tarea se completa debidamente)

Estado de una tarea T’TERMINATED

Cierto si T ha terminado T’CALLABLE

Cierto a menos que la tarea se haya completado o terminado o se encuentre en un estado “anormal” pendiente de que la aborten

TASKING_ERROR Error durante la activación de alguna tarea

TASKING _ERRROR en la unidad progenitora Aborta una tarea llamada durante una cita

TASKING_ERROR en la tarea llamante Tareas encoladas en puntos de entrada de

una tarea servidora que es abortada TASKING_ERROR en las tareas encoladas

Otras situaciones de error Si se produce una excepción durante

una cita en la tarea llamada y no se maneja dicha excepción en el accept correspondiente, se propaga la excepción en ambas tareas

Si una tarea no maneja una excepción de ninguna manera, se abandona la tarea y se pierde la excepción

Objetos protegidosprotected [type] OBJETO is function XXX(params) return tipo; procedure YYY(params); entry ZZZ(params);private --datos privados --otras funciones, procedimientos y --puntos de entrada privadosend OBJETO;protected body OBJETO is --cuerpo (implementación) --A diferencia de los paquetes y tareas --en esta parte no se pueden declarar --datosend OBJETO;

Discriminantesprotected type OBJETO(tamaño:integer:=100) is ...end OBJETO;protected body OBJETO is ...end OBJETO;

task type T(tamaño:integer:=100) is ...end T;task body T is ...end T;

Objetos protegidos (OP) Los objetos protegidos garantizan

exclusión mutua en las diferentes llamadas a sus operaciones protegidas (funciones, procedimientos, puntos de entrada)

Funciones: sólo tienen permiso de lectura sobre los datos privados Acceso concurrente a un objeto

protegido

Operaciones protegidasprotected body OBJETO is procedure YYY(...) is --declaraciones begin ... end YYY; function XXX return tipo; begin ... end XXX; entry ZZZ(...) when condicion is begin ... end ZZZ;end OBJETO;

Acceso a objetos protegidos

entry 1

entry N

...

Tareas esperando fuera del OP

Tareas esperando en las barreras asociadas a los puntos de entrada

Una tarea dentro del OP

Condiciones barrera Uso del atributo COUNT + Llamadas temporizadas y condicionales

Tareas Problemas: puede ocurrir que entre la evaluación de

la condición y la cita, la condición haya cambiado Objetos protegidos:

No es posible estas situaciones erróneas La operación de quitar una tarea de una cola es una

operación protegida. Por tanto, esto provocará que se reevalúen las condiciones

Requeue requeue [punto de entrada];

Encola una tarea en un punto de entrada de la misma tarea otra tarea un objeto protegido

Pasa implícitamente los parámetros de la llamada original

No pueden pasarse parámetros explícitamente No se puede abortar a una tarea que realice un

operación requeue, salvo requeue [punto de entrada] [with abort]

Ejemploprotected Event is entry wait; entry signal;private entry reset; Ocurred:boolean:=False;end Event;

protected body Event is entry wait when Ocurred is begin null; end wait;

entry signal when True is begin if wait’count>0 then Ocurred:=True; Requeue reset; end if; end signal;

entry reset when wait’count=0 is begin Ocurred:=False; end reset;end Event;

Excepciones Una excepción durante una

operación protegida no manejada localmente se propaga a la tarea llamada

Select asíncrono(Asyncronous Transfer Control- ATC) Permite abandonar una actividad bajo

determinadas circunstancias, pudiéndose ejecutar en ese caso un conjunto alternativo se sentencias

select --delay 5.0 --o Llamada a un punto de entrada --sentencias alternativasthen abort --otras sentenciasend select;

Sentencias alternativas

Parte que se puede abortar

2

1

Ejemplo – cálculo iterativoprotected Result is procedure Set_Estimate(X:in Data); function Get_Estimate return Data;private The_Estimate:Data;end;

protected Trigger is entry wait; procedure signal;private Flag:Boolean:=False;end;

...select Trigger.wait;then abort --Obtener una estimación nueva_est Result.Set_Estimate(nueva_est);end select;...

...Trigger.signal;Final_Answer:=Result.Get_Estimate;...

Tarea esclava Tarea controladora

Familia de puntos de entradas. Tareas

type peticion is integer range 1..3;task Servidor is entry Sevir(peticion)(params);end Servidor;task body Servidor isbegin loop select when guarda1 => accept Servir(1)(params) do ... end Servir; or when guarda2 => accept Servir(2)(params) do ... end Servir; or

when guarda3 => accept Servir(3)(params) do ... end Servir; end select; end loop;end Servidor;

Familia de puntos de entradas. Tareas

type peticion is integer range 1..3;task Servidor is entry Sevir(peticion)(params);end Servidor;task body Servidor isbegin loop for P in peticion loop select accept Servir(p)(params) do ... end Servir; exit; else null; end select; end loop; end loop;end Servidor;

Familia de puntos de entradas. Objetos protegidostype peticion is integer range 1..3;

protected Servidor is entry Sevir(peticion)(params);end Servidor;

protected body Servidor is function Condicion(P:peticion) return boolean is begin ... end Condicion; entry Servir(for P in peticion)(params) when Condicion(P) is begin Accion(params); end Servir;end Servidor;