EXAMEN SISTEMAS INFORMATICOS DE TIEMPO REAL.

4 Febrero 2002
Pregunta 1 (1.5 p):
Definir e implementar un paquete en el que se proporcione el tipo racional (nmero racional con
numerador y denominador) y las operaciones suma, resta, multiplicacin y divisin. Todas ellas a travs
de los operadores +,-,* y /. El racional resultado de las operaciones deber ser simplificado por 2,3,5,7 y
10 en el caso de que sea mltiplo de alguno de ellos.
return Racional;
package Racionales is
type Racional is
record
Numerador : Integer;
Denominador : Integer;
end record;
function "+" (
Left,
Right : Racional )
return Racional;
function "*" (
Left,
Right : Racional )

function "-" (
Left,
Right : Racional )
return Racional;
function "/" (
Left,
Right : Racional )
return Racional;
end Racionales;

package body Racionales is

function racionaliza(numero:racional) return racional;
function "+" (
Left,
Right : Racional )
return Racional is
Result : Racional;
begin
Result.Numerador:=Left.Numerador*Right.Denominador+Left.Denominador*
Right.Numerador;
Result.Denominador:=Left.Denominador*Right.Denominador;
return Racionaliza(Result);
end "+";
function "*" (
Left,
Right : Racional )
return Racional is
Result : Racional;
begin -- stub
Result.Numerador:=Left.Numerador*Right.Numerador;
Result.Denominador:=Left.Denominador*Right.Denominador;
return Racionaliza(Result);
end "*";
function "-" (
Left,
Right : Racional )
return Racional is
Result : Racional;
begin
Result.Numerador:=Left.Numerador*Right.Denominador-Left.Denominador*
Right.Numerador;
Result.Denominador:=Left.Denominador*Right.Denominador;
return Racionaliza(Result);

end "-";
function "/" (
Left,
Right : Racional )
return Racional is
Result : Racional;
begin -- stub
Result.Numerador:=Left.Numerador*Right.Denominador;
Result.Denominador:=Left.Denominador*Right.Numerador;
return Racionaliza(Result);
end "/";
function Racionaliza (
Numero : Racional )
return Racional is
Result : Racional;
Valores : array (1 .. 4) of Integer := (2, 3, 5, 7);
begin -- stub
result.numerador:=numero.numerador;
result.denominador:=numero.denominador;
for I in 1..4 loop
while ((result.Numerador mod Valores(I))=0) and ((result.
Denominador mod Valores(I))=0) loop
result.Numerador:=result.Numerador/Valores(I);
result.Denominador:=result.Denominador/Valores(I);
end loop;
end loop;
return Result;
end Racionaliza;
end Racionales;
Pregunta 2 (1.5 p):
Se desea crear un tipo protegido denominado Key. Este tipo de objeto no es ms que una clave entera que
se fija a un valor determinado por el usuario. Una vez definido el valor su modificacin slo es posible si
se conoce el valor clave anterior. Una variable Key devuelve a travs de una entrada protegida un valor
TRUE o FALSE como respuesta a la entrada de una clave, si la clave de entrada coincide con la
almacenada se devuelve TRUE, en caso contrario FALSE. Generar la especificacin e implementacin
del tipo protegido.
NOTA: el tipo protegido deber proporcionar tres tipos de llamadas: Asignar_clave(clave) cuando no hay
valor de clave asignado, Valor_clave(clave) que devuelve True o false en funcin de si coincide con el
valor asignado y Cambiar_clave(clave_nueva,clave_vieja,exito) que permite modificar la clave
devolviendo el valor true en la variable xito si la clave_vieja coincide con el anterior valor de clave o
false en caso contrario.
package claves is
protected type key is
entry asignar_clave(clave:integer);
procedure Cambiar_clave(clave_nueva:integer;clave_vieja:integer;exito:out boolean);
function valor_clave(clave:integer) return boolean;
private
clave_asignada: Boolean:=False;
codigo_clave:integer:=0;
end key;
end claves;
package body Claves is
protected body Key is
entry Asignar_Clave (
Clave : Integer ) when Clave_Asignada = False is

