1 / 56

Concurrencia en Ada

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:

zea
Download Presentation

Concurrencia en Ada

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Concurrencia en Ada

  2. 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;

  3. 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; task body T is --cuerpo end T; task T is --especificación end T; task body T is --cuerpo end T;

  4. Tareas • Declaración • Activación • Terminación

  5. 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

  6. Ejemplo • Arreglos en una casa: colocar pisos, colocar molduras, colocar cocina

  7. Ejemplo procedureARREGLAR_CASAis taskALBAÑIL; task bodyALBAÑILis begin COLOCAR_PISOS; endALBAÑIL; taskYESISTA; taskbodyYESISTAis begin COLACAR_MOLDURAS; endYESISTA; taskMONTADOR; task bodyMONTADORis COLOCAR_COCINA; endMONTADOR; begin SUPERVISAR_TRABAJOS; endARREGLAR_CASA; procedureARREGLAR_CASAis COLOCAR_PISOS; COLACAR_MOLDURAS; COLOCAR_COCINA; SUPERVISAR_TRABAJOS; endARREGLAR_CASA;

  8. 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

  9. Activación de tareas • Cuando una tarea se declara en un paquete, su activación se produce en el begin del cuerpo del paquete

  10. Activación de tareas procedureARREGLAR_CASAis taskALBAÑIL; task bodyALBAÑILis begin COLOCAR_PISOS; endALBAÑIL; taskYESISTA; taskbodyYESISTAis begin COLACAR_MOLDURAS; endYESISTA; taskMONTADOR; task bodyMONTADORis COLOCAR_COCINA; endMONTADOR; begin SUPERVISAR_TRABAJOS; endARREGLAR_CASA; • Activación de las tareas: albañil, yesista y montador • Un vez activadas la tareas existirán 4 tareas ejecutándose concurrentemente

  11. 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”

  12. 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, hayanterminado también

  13. begin Principal declaraciones end tarea A declarada activación ejecución tarea B declarada activación ejecución Ejemplo procedurePRINCIPALis --declaraciones ... taskA; task bodyAis begin ...; endA; taskB; taskbodyBis begin ...; endB; begin ...; endPRINCIPAL;

  14. 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)

  15. 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 taskEJEMPLO is entry SIN_PARAMETROS; entryCON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN); private entry .....; endEJEMPLO;

  16. 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

  17. 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 correspondiente task bodyEJEMPLOis begin ... acceptSIN_PARAMETROSdo --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada SIN_PARAMETROS [exception:] endSIN_PARAMETROS; ... acceptCON_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 endCON_PARAMETROS; endA;

  18. Vista completa taskEJEMPLO is entry SIN_PARAMETROS; entryCON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN); endEJEMPLO; task bodyEJEMPLOis begin ... acceptSIN_PARAMETROSdo --conjunto de sentencias que se ejecutarán en la cita --correspondiente al punto de entrada SIN_PARAMETROS endSIN_PARAMETROS; ... acceptCON_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 endCON_PARAMETROS; ... endA;

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

  20. La cita o rendes-vous taskPEON is entry PREPARAR_MEZCLA(cantidad:in INTEGER); endPEON; task bodyPEONis begin loop --Peón haciendo otros trabajos ... acceptPREPARAR_MEZCLA(cantidad: in INTEGER) do --prepara la mezcla ... -mezcla preparada endPREPARAR_MEZCLA; end loop; endPEON; taskALBAÑIL; task bodyALBAÑILis cantidad: integer; begin loop --Trabajando ... PEON.PREPARAR_MEZCLA(cantidad); ... end loop; endALBAÑIL;

  21. 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

  22. 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)

  23. 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

  24. Ada.Calendar package Ada.Calendar is type Time isprivate; 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);

  25. 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 dependent end Ada.Calendar;

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

  27. Sentencia Select (con guardas) • 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 select when condicion => accept A(X: out item) do --sentencias end; --más sentencias or when condicion => accept B(X:in item) do --sentencias end; --más sentencias or ... end select;

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

  29. Sentencia Select(con else) • 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 select [when condicion =>] accept A(X: out item) do --sentencias end; --más sentencias or ... or ... else --sentencias end select;

  30. Llamada temporizada • La sentencia select sólo puede tener una llamada a un punto de entrada y sin guarda select Peon.Preparar_Mezcla(cantidad); or delay 1*MINUTE; --HAGO OTRAS COSAS Y ME OLVIDO --DE LA MEZCLA end select;

  31. Llamada condicional • La sentencia select sólo puede tener una llamada a un punto de entrada y sin guarda select Peon.Preparar_Mezcla(cantidad); else --HAGO OTRAS COSAS Y ME OLVIDO --DE LA MEZCLA end select;

  32. Tipos Tarea procedureprincipalis task type T is --especificación entryE(...); 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 isaccess T; RX: REF_T; --otras declaraciones begin X.E(...); vector(I).E(...); Y.CT.E(...); RX=new T; RX.E(...); endprincipal;

  33. 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

  34. 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

  35. Terminación • ¿ Cuándo termina la tarea “progenitora” ? • Select con alternativa terminate task type progenitora; task body progenitora is task type T; task body T is loop --cuerpo end loop; endT; tarea:T; begin ... endprogenitora;

  36. Terminación • 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 select ... or ... or terminate; end select;

  37. 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

  38. 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

  39. 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)

  40. 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

  41. 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

  42. 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

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

  44. Discriminantes protectedtype OBJETO(tamaño:integer:=100)is ... end OBJETO; protected body OBJETO is ... endOBJETO; tasktype T(tamaño:integer:=100)is ... end T; task body T is ... endT;

  45. 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

  46. Operaciones protegidas protected 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; endOBJETO;

  47. Acceso a objetos protegidos Tareas esperando fuera del OP Tareas esperando en las barreras asociadas a los puntos de entrada Una tarea dentro del OP entry 1 . . . entry N

  48. 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

  49. 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]

  50. Ejemplo protectedEventis 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;

More Related