View
72
Download
2
Category
Preview:
DESCRIPTION
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ón end T ; task body T is --cuerpo end T; . Tareas. Cada tarea consta de: - PowerPoint PPT Presentation
Citation preview
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;
Recommended