begin
Codigo_Clave:=Clave;
Clave_Asignada:=True;
end Asignar_Clave;
procedure Cambiar_Clave (
Clave_Nueva :
Integer;
Clave_Vieja :
Integer;
Exito
: out Boolean ) is
begin
if (Clave_Vieja=Codigo_Clave) then
Codigo_Clave:=Clave_Nueva;
Exito:=True;
else
Exito:=False;
end if;
end Cambiar_Clave;
function Valor_Clave (
Clave : Integer )
return Boolean is
begin
return (Codigo_Clave=Clave);
end Valor_Clave;
end Key;
end Claves;
Pregunta 3 (2.0 p):
Se quiere controlar el acceso a un recurso mediante un objeto protegido de Ada. Para realizar este control
de acceso se utilizar la secuencia: Adquirir Usar Liberar (donde adquirir y liberar sern las
operaciones proporcionadas por el objeto protegido). Existen dos tipos de procesos (A y B)que necesitan
acceder al recurso segn las reglas siguientes:
Los procesos As y los Bs no pueden acceder al recurso simultneamente. Es necesario que
accedan de forma mutuamente excluyente.
Los procesos As pueden acceder al recurso simultneamente hasta un mximo de 10.
Los procesos Bs pueden acceder al recurso simultneamente hasta un mximo de 5.
Generar la especificacin e implementacin del tipo protegido as como el esqueleto de las tareas
tipo A y B con la secuencia de llamadas a realizar para acceder al recurso.
protected Control is
entry Adquirir_A;
procedure Liberar_A;
entry Adquirir_B;
procedure Liberar_B;
private
Conta :Integer :=0;
Contb :Integer :=0;
end Control ;
protected body Control is
entry Adquirir_A when Contb = 0 and Conta < 10 Iis begin Conta := Conta + 1;
end Adquirir_A;
procedure Liberar_A is
begin
Conta :=Conta -1;
end Liberar_A;
entry Adquirir_B when Conta = 0 and Contb < 5 Iis begin Contb := Contb + 1;
end Adquirir_B;
procedure Liberar_B is
begin
Contb :=Contb -1;
end Liberar_B;

end Control;
task Tareas_A body is
begin
loop
Adquirir_A;
Usar_A;--no est implementado pq es el cdigo de uso
Liberar_A;
end;
end;
Pregunta 4 (1.5 p):
Dado el siguiente conjunto de tareas definidas como T = (C i , Pi , Di ) (cmputo, periodo, deadline),
determinar sin son planificables en un sistema de planificacin basado en prioridades y bajo qu criterio
de asignacin de las mismas.
T1=(1,8,8); T2=(2,10,5); T3=(5,30,30);
Analisis de utilizacin
U=1/8+2/10+5/30<U(3) por lo tanto es planificable
Supongamos que los el tiempo de cambio de contexto fuera de 0.5 unidades de tiempo. Como
influira en el resultado anterior. Justificar numricamente.
Se realiza el anlisis de utilizacin aadiebdo 2*tiempo de cambio de contexto a cada computo de las
tareas
U=2/8+3/10+6/30<U(3) por lo tanto tambin sera planificable
Pregunta 5 (1.5 p):
Consideremos los siguientes fragmentos de cdigo:
Caso B
select
T.Call; -- an entry call to task T
Flag := A;
else
delay 10.0;
Flag := B;
-- code taking 2 seconds to execute
end select;

Caso A
select
T.Call; -- an entry call to task T
Flag := A;
or
delay 10.0;
Flag := B;
-- code taking 2 seconds to execute
end select;

Caso C
select
delay until clock+10.0;
Flag := A;
then
abort
T.Call; -- an entry call to task T
Flag := B;
-- code taking 2 seconds to execute
end select;
Asumiendo que la ejecucin de T.Call emplea 5 segundos cuando es atendida y la asignacin del valor de
Flag no consume tiempo de CPU, determinar cual es el valor de la variable Flag en cada una de las
siguientes situaciones:
i.
ii.
iii.
iv.

