Concurrencia en Ada.

Presentación del tema: "Concurrencia en Ada."— Transcripción de la presentación:

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

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 is --especificación end T; task body T is --cuerpo task 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 Se pueden declarar tanto en la especificación del paquete como en el cuerpo (si se declaran en la especificación del paquete, el cuerpo de la tarea debe ir en el cuerpo del paquete). No se puede declara una tarea en la especificación de otra tarea.

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

7 Ejemplo procedure ARREGLAR_CASA is task ALBAÑIL; task body ALBAÑIL is
begin COLOCAR_PISOS; end ALBAÑIL; task YESISTA; task body YESISTA is COLACAR_MOLDURAS; end YESISTA; task MONTADOR; task body MONTADOR is COLOCAR_COCINA; end MONTADOR; SUPERVISAR_TRABAJOS; end ARREGLAR_CASA; procedure ARREGLAR_CASA is COLOCAR_PISOS; COLACAR_MOLDURAS; COLOCAR_COCINA; SUPERVISAR_TRABAJOS; end ARREGLAR_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 Si el cuerpo del paquete no tiene sentencias de inicialización y por tanto no tiene begin, entonces se supone que existe una sentencia null de inicialización. Más aún, si un paquete no tiene cuerpo, entonces se supone que existe un cuerpo con una sola sentencia null de inicialización

10 Activación de tareas procedure ARREGLAR_CASA is task ALBAÑIL; task body ALBAÑIL is begin COLOCAR_PISOS; end ALBAÑIL; task YESISTA; task body YESISTA is COLACAR_MOLDURAS; end YESISTA; task MONTADOR; task body MONTADOR is COLOCAR_COCINA; end MONTADOR; 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

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” La primera afirmación es cierta siempre que esa tarea no tenga otras subordinadas, en cuyo caso terminará cuando hayan terminado todas sus subordinadas.

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, hayan terminado también

13 Ejemplo Principal tarea A tarea B procedure PRINCIPAL is
--declaraciones ... task A; task body A is begin ...; end A; task B; task body B is end B; end PRINCIPAL; Principal tarea A tarea B declaraciones begin end declarada activación ejecución Esta regla de terminación asegura que los objetos declarados en la unidad, y por tanto potencialmente visibles por las tareas locales, no puedan desaparecer mientras que exista una tarea que pueda accederlos. Por otro lado la razón de tratar de esta forma la activación de tareas está relacionada con las excepciones. Una excepción elevada durante la elaboración de declaraciones no se maneja en ese nivel, sino que se propaga inmediatamente. Por tanto, una excepción elevada en las declaraciones de una nueva tarea no se podría manejar por esa tarea de ninguna manera. Sin embargo, ya que es claramente deseable que se proporcionen algunos medios para detectar tales excepciones, es obvio que se tiene que elevar una excepción en la unidad progenitora. De hecho, se eleva la excepción predefinida TASKKING_ERROR, independiente de cual sea la excepción original. Si se elevara esta excepción en la unidad progenitora después de que ésta hubiera continuado su ejecución concurrentemente con las tareas dependientes, evidentemente el problema sería más difícil de manejar y, por ello, la unidad progenitora se queda dormida hasta que todas las nuevas tareas se hayan activado. Además es importante tener en cuenta que si varias de las tareas nuevas elevan excepciones durante su activación, entonces TASKING_ERROR se eleva sólo una vez. Tales tareas se consideran completadas (no terminadas), y no afectan a las tareas hermanas que se estén activando simultáneamente. El otro problema que puede haber es que se presente una excepción en las declaraciones de la unidad progenitora. En este caso, todas las tareas nuevas que se hayan declarado (pero que no se han activado todavía debido a que la unidad progenitora no ha llegado a su begin) automaticamente terminan y no se activan nunc

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) Esto es similar a la situación que se presenta en la vida real cuando dos personas se encuentran, realizan una transacción y luego continúan independientemente.

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 Como se ve en el ejemplo puede tener puntos de entrada privados (esto podría ser útil por ejemplo en el caso de que una tarea tenga tareas dependientes; estas tareas tendrían acceso a estas entradas privadas; otra uso podría ser para que la tarea pueda reencolarse (requeue) en esos puntos de entrada privados, que no pueden ser llamados externamente. task EJEMPLO is entry SIN_PARAMETROS; entry CON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN); private entry .....; end EJEMPLO;

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 body EJEMPLO is begin ... 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 --correspondiente al punto de entrada CON_PARAMETROS end CON_PARAMETROS; end A; El cuerpo de la sentencia accept es sólo una secuencia de sentencias. Toda declaración local debe introducirse escribiendo un bloque local. Como se observa puede tener un manejador de excepciones (esto no era posible en Ada 83). Dentro de la sentencia accept podemos tener cualquier sentencia (llamadas a procedimientos, etc...) salvo accept al mismo punto de entrada o de la misma familia y salvo el select asíncrono.

18 Vista completa task EJEMPLO is entry SIN_PARAMETROS;
entry CON_PARAMETROS(A:in INTEGER;B:out FLOAT; C:in out BOOLEAN); end EJEMPLO; task body EJEMPLO is begin ... 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 --correspondiente al punto de entrada CON_PARAMETROS end CON_PARAMETROS; end A;

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); Se aplican las reglas de ámbito y visibilidad usuales (una tarea local puede llamar a un punto de entrada de su progenitor directamente)

20 La cita o rendes-vous task PEON is task ALBAÑIL;
entry PREPARAR_MEZCLA(cantidad:in INTEGER); end PEON; task body PEON is begin loop --Peón haciendo otros trabajos ... accept PREPARAR_MEZCLA(cantidad: in INTEGER) do --prepara la mezcla -mezcla preparada end PREPARAR_MEZCLA; end loop; task ALBAÑIL; task body ALBAÑIL is cantidad: integer; begin loop --Trabajando ... PEON.PREPARAR_MEZCLA(cantidad); end loop; end ALBAÑIL; Explicación de cómo tiene lugar la cita: La diferencia más importante entre una llamada a un punto de entrada y una llamada a un procedimiento es que, en el caso de un procedimiento, la tarea que llama al procedimiento ejecuta también inmediatamente el cuerpo del procedimiento mientras que, en el caso de un punto de entrada, la sentencia accept correspondiente la ejecuta la tarea propietaria del punto de entrada. Más aún, no se puede ejecutar la sentencia accept hasta que la tarea llame al punto de entrada, y la tarea propietaria del punto de entrada llegue a la sentencia accept. Uno de estos sucesos ocurrirá antes que el otro, y entonces se suspenderá una de las dos tareas hasta que la otra llegue a su sentencia correspondiente. Cuando esto sucede, la tarea llamada ejecuta la secuencia de sentencias de la sentencia accept, mientras que la tarea que llamó permanece suspendida. Esta interacción se denomina una cita o rendes-vous. Cuando se llega al final de la sentencia accept se completa la cita, y a continuación ambas tareas continúan independientemente.

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; Más operaciones: 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 is private;
subtype Year_Number is integer range ; subtype Month_Number is integer range 1..12; subtype Day_Number is integer range 1..31; subtype Day_Duration is duration range _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 ... end select; “return” dentro del accept -> = salir del accept.

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 accept B(X:in item) do ... end select; Entre la evaluación de la condición y el when puede haber cambiado la condición. Si todos los guardas son falsos se eleva PROGRAM_ERROR. Si una opción no tiene guarda se considera cierta siempre.

28 Sentencia Select (con delay)
[when condicion =>] accept A(X: out item) do --sentencias end; --más sentencias or ... 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 ... else 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 procedure principal is task type T is --especificación
entry E(...); end T; task body T is --cuerpo 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 declaraciones begin X.E(...); vector(I).E(...); Y.CT.E(...); RX=new T; RX.E(...); end principal; Una observación importante es que los objetos tarea no son variables, sino que se comportan como constantes. Una declaración de objeto tarea crea una tarea que está asociada permanentemente al objeto. Por tanto, no se permite la asignación para los tipos tarea, ni tampoco existen las comparaciones de igualdad y desigualdad. Por ello, un tipo tarea es otra forma de tipo limitado. Los tipos tarea pueden ser parámetros de subprogramas; se pasan siempre por referencia y, por lo tanto, los parámetros formal y real hacen referencia siempre a la misma tarea. Comentar como se produce la activación (igual que en los casos anteriores).

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” ?
task 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

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 select ... or terminate; end select; Puede estar guardada, pero no puede aparecer en una sentencia select que tenga una alternativa delay o else

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 T’CALLABLE Cierto si T ha terminado
Cierto a menos que la tarea se haya completado o terminado o se encuentre en un estado “anormal” pendiente de que la aborten Es necesario tener cuidado con el uso de estor atributos. Por ejemplo, en el tiempo que transcurre entre que se descubre que una tarea no ha terminado, y el momento en que se toma alguna acción basada en esa información, se podría terminar la tarea. Sin embargo, no es posible la inversa, ya que no se puede volver a iniciar una tarea y, por tanto, es completamente seguro tomar una acción basada en el hecho de que una tarea ha terminado.

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] OBJETO is
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 En la parte privada declaramos los datos (no se pueden declarar tipos si el objeto protegido es un tipo ya que existe una regla general que indica que no se pueden declarar tipos dentro de otros tipos). En el cuerpo del objeto protegido estarán los cuerpos de todas las operaciones protegidas (funciones, procedimientos y entradas). Pueden además existir funciones y subprogramas locales. Los datos sin embargo deben estar todos en la parte privada de la especificación.

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

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 OJO, las funciones si pueden modificar otros datos que no sean privados, por ejemplo, variables globales (eso si, cuidado con esto puesto que podrían estar varias tareas modificando datos sin garantizarse la exclusión mutua).

