Sunteți pe pagina 1din 11

PROGRAMACIN CONCURRENTE Y TIEMPO REAL

ACTIVIDAD DE ADA
CURSO 2013/2014
ESCUELA SUPERIOR DE INFORMTICA
UNIVERSIDAD DE CASTILLA-LA MANCHA
Res!e"##################################################################################################################################### 2
O$%e&'()s##################################################################################################################################### 2
Es*e+','+-+'."############################################################################################################################ 2
E%e/+'+')s#################################################################################################################################### 3
E"&/e0- 1 ")/!-s 2e */ese"&-+'."########################################################################################## 3
E(-4-+'."################################################################################################################################## 3
5'$4')0/-,6- $7s'+-##################################################################################################################### 8
A"e9) : F'+;e/)s #-2s############################################################################################################### 8
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
Res!e"
Este documento contiene la especificacin, objetivos, materializacin y evaluacin del
trabajo terico/prctico a realizar por el estudiante y que representa una actividad no
obligatoria y recuperable segn la gua docente de la asignatura Programacin oncurrente y
!iempo "eal# Esta actividad, cuya temtica es la programacin en $da, tiene un peso del 15%
de la nota final#
%a actividad en cuestin se divide en dos partes&
'# %a implementacin de una serie de ejercicios bsicos relativos a la utilizacin de
$da en el conte(to de la Programacin oncurrente y el !iempo "eal, junto con
la elaboracin de una memoria que discuta brevemente la solucin planteada e
integre el cdigo fuente comentado relativo a la solucin de cada uno de los
ejercicios# Esta parte se puede realizar de manera individual o por parejas#
)# %a realizacin de una actividad prctica en el laboratorio en la que se podr
utilizar como documentacin la memoria previamente elaborada# Esta parte se
debe realizar de manera individual#
$ continuacin se describe con ms detalle la actividad propuesta#
O$%e&'()s
Objetivo general
El objetivo general de esta actividad consiste en adquirir las competencias bsicas para
llevar a cabo la creacin de programas en $da en el mbito de la Programacin oncurrente y
!iempo "eal#
Objetivos especficos
El estudiante deber adquirir las *abilidades necesarias para la creacin de programas en
$da orientados a gestionar de manera adecuada la concurrencia a trav+s de los mecanismos de
alto nivel, como los objetos protegidos, integrados en el propio lenguaje# Por otra parte,
tambi+n se persigue el manejo bsico de paquetes relativos al tiempo real#
,er necesario implementar soluciones funcionales para las distintas cuestiones planteadas
utilizando el lenguaje de programacin $da#
Es*e+','+-+'."
%a relacin de ejercicios a resolver se e(pone a continuacin# onstruya los siguientes
programas $da usando los mecanismos integrados en el propio lenguaje y muestre los
resultados por la salida estndar#
En el anexo puede consultar los elementos utilizados para resolver los distintos ejercicios#
Este contenido se corresponde con los arc*ivos de especificacin -#ads. que contienen la
declaracin de dic*os elementos#
P!gina "
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
E%e/+'+')s
Ejercicio 1
ree un ejecutable en $da denominado main con la siguiente funcionalidad&
/ostrar por pantalla el mensaje& 0---- Inicio del programa main ----1#
Esperar 2 segundos#
/ostrar por pantalla el mensaje& 0---- Fin del programa main ----1#
Ejercicio 2
onstruye en $da un tipo tarea peridica con las siguientes caractersticas&
Tiempo de activacin: ' segundo#
Periodo: '333 milisegundos#
Tiempo de cmputo: 233 milisegundos#
Para el modelado del tiempo de cmputo utiliza una espera activa que incremente una
variable entera durante el tiempo indicado# 4nicializa a cero el valor de esta variable en cada
ciclo# Para resolver este problema debers *acer uso de la biblioteca Ada.Real_Time# $dems,
ser necesario declarar este tipo dentro de un paquete#
Para comprobar que la tarea funciona correctamente, muestra por pantalla un mensaje con
el valor de la variable entera al final de cada ejecucin#
Para probar la tarea, crea una instancia en el procedimiento principal main a partir del
paquete creado -reutiliza el cdigo del ejercicio anterior.# uando termines la ejecucin del
main, aborta la tarea creada#
Ejercicio 3
onstruye en $da un tipo tarea peridica con las siguientes caractersticas&
Tiempo de activacin: ' segundo#
Periodo: '333 milisegundos#
Esta tarea deber permitir una comunicacin mediante paso de mensajes# Para ello tendr
dos puntos de entradas 0MultiplicaX21 y 0MultiplicaX11, cada uno de los cuales devuelve
el nmero entero que recibe multiplicado por ) y por '3, respectivamente# %a funcionalidad de
esta tarea ser la siguiente&
5urante la mitad del tiempo del periodo ser sensible a cualquiera de estas dos
llamadas# !ranscurrido ese tiempo mostrar un mensaje por pantalla y esperar al
comienzo del siguiente ciclo# El mensaje ser& 0--- Error: No se ha recibido
ninguna llamada --- 0#
El procedimiento main se encargar de realizar las llamadas a la instancia de la tarea
anterior# Para ello ejecutar un bucle for con '3 iteraciones, de forma que en la iteraciones
pares *ar una llamada a /ultiplica6) y en la impares a /ultiplica6'3, pasando como
parmetro el ndice de la iteracin del bucle#
P!gina 3
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
!ras cada llamada, el procedimiento principal deber mostrar el valor recibido y
bloquearse un nmero de segundos igual a la iteracin correspondiente del bucle for# $ntes de
finalizar su ejecucin, deber abortar la tarea#
Ejercicio 4
En la programacin de un sistema e(isten diversas tareas que interactan con un usuario
mediante la impresin de mensajes por pantalla# En este conte(to, y debido a la alta
concurrencia de estos sistemas, nos encontramos con el problema de que los mensajes
aparecen sin un orden adecuado# $dems, cuando una tarea en concreto necesita obtener un
mensaje por parte del usuario, la continua impresin de mensajes por parte de las otras tareas
*ace muy incmodo comprender lo que se le est pidiendo#
Para solventar este problema se pide que modele en $da un recurso que ser compartido
por varias tareas# Este recurso se encargar de modelar una pantalla o monitor encargado
interactuar con el usuario a trav+s de la impresin de mensajes y de la espera de los mensajes
por parte del usuario# %a interfaz de este recurso ser la siguiente&
imprimir_msg(msg) 78 imprime por pantalla el mensaje msg cuando el recurso
est libre#
get_msg(msg) 78 espera que el usuario introduzca una cadena de caracteres por
lnea de rdenes y devuelve ese mensaje utilizando paso por referencia# ,i el usuario
no escribe nada en 2 segundos, se mostrar un mensaje de error y se liberar el
recurso#
on el fin de modelar la e(clusin mutua, se recomienda que la impresin de mensajes por
pantalla se *aga a trav+s de un objeto protegido# 5e esta forma,
,lo podremos usar imprimir_msg si el objeto protegido no est siendo usado# $s, no
se intercalarn los mensajes de las distintas tareas# ualquier mensaje que se vaya a
mostrar por pantalla debe *acerse a trav+s de este objeto protegido#
,i en lugar de mostrar un mensaje por pantalla queremos recibir por parte del usuario
un mensaje, el objeto protegido se *a de bloquear para que ninguna otra tarea
interfiera# ,in embargo, puede resultar necesario escribir algn mensaje por pantalla
para indicarle al usuario qu+ tipo de informacin necesitamos o, por ejemplo,
representar un mensaje de error# Para ello, el objeto protegido tendr *abilitado otro
punto de entrada que slo podr ser usado cuando est+ bloqueado# Este
imprimir_aux(msg) slo podr ser usado por el procedimiento get_msg(msg)
de la interfaz#
omo resumen, el objeto protegido tendr la siguiente interfaz&
Liberar 78 libera el recurso#
Bloquear 78 bloquea el recurso#
imprimir_msg(msg) 78 para que cualquier tarea pueda mostrar un mensaje por
pantalla#
imprimir_aux(msg) 78 para que el procedimiento get_mensaje pueda mostrar un
mensaje cuando el objeto protegido est+ bloqueado#
P!gina 4
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
$dems, contar con las siguientes guardas o barreras&
estado 78 que indicar si el objeto protegido esta !"#P$%! o &'()*
estado_aux 78 que garantiza que no se pueda usar imprimir_aux si ya est siendo
usada#
Para evitar que el recurso se quede bloqueado de forma indefinida cuando se est a la
espera de que el usuario introduzca un mensaje, se limitar esta espera a 2 segundos# ,i
transcurridos esos 2 segundos el usuario no *a introducido ningn mensaje, entonces se
lanzar un mensaje de error informando de este *ec*o, mostrando la cadena 0E""9"1 en
maysculas y desbloqueando el recurso#
Encapsule el cdigo en un paquete y defina una interfaz en el paquete para poder utilizar
dic*o recurso#
+ ,ota& Para mostrar un mensaje por pantalla es necesario usar la funcionalidad ofrecida por la
biblioteca Ada.Text_IO# ,in embargo, +sta slo trabaja con variables String, las cuales tienen que
estar definidas -en tama:o. en el momento de su creacin# Para poder usar cadenas sin restricciones
de te(to podemos usar la biblioteca Ada.Strings.Unbounded y definir la variable msg del tipo
Unbounded_String# onsidere que antes de poder usar la funcionalidad de Ada.Text_IO *ay que
convertirlas a String mediante To_String(msg)# "ecuerde que en get_msg(msg) no se conoce a priori
el tama:o de la cadena#
Ejercicio 5
/odele en $da un semforo binario mediante objetos protegidos# Encapsule el cdigo en
un paquete y defina una interfaz en el paquete para utilizar dic*o semforo#
Ejercicio 6
/odele en $da una tarea -ue sea sensible a un evento o suceso# Este evento se modelar
como un semforo binario -reutilice el cdigo del ejercicio 2. y deber estar encapsulado
dentro de un paquete# %a tarea, encapsulada tambi+n dentro de un paquete, deber mostrar por
pantalla el mensaje 0Evento generado a las: [Hora]1, siendo [Hora] la *ora en
formato 0da/mes/a:o ; **&mm&ss1 en la que se *a generado el evento# omo modo de
ejecucin normal no *ar nada#
$dems, se deber crear un procedimiento principal para probar la tarea# El
procedimiento principal, adems de instanciar la tarea y el semforo necesario, activar '3
eventos, con una distancia mnima entre eventos igual al orden del evento, es decir, ' segundo
entre el primer y el segundo evento, ) segundos entre el segundo y el tercero, y as
sucesivamente# %a ejecucin del programa debe acabar correctamente, por lo que el
procedimiento principal deber finalizar la tarea que *a generado#
<Por qu+ se generan '' eventos en lugar de los '3 programados=
+ ,otas
En este caso no se podr utilizar una interfaz para manejar al objeto protegido, ya que el
elemento de bloqueo en la transferencia asncrona *a de ser directamente un entry, un
accept o un delay, por lo que no sirve una llamada indirecta a trav+s de un procedimiento#
Es necesario a:adir un punto de despac*o en la parte de 0ejecucin normal1 de la
transferencia asncrona de control# Esto se consigue a:adiendo un delay#
,e aconseja usar un procedimiento para representar la *ora# Para ello ser necesario *acer
uso del paquete Ada.Calendar#
P!gina #
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
Para finalizar la tarea de forma correcta es necesario realizar la salida del bucle for e(terior
-mediante un exit. cuando la tarea ya no va a ser invocada, evitando as permanecer en un
bucle infinito# Para conocer si una tarea puede ser llamada podemos usar la funcin
Is_Callable(Task_Id) y la funcin Current_Task para obtener el Task_Id de la tarea# Estas
funciones las encontramos en el paquete Ada.Task_Identification#
Ejercicio 7
5ise:e en $da un ejecutivo c.clico para las tareas mostradas en la siguiente tabla&
!area ! 5
$ )2 )2 '3
> )2 )2 ?
23 23 2
5 23 23 @
E '33 '33 )
Es necesario definir el superperiodo del sistema, as como el periodo secundario# /odele
las tareas en un paquete y utilice este paquete en el modelo del ejecutivo cclico# ,e debe
mostrar por pantalla un mensaje al final de la ejecucin de cada una de las tareas y otro
mensaje indicando el final de cada uno de los marcos#
Ejercicio 8
Aaciendo uso de los objetos creados en los ejercicios @, 2 y B modele un sistema
compuesto por los siguientes elementos&
Cn monitor -creado en el ejercicio !.#
Cn semforo -creado en el ejercicio " o el #. que se utilizar para sincronizar tareas#
%os tarea peridicas -tomar como referencia las creadas en los ejercicios $ y #. con
periodos de )333 milisegundos y 2333 milisegundos, respectivamente, y con
momentos de activacin en '333 y )233 milisegundos con un plazo igual a la mitad
de sus periodos#
,u funcionalidad consistir en escribir por pantalla -*aciendo uso del monitor
'
.
un mensaje compuesto por el identificador de la tarea
)
y la *ora en formato
D**&mm&ssE -por ejemplo& /Soy la tarea Task1130 y son las
[18:30:12]01#
Estas tareas deben comprobar que no se *a incumplido el plazo y, en caso de que
se *aya incumplido, *acer uso del semforo, lanzar un evento para activar una
tercera tarea y bloquearse durante dos veces su periodo para, posteriormente,
volver a su funcionamiento normal#
P!gina $
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
Esta tercera tarea se encargar de monitorizar los eventos lanzados por la tareas
peridicas# ,i cualquiera de las dos tareas anteriores lanza un evento por *aber
incumplido sus plazos, debe mostrar por pantalla qu+ tarea lo *a incumplido# Para
ello es necesario pasar el identificador de la tarea mediante el semforo#
/ientras, una cuarta tarea le pedir al usuario que introduzca un cdigo cada 2
segundos# ,i ese cdigo coincide con 012341, la ejecucin sigue su curso normal# En
caso contrario, o si se tarda ms de '3 segundos en dar una respuesta, se lanzar un
mensaje por pantalla informando de este *ec*o y se abortarn las tareas
F
#
Cn procedimiento principal que nos permitir probar el sistema#
El monitor, los semforos y las tareas peridicas debern ser encapsuladas dentro de un
paquete#
+ ,otas
-'.
!en en cuenta que ser necesario pasarle a las tareas el monitor como parmetro# %o mismo
ocurrir con el semforo#
-).
Para obtener el identificador de una tarea podemos *acer uso de la funcin Current_Task de la
biblioteca Ada.Task_Identification#
-F.
Para no tener que pasarle punteros de tareas a esta cuarta tarea, podemos 0suicidarnos1 y desde
el procedimiento principal monitorizar si la cuarta tarea an es llamable -4sGallable. y abortar el
resto de tareas desde el procedimiento principal#
E"&/e0- 1 ")/!-s 2e */ese"&-+'."
%a memoria asociada a esta actividad deber entregarse como m(imo el d.a 12 de Ma3o
de 212 a trav+s de la tarea correspondiente que se *abilitar en el espacio virtual de la
asignatura# Ho se tendrn en cuenta las memorias entregadas fuera de plazo# Ho se admitirn
memorias entregadas por e;mail# %a entrega de la memoria tendr que realizarse
e(clusivamente en formato electrnico -no es necesario imprimirla para su entrega.#
%a memoria de la prctica *a de incluir una breve discusin de la solucin planteada para
cada ejercicio -no ms de ' pgina., *aciendo especial *incapi+ en aquellas partes del cdigo
fuente que considere ms relevante# $s mismo, la memoria 4a de incluir todo el cdi5o
fuente y una seccin en la que se indique brevemente cmo compilar y ejecutar#
ada estudiante deber subir un nico arc*ivo comprimido cuyo nombre consistir en su
5H4 -ejemplo& 2I?JB2@#tar#gz.# $l descomprimir el fic*ero, se deber obtener la siguiente
estructura de directorios/arc*ivos&
&**M*6txt ontendr los datos del estudiante#
memoria ontendr la memoria en formato pdf#
src ontendr el cdigo fuente de las soluciones -un subdirectorio
por ejercicio.#
P!gina %
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
E(-4-+'."
,e valorar la memoria aportada y el grado de adquisicin de las competencias con la
realizacin de una actividad en laboratorio, similar a las prcticas realizadas anteriormente, en
la fec*a de la convocatoria ordinaria y/o e(traordinaria#
En dic*a actividad de laboratorio, reali7ada de manera individual, ser posible utili7ar la
memoria con las soluciones de los ejercicios previamente resueltos# El profesor responsable
comprobar que el contenido de la memoria se corresponde con la entregada anteriormente a
trav+s de la tarea correspondiente de ampus Kirtual#
5'$4')0/-,6- $7s'+-
D>C"H,3FE >urns, $#, Lellings, $#, ,istemas en !iempo "eal y %enguajes de Programacin
-FM Edicin., $ddison;Lesley )33F#
D595"4%%I?E !utorial Neb $da ; *ttp&//NNN#infres#enst#fr/Opautet/$daI2/aI2list#*tm
P!gina &
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
A"e9) : F'+;e/)s #-2s
Ejercicio 2 pkg_tareaa!s
package pkg_tarea is
task type tarea_periodica_t;
end pkg_tarea;
Ejercicio 3 pkg_tareaa!s
package pkg_tarea is
task type tarea_periodica_t is
entry MultiplicaX2 (valor : in out integer);
entry MultiplicaX10 (valor : in out integer);
end tarea_periodica_t;
end pkg_tarea;
Ejercicio 4 pkg_"onitora!s
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package pkg_monitor is
type monitor_t is limited private;
procedure imprimir_msg(monitor : in out monitor_t; msg : in String);
procedure get_msg(monitor : in out monitor_t;
msg : out Unbounded_String);
private
type Status is (LIBRE, OCUPADO);
protected type monitor_t is
entry imprimir_msg(msg : in String);
entry imprimir_aux(msg : in String);
entry bloquear;
procedure liberar;
private
estado : Status := LIBRE;
estado_aux : Status := LIBRE;
end monitor_t;
end pkg_monitor;
P!gina '
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
Ejercicio 5 pkg_se"a!s
package pkg_sem is
type sem_t is limited private;
procedure signal(sem : in out sem_t);
procedure wait(sem : in out sem_t);
private
protected type sem_t(valor_inicial : integer := 0) is
entry wait;
procedure signal;
private
valor_sem : integer := valor_inicial;
end sem_t;
end pkg_sem;
Ejercicio 6 pkg_tareaa!s
with pkg_sem; use pkg_sem;
package pkg_tarea is
task type tarea_suceso_t(sem : pkg_sem.p_sem);
end pkg_tarea;
Ejercicio 7 tareasa!s
with Ada.Real_Time; use Ada.Real_Time;
with Ada.Text_IO; use Ada.Text_IO;
package tareas is
procedure A;
procedure B;
procedure C;
procedure D;
procedure E;
end tareas;
P!gina 1(
Programacin Concurrente y Tiempo Real (13/14) Trabajo sobre Ada
Ejercicio 8 pkg_tareaa!s
with pkg_monitor; use pkg_monitor;
with pkg_sem; use pkg_sem;
package pkg_tarea is

function time_to_string return string;
type p_integer is access integer;
task type tarea_periodica_t(monitor : p_monitor;
sem : p_sem;
per : integer);
task type tarea_eventos_t(monitor : p_monitor; sem : p_sem);
task type tarea_codigo_t(monitor : p_monitor);
end pkg_tarea;
P!gina 11