T.Call
T.Call
T.Call
T.Call

est disponible cuando se ejecuta el select

NO est disponible cuando se ejecuta el select sino 14 segundos despus
est disponible cuando se ejecuta el select sino 2 segundos despus
est disponible cuando se ejecuta el select sino 8 segundos despus

VALOR DE FLAG
CASO A
CASO B

i
A
A

ii
B
B

iii
A
B

iv
A
B

CASO C

Pregunta 6 (2.0 p):

Dado el comportamiento del tipo tampn circular de enteros protegido visto en clase, especificar e
implementar una tarea servidora de un tampn circular de 10 elementos con la misma funcionalidad al
cual se podr acceder por medio de los servicios. Codificar tambin el cuerpo de una tarea productora y
otra consumidora de enteros.
Esta_lleno: devolver True si est lleno, False en caso contrario
Esta_vacio: devolver True si est vacio, False en caso contrario
Insertar: se le pasar un valor entero que se insertar en la posicin adecuada siempre que exista espacio.
En caso contrario la tarea invocante permanecer suspendida
Sacar: devolver un valor entero de la posicin adecuada siempre que exista al menos uno en la
estructura. En caso contrario la tarea invocante permanecer suspendida
Listar: Listar el contenido del tampn
ESPECIFICACIN
task Control_tampon is
entry esta_lleno(valor:out boolean);
entry esta_vacio(valor:out boolean);
entry Insertar(valor:integer);
entry sacar(valor: out integer);
entry listar;
end Control_tampon;
task productora;
task consumidora;
IMPLEMENTACIN
task body Control_Tampon is
Max : Integer := 10;
type Tampon is array (1 .. Max) of Integer;
type Buffer is
record
Cola : Tampon;
Primero,
Ultimo : Positive := 1;
Contador : Integer := 0;
end record;
Instancia : Buffer;
Periodo : Ada.Real_Time.Time_Span := Milliseconds (600);
Siguiente : Ada.Real_Time.Time;
begin
Siguiente:=Clock+Periodo;
loop
select
accept Esta_Lleno (
Valor : out Boolean ) do
Valor:=(Instancia.Contador=Max);
end Esta_Lleno;
or
accept Esta_Vacio (
Valor : out Boolean ) do
Valor:=(Instancia.Contador=0);
end Esta_Vacio;
or
when (Instancia.Contador/=0) =>
accept Sacar (
Valor : out Integer ) do
Valor:= Instancia.Cola(Instancia.Ultimo);

Instancia.Ultimo := (Instancia.Ultimo mod Max) +1;

Instancia.Contador := Instancia.Contador - 1;
end Sacar;
or
when (Instancia.Contador<Max) =>
accept Insertar (
Valor : Integer ) do
Instancia.Cola(Instancia.Primero) := Valor;
Instancia.Primero := (Instancia.Primero mod Max)+1 ;
Instancia.Contador := Instancia.Contador + 1;
end Insertar;
or
accept Listar do
declare
I,J : Integer;
begin
J := instancia.Contador;
I := instancia.Ultimo;
loop
exit when J = 0;
Ada.Integer_Text_Io.Put(I);
Ada.Text_Io.Put(": => ");
Ada.Integer_Text_Io.Put(instancia.Cola(I));
Ada.Text_Io.New_Line;
I := (I mod max) +1;
J:=J-1;
end loop;
end;
end Listar;
or
delay until Siguiente;
end select;
Siguiente:=Siguiente+Periodo;
end loop;
end Control_Tampon;
--***********************************************************************************
task body productora is
task body consumidora is
i:integer:=0;
i:integer;
begin
begin
loop
loop
control_tampon.insertar(i);
control_tampon.sacar(i);
end loop;
put(i);
end productora;
end loop;
end consumidora;