46 Operaciones protegidas
protected body OBJETO is procedure YYY(...) is --declaraciones begin ... end YYY; function XXX return tipo; end XXX; entry ZZZ(...) when condicion is end ZZZ; end OBJETO; El cuerpo de los puntos de entrada pueden tener una parte declarativa, a diferencia de la sentencia accept (donde si si quería realizar declaraciones de variables era necesario definir un bloque).

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 . Los objetos protegidos garantizan exclusión mutua en las diferentes llamadas a sus operaciones protegidas (cerrojo). Cada barrera asociada a cada punto de entrada tiene a su vez su cola de tareas cuya condición se evaluó a falso. Cada vez que una tarea termina una operación protegida (salvo si se trata de una función) se reevalúan las condiciones de las tareas bloqueadas en todos los puntos de entrada. Dentro de una cola se sigue una política FIFO pero entre las diferentes colas, si existen varias tareas cuyas condiciones son ciertas, no se nos especifica nada acerca del orden en el que harán uso del OP. Por tanto, las tares bloqueadas en las condiciones barrera de los puntos de entrada tienen preferencia frente a las que están intentando acceder al OP (quedaran bloqueadas en el cerrojo). Si en las condiciones barrera se utilizan variables globales puede ocurrir que un cambio en las mismas no tenga efecto inmediato en tareas bloqueadas en dichas barreras, puesto que solo se reevalúan cuando termina una operación protegida que no sea una función. 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] Se puede hacer un requeue sobre el mismo punto de entrada, sobre otros puntos de entrada del mismo objeto protegido o tarea, entre puntos de entrada de diferentes tareas y objetos. Pasa implícitamente los parámetros de la llamada original. El punto de entrada llamado o no tiene parámetros (en cuyo caso se ignoran los parámetros de la llamada original) o si los tiene, estos deben coincidir con el patrón de parámetros del punto de entrada desde donde se realiza el requeue.

50 Ejemplo protected 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 Ocurred:=False; end reset; end Event;

51 Excepciones Una excepción durante una operación protegida no manejada localmente se propaga a la tarea llamada Comentar aquí también que el paso de parámetros de tanto en el caso de tareas como en el caso de objetos protegidos se realiza siempre por referencia.

52 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 alternativas then abort --otras sentencias end select; Sentencias alternativas Funcionamiento: Si pasan 5 segundos y no ha terminado todo el bloque 2, se abandona la ejecución de las sentencias que estén en el bloque 2 y se ejecuta el conjunto de sentencias que estén en el bloque 1. Si en lugar de una sentencia delay tenemos una llamada a un punto de entrada el funcionamiento de esta sentencia es el siguiente: si se retorna del punto de entrada (es decir, si tiene lugar la cita) y el conjunto de sentencias del bloque 2 no ha terminado, se abandona la ejecución de sentencias de dicho bloque y se ejecuta el conjunto de sentencias que estén en el bloque 1. La llamada puede ser a un punto de entrada de una tarea o de un objeto protegido. 1 Parte que se puede abortar 2

53 Ejemplo – cálculo iterativo
protected Trigger is entry wait; procedure signal; private Flag:Boolean:=False; end; protected Result is procedure Set_Estimate(X:in Data); function Get_Estimate return Data; private The_Estimate:Data; end; Tarea esclava Tarea controladora ... 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; Una ventaja importante de esta aproximación es que la tarea esclava no necesita interrogar alguna variable común con la tarea controladora para saber cuando tiene que parar.

54 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 is begin loop select when guarda1 => accept Servir(1)(params) do ... end Servir; or when guarda2 => accept Servir(2)(params) do when guarda3 => accept Servir(3)(params) do ... end Servir; end select; end loop; end Servidor; La llamada a un punto de entrada en este caso se realiza: Servidor.Servir(1)(params). El atributo count se puede especificar para un miembro concreto de la familia (poner el ejemplo de un servidor con una familia de puntos de entradas que se atiendan según una prioridad).

55 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 is begin loop for P in peticion loop select accept Servir(p)(params) do ... end Servir; exit; else null; end select; end loop;

56 Familia de puntos de entradas. Objetos protegidos
type 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 Accion(params); end Servir;