Tema 3
Download
1 / 81

Tema3 - PowerPoint PPT Presentation


  • 136 Views
  • Uploaded on

presentacion tema 3

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Tema3' - guest41486


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Tema 3 l.jpg

Tema 3

Programación concurrente


Objetivos y bibliograf a l.jpg
Objetivos y bibliografía

  • Objetivos:

    • Recordar el concepto de ejecución concurrente.

    • Entender el la función que realiza el planificador a corto plazo.

    • Conocer las facilidades que ofrece Ada’95 para la programación concurrente.

    • Entender el problema de los interbloqueos y conocer los mecanismos que ofrece Ada’95 para evitarlos.

  • Bibliografía

    • “Sistemas de tiempo real y lenguajes de programación” (3a Edición) A.Burns y A. Wellings. Editorial Addison Wesley.


Ndice l.jpg
Índice

3.1.- Introducción. Definición de conceptos.

3.2.- Declaración y uso de tareas en Ada’95.

3.3.- Comunicación y sincronización de tareas.

Variables compartidas

Paso de mensajes.

3.4.- Casos de Estudio.


Introducci n l.jpg

Nuevo

Acabado

Preparado

Ejecución

Suspendido

Introducción

  • Proceso = programa en ejecución.

  • Los procesos se ejecutan concurrentemente en la misma CPU

  • El sistema operativo mantiene un PCB por proceso donde guarda toda su información (atributos).

  • Los posibles estados de los procesos son:


Introducci n5 l.jpg
Introducción

  • En los lenguajes secuenciales sólo existe un hilo de control.

  • En los lenguajes concurrentes podemos definir más de un hilo de control dentro de una misma aplicación (programa).

  • En sistemas centralizados, es necesario conmutar la ejecución de los procesos que se encuentran activos. La conmutación la lleva a cabo elplanificador (S.O).


Introducci n6 l.jpg
Introducción

  • En la conmutación el planificador decide, según un algoritmo de planificación, que proceso se pone en ejecución.

  • Los algoritmos de planificación pueden ser de muchos tipos, basados en prioridades, round-robin, FCFS, etc.

  • En los STR es el planificador el encargado de hacer cumplir los requerimientos temporales de la aplicación.


Introducci n7 l.jpg
Introducción.

  • Planificadores estáticos

    • Como en el ejemplo anterior, la planificación se realiza atendiendo a criterios fijos, p.e. prioridad de un proceso.

    • Es fundamental la asignación de de prioridades para que un sistema funcione correctamente, es decir, cumpla sus restricciones temporales.


Slide8 l.jpg

T1 = { 100, 20

T2 = { 150, 40 }

T3 = { 300, 100 }

+

T3

T2

T1

-

250

50

100

150

200

300

350

400

+

T1

T3

-

T2

250

50

100

150

200

300

350

400

Introducción.

NO PLANIFICABLES !!!


Slide9 l.jpg

+

T1

T2

T3

-

50

100

150

200

250

300

350

400

Introducción.

T1 = { 100, 20 }

T2 = { 150, 40 }

T3 = { 300, 100 }


Introducci n10 l.jpg
Introducción.

  • Planificadores de tiempo real:

    • Como hemos dicho, un planificador proporciona un algoritmo o política de gestión de procesos.

    • Un conjunto de procesos es factible o planificable si existe un planificador que cumpla las restricciones o precondiciones.

    • En sistemas de tiempo real críticos, la precondición son los plazos límites.

    • Un planificador esóptimosi es capaz de planificar todos los conjuntos de procesos que cualquier otro puede.

    • Los planificadores pueden basarse en algoritmos estáticos o dinámicos


Ndice11 l.jpg
Índice

3.1.- Introducción. Definición de conceptos.

3.2.- Declaración y uso de tareas en Ada’95.

3.3.- Comunicación y sincronización de tareas.

Variables compartidas

Paso de mensajes.

3.4.- Casos de Estudio.


Tareas en ada95 l.jpg
Tareas en Ada95

  • Concepto de tarea

    • Ada permite la programación de actividades concurrentes dentro de un programa mediante el concepto de tarea

    • Dentro de un programa en Ada se puede definir múltiples tareas. Cada una de ellas se ejecuta mediante un hilo de ejecución

      • Si el s.o. soporta hilos de ejecución, el compilador los utiliza

      • Sino, los hilos son implementados por el “run-time” del lenguaje

    • Las tareas se definen en una cierta unidad (subprograma, p.ej.)

      • Las tareas comparten las variables globales definidas en su unidad

      • Además, pueden tener variables locales (privadas)


Tareas en ada9513 l.jpg
Tareas en Ada95

  • Concepto de tarea (ii)

    • Existe una relación de parentesco entre la “tarea padre” (que ejecuta la unidad donde se definen las tareas) y dichas tareas:

      • Las tarea padre y las tareas hijas comienzan su ejecución a la vez

      • La tarea padre espera la finalización de TODAS sus tareas hijas

    • El estándar Ada define que las tareas se ejecutan en paralelo, entre sí y con respecto a su “tarea padre”:

      • En principio, Ada no define ninguna planificación en concreto

      • Es como si cada tarea la ejecutara un procesador virtual distinto

    • El Anexo de Tiempo Real sí permite la definición de políticas de planificación (lo veremos más adelante)


Tareas en ada 95 l.jpg
Tareas en Ada’95

  • Creaciónde una tarea:

    • Para crear una tarea en Ada95 simplemente hay que definirla dentro del programa (creación implícita)

    • En concreto, hay que definir cada una de sus dos partes:

      (1) Especificación

      (2) Cuerpo

task CONTROL_NIVEL;

task body CONTROL_NIVEL is

-- Declaración de variables, tipos, etc.

begin

loop

leer_sensor(nivel);

calcula_accion(nivel, accion);

envia_accion(accion);

delay until PERIODO;

end loop;

end CONTROL_NIVEL;


Ejercicio 1 l.jpg
Ejercicio 1

WITH Text_Io; USEText_Io;

PROCEDUREEjercicio1 IS

TASK Hello;

TASKBODYHelloIS

I : Integer := 0;

BEGIN

Null;

ENDHello;

  • TASK Word;

  • TASK BODY Word IS

  • I : Integer := 0;

  • BEGIN

  • NULL;

  • END Word;

  • BEGIN

  • Put_Line("Programa Principal");

  • END Ejercicio1;


Ejercicio 1 soluci n l.jpg
Ejercicio 1-Solución

WITH Text_Io;

USEText_Io;

PROCEDURE Ejemplo1 IS

TASK Hello;

TASKBODYHelloIS

I : Integer := 0;

BEGIN

WHILE I<5

LOOP

Put_Line("Hello");

DELAY (0.5);

I:=I+1;

END LOOP;

ENDHello;

  • TASK Word;

  • TASK BODY Word IS

  • I : Integer := 0;

  • BEGIN

  • WHILE I<5

  • LOOP

  • Put_Line(“Word");

  • DELAY (0.7);

  • I:=I+1;

  • END LOOP;

  • END Word;

  • BEGIN

  • Put_Line("Programa Principal");

  • END Ejemplo1;


Ejemplo 1 l.jpg
Ejemplo 1

task body PRODUCTORis

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni > 15;

delay0.7;

whileLLENO(T)loop

delay1.0;

end loop;

ANYADIR(T, i);

Text_io.put("He anyadido el item: ");

Ada.Integer_text_IO -put(i); new_line;

end loop;

end PRODUCTOR;

Tareas1.adb

Tampones.adb

Tampones.ads

with TEXT_IO;useTEXT_IO;

withAda.Integer_Text_IO; useAda.Integer_text_IO;

with TAMPONES;useTAMPONES;

procedureTareas1 is

T: TAMPON_CIRCULAR;

taskPRODUCTOR;

taskCONSUMIDOR;

……

begin

INICIALIZAR(T);

put_line("Programa de test del tampon concurrente");

end Tareas1;

task bodyCONSUMIDORis

X : Integer

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni > 15;

whileVACIO(T) loop

delay1.0;

end loop;

SACAR(T, X);

put("He sacado el item:");

Ada.Integer_text_IO.put(X); new_line;

delay1.1;

end loop;

end CONSUMIDOR;


Tipo tarea l.jpg
Tipo Tarea.

  • Uno de los problemas de la definición de una tarea es cuando se requieren varias instancias de una actividad de características similares.

  • Por ejemplo queremos 3 Productores y 2 Consumidores.

  • Una posible solución es la de replicar las tareas tantas veces como sea necesario.

  • La solución anterior es muy ineficiente, por lo que seria necesaria la posibilidad de definir un tipo tarea y a partir de el crear las instancias que hicieran falta.


Tipo tarea19 l.jpg
Tipo Tarea.

Definición :

task type PRODUCTOR;

Instanciación :

Implementación :

-- Definición de 3 procesos productores

P1, P2, P3 : PRODUCTOR;

task body PRODUCTOR is

i : INTEGER:= 0;

begin

loop

...

ANYADIR(T, i);

...

end loop;

end PRODUCTOR;


Tareas 2 l.jpg
Tareas 2

task bodyPRODUCTORis

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni > 15;

delay0.7;

whileLLENO(T)loop

delay1.0;

end loop;

ANYADIR(T, i);

Text_io.put(" He anyadido el item: ");

Ada.Integer_text_IO -put(i); new_line;

end loop;

end PRODUCTOR;

Tareas2.adb

Tampones.adb

Tampones.ads

withTEXT_IO;use TEXT_IO;

with Ada.Integer_Text_IO; use Ada.Integer_text_IO;

withTAMPONES;use TAMPONES;

procedureTareas2is

T: TAMPON_CIRCULAR;

task typePRODUCTOR;

task typeCONSUMIDOR;

……

P1,P2 : PRODUCTOR;

C1, C2 : CONSUMIDOR;

begin

INICIALIZAR(T);

put_line("Programa de test del tampon concurrente");

endTareas2;

task body CONSUMIDORis

X : Integer

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni > 15;

while VACIO(T)loop

delay 1.0;

end loop;

SACAR(T, X);

put(" He sacado el item: ");

Ada.Integer_text_IO.put(X); new_line;

delay1.1;

end loop;

end CONSUMIDOR;


Tareas identificaci n l.jpg
Tareas. Identificación

  • Cuando definimos un tipo tarea, también podemos definir una serie de parámetros de entrada a la tarea.

  • Esta facilidad nos puede servir para identificar las diferentes instancias.

  • La única restricción en el paso de parámetros en la instanciación de tareas, es que éstos deben de ser de tipo discreto


Tareas 3 l.jpg
Tareas 3

taskbody PRODUCTORis

i : Integer:= 0;

begin

loop

i := i + 1;

exitwheni > 15;

delay0.7;

whileLLENO(T)loop

delay1.0;

endloop;

ANYADIR(T, i);

put(“Productor “);Ada.Integer_text:io.put(pid);

Text_io.put(" y he anyadido el item: ");

Ada.Integer_text_IO -put(i); new_line;

endloop;

end PRODUCTOR;

Tareas3.adb

Tampones.adb

Tampones.ads

with TEXT_IO;use TEXT_IO;

with Ada.Integer_Text_IO;use Ada.Integer_text_IO;

withTAMPONES;useTAMPONES;

procedure Tareas3 is

T: TAMPON_CIRCULAR;

task typePRODUCTOR (pid :INTEGER);

task typeCONSUMIDOR(cid : INTEGER);

……

P1 : PRODUCTOR(pid =>1);

P2 : PRODUCTOR(pid=>2);

C1 : CONSUMIDOR(cid=>1);

begin

INICIALIZAR(T);

put_line("Programa de test del tampon concurrente");

endTareas3;

taskbodyCONSUMIDORis

X : Integer

i : Integer:= 0;

begin

loop

i := i + 1;

exitwheni > 30;

whileVACIO(T)loop

delay1.0;

endloop;

SACAR(T, X);

put(“ Consumidor “);Ada.Integer_text:io.put(cid);

put(" y he sacado el item: ");

Ada.Integer_text_IO.put(X); new_line;

delay1.1;

endloop;

endCONSUMIDOR;


Tareas 4 l.jpg
Tareas 4

task bodyPRODUCTOR is

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni > n;

delay0.7;

whileLLENO(T)loop

delay1.0;

end loop;

ANYADIR(T, i);

put(“Producdor “);Ada.Integer_text:io.put(pid);

Text_io.put(" y he anyadido el item: ");

Ada.Integer_text_IO -put(i); new_line;

end loop;

endPRODUCTOR;

Tareas4.adb

Tampones.adb

Tampones.ads

with TEXT_IO;useTEXT_IO;

withAda.Integer_Text_IO;useAda.Integer_text_IO;

withTAMPONES;useTAMPONES;

procedure Tareas4is

T: TAMPON_CIRCULAR;

task typePRODUCTOR(pid :INTEGER; n:Integer);

task typeCONSUMIDOR(cid : INTEGER: n:Integer);

……

P1 : PRODUCTOR(pid =>1, n=>15);

P2 : PRODUCTOR(pid=>2, n =>20);

C1 : CONSUMIDOR(cid=>1, n=>20);

begin

INICIALIZAR(T);

put_line("Programa de test del tampon concurrente");

endTareas4;

task bodyCONSUMIDORis

X : Integer

i : Integer:= 0;

begin

loop

i := i + 1;

exit wheni >n;

whileVACIO(T)loop

delay1.0;

end loop;

SACAR(T, X);

put(“ Consumidor “);Ada.Integer_text:io.put(cid);

put(" y he sacado el item: ");

Ada.Integer_text_IO.put(X); new_line;

delay1.1;

end loop;

endCONSUMIDOR;


Tareas din micas l.jpg
Tareas Dinámicas.

  • Hasta ahora hemos visto la creación de tareas de forma estática, es decir, sabemos cuantas tareas se pondrán en ejecución en tiempo de compilación

  • Sin embargo, esta no es la única forma de definir tareas en Ada, también se pueden crear tareas de manera dinámica, es decir, en tiempo de ejecución.


Tareas din micas25 l.jpg
Tareas dinámicas.

Definimos un tipo tarea

Creamos un tipo puntero

del tipo tarea (referencia)

declare

task typeT;

typeREF_T is accessT;

P: REF_T;

Q: REF_T := new T;--Q arranca ahora mismo

begin

P := new T;-- P arranca ahora

Q := P;

•••

end;

Mediante la instrucción

new arrancamos las tareas

A partir de este momento

la tarea a la que apuntaba

Q sigue ejecutándose, pero

ya no hay forma de hacer

referencia a ella.


Tareas est ticas vs din micas l.jpg
Tareas. Estáticas vs. Dinámicas

DINÁMICAS

  • No dependen de la unidad donde se crean sino de la unidad donde se declara el tipo puntero.

  • Se activan al ejecutarse el operador new

  • Pueden seguir existiendo aunque termine la unidad progenitora

ESTÁTICAS

  • Dependen del bloque , subprograma o cuerpo donde se definan.

  • Se activan justo antes de empezar la ejecución de la unidad.

  • No pueden terminar hasta que terminen todas las tareas que dependen de ella.


Tareas terminaci n l.jpg
Tareas. Terminación.

  • La terminación de una tarea puede ser debida a :

    • La tarea termina la ejecución del cuerpo.

    • La tarea se pone de acuerdo con otras tareas para terminar conjuntamente.

    • Es abortada por otra tarea.

    • Se produce una excepción y finaliza la ejecución.

    • Suicidio, ejecuta la instrucción “fin_de_ejecución” terminate.


Ndice28 l.jpg
Índice

3.1.- Introducción. Definición de conceptos.

3.2.- Declaración y uso de tareas en Ada’95.

3.3.- Comunicación y sincronización de tareas.

Variables compartidas

Paso de mensajes.

3.4.- Casos de Estudio.


Comunicaci n entre tareas l.jpg
Comunicación entre tareas.

  • Las tareas o procesosnecesitancomunicarse y sincronizarse.

  • Existen dos formas para realizar esta comunicación:

    • Variables Compartidas

    • Paso de Mensajes


Comunicaci n entre tareas30 l.jpg
Comunicación entre tareas.

  • Variables Compartidas

    Tienen como problema las condiciones de carrera, que se suelen solucionar mediante la exclusión mutua.

    • Semáforos,

    • Monitores y variables de condición

    • Regiones críticas condicionales

  • Paso de Mensajes

    • Comunicación asincrónica.

    • Comunicación sincrónica (cita)

    • Invocación remota (cita extendida).


  • Comunicaci n orientada a datos l.jpg
    Comunicación Orientada a Datos

    • Ada permite eliminar los problemas de coordinación y comunicación con datos suministrando la abstracción tipo protegido.

    • Los tipos protegidos son similares a los monitores y a las regiones críticas condicionales

    protected typeVariable_Compartida (Valor_inicial:integer)is

    functionLeer return integer;

    procedureEscribir (valor: integer);

    procedureIncrementar (N: integer);

    private

    Dato : integer;

    end Variable_Compartida;


    Ndice32 l.jpg
    Índice

    3.1.- Introducción. Definición de conceptos.

    3.2.- Declaración y uso de tareas en Ada’95.

    3.3.- Comunicación y sincronización de tareas.

    Variables compartidas

    Paso de mensajes.

    3.4.- Casos de Estudio.


    Objetos protegidos l.jpg
    Objetos Protegidos.

    • Los objetos protegidos implementan un protocolo basado en lectores/escritores.

    • Según este protocolo:

      • Número de lectores ilimitado.

      • Sólo un escritor.

      • Escritores y lectores no pueden coexistir.


    Objetos protegidos34 l.jpg
    Objetos Protegidos.

    • Para llevar a cabo este protocolo Ada distingue el modo de acceso :

      • Procedure: acceso de lectura/escritura excluyente a los datos.

      • Function : acceso se sólo lectura a datos.

      • Proceduresy Functions son excluyentes entre ellos.

    Objeto Protegido

    Procedure

    Lectura/Escritura

    Datos

    Function

    Sólo Lectura


    Objetos protegidos35 l.jpg
    Objetos Protegidos.

    • También podemos definir otro tipo de operaciones sobre el objeto protegido denominadasentry

      Entry : Es un procedure sobre el que identifica una condición (guarda) de acceso. Si la guarda es FALSE la tarea invocante se suspende en la barrera (cola interna) hasta que la guarda sea TRUE y no queda ninguna tarea ejecutándose en el objeto protegido.

    protected typeVariable_Compartida (Valor_inicial:integer)is

    functionLeer return integer;

    entryEscribir (valor: integer);

    procedureIncrementar (N: integer);

    private

    Dato : integer;

    end Variable_Compartida;

    entryEscribir (valor: integer)whenC1 is

    begin

    ....

    endEscribir;


    Objetos protegidos36 l.jpg
    Objetos Protegidos .

    Objeto Protegido

    Lectura/Escritura

    Procedure

    Sólo Lectura

    Datos

    Function

    Entry

    Cola interna de tareas

    que esperan en un Entry

    a que su guarda sea verdadera

    (TRUE)


    Ejercicio l.jpg

    13

    N-1

    0

    12

    1

    11

    10

    2

    9

    8

    3

    4

    5

    7

    6

    Entrada

    Salida

    Contador = 5

    Ejercicio

    • Implementar el TAMPON_ACOTADO como un tipo protegido.

    • Realizar los cambios necesarios en las tareas PRODUCTOR y CONSUMIDOR para que utilicen el tipo protegido.


    Sincronizaci n mediante tipos protegidos l.jpg
    Sincronización Mediante Tipos Protegidos.

    • Los Entry de los objetos protegidos pueden ser utilizados como elementos de sincronización de tareas.

    package bodyBarreras is

    protected body Barrera is

    entryEntrar when Cerrojo_Abierto=TRUEis

    begin

    NProcesos := NProcesos - 1;

    if NProcesos = 0then

    Cerrojo_Abierto:=FALSE;

    end if;

    end Entrar;

    procedureAbrir(N : INTEGER)is

    begin

    Cerrojo_Abierto:=TRUE;

    NProcesos := N;

    end abrir;

    end Barrera;

    end Barreras;

    packageBarreras is

    protected typeBarrera is

    entryEntrar;

    procedureAbrir(N: in INTEGER);

    private

    Cerrojo_Abierto: BOOLEAN:=FALSE;

    NProcesos : INTEGER := 0;

    end Barrera;

    end Barreras;


    Ndice39 l.jpg
    Índice

    3.1.- Introducción. Definición de conceptos.

    3.2.- Declaración y uso de tareas en Ada’95.

    3.3.- Comunicación y sincronización de tareas.

    Variables compartidas

    Paso de mensajes.

    3.4.- Casos de Estudio.


    Sincronizaci n entre tareas l.jpg
    Sincronización entre Tareas.

    • Se pueden diferenciar tres tipos paso de mensajes:

      • Asincrónica dónde el emisor envía el mensaje y continua su ejecución sin esperar confirmación.

      • Sincrónica donde el emisor se espera hasta que el receptor recoge el mensaje (CITA).

      • Invocación Remota donde el emisor se espera hasta que el receptor le envía una respuesta (CITA extendida).


    La cita en ada definici n l.jpg
    La Cita en Ada. Definición.

    • La cita o rendez-vous de Ada permite la comunicación entre tareas atendiendo al modelo cliente-servidor.

    • La tarea servidora declara los servicios que puede ofrecer a otras tareas, las cuales se comportaran como clientes.

    Control_Nivel

    taskControl_nivelis

    entryIniciar_Control;

    entry Terminar_Control;

    end Control_Nivel;

    Iniciar_Control

    Terminar_Control


    La cita en ada implementaci n l.jpg
    La Cita en Ada. Implementación.

    Especificación

    Cuerpo

    task bodyControl_nivel is

    begin

    ...

    acceptIniciar_Control;

    ...

    accept Terminar_Control;

    ...

    end Control_Nivel;

    task Control_nivel is

    entryIniciar_Control;

    entryTerminar_Control;

    end Control_Nivel;


    La cita en ada invocaci n l.jpg
    La Cita en Ada. Invocación.

    Tarea/Procedure Cliente

    Tarea Servidora

    procedureSControl is

    begin

    ...

    Control_Nivel.Iniciar_Control;

    ...

    Control_Nivel.Terminar_Control;

    ...

    end Control_Nivel;

    task bodyControl_nivel is

    begin

    ...

    acceptIniciar_Control;

    ...

    acceptTerminar_Control;

    ...

    endControl_Nivel;


    La cita en ada ejecuci n l.jpg
    La Cita en Ada. Ejecución.

    Cliente

    Servidor

    Cliente: Petición de servicio.

    Cliente: Como el Servidor está ocupado,

    se espera hasta le atienda.

    Accept

    Cliente: Una vez le contesta el Servidor

    puede continuar su ejecución.


    La cita en ada ejecuci n45 l.jpg
    La Cita en Ada. Ejecución.

    Cliente

    Servidor

    Servidor: Espera una petición de servicio.

    Accept

    Servidor :Cuando un cliente realiza una

    petición puede continuar su

    ejecución para atenderla.


    Comunicaci n la cita extendida l.jpg
    Comunicación : La Cita Extendida.

    • DEFINICIÓN:

      Para comunicar tareas también se utilizan los entry. Éstos puede tener parámetros de entrada o de salida

    Control_Nivel

    taskControl_nivelis

    entryIniciar_Control;

    entryParar_Control;

    entry Terminar_Control;

    entryDefinir_Referencia(R : FLOAT);

    entryAsociar_Rgeulador(R: Regulador);

    end Control_Nivel;

    Iniciar_Control

    Parar_Control

    Terminar_Control

    Definir_Referencia

    Asociar_Regulador


    La cita extendida l.jpg
    La Cita Extendida.

    IMPLEMENTACIÓN:

    Especificación

    Cuerpo

    task bodyControl_nivelis

    referencia :FLOAT

    begin

    ...

    accept Iniciar_Control;

    ...

    accept Definir_Referencia(R:FLOAT)

    do

    referencia :=R;

    endDefinir_Referencia;

    ...

    endControl_Nivel;

    task Control_nivel is

    entryIniciar_Control;

    entry Definir_Referencia(R:FLOAT);

    endControl_Nivel;


    La cita extendida48 l.jpg
    La Cita Extendida.

    INVOCACIÓN:

    Cliente

    Servidor

    task bodyControl_nivelis

    referencia :FLOAT

    begin

    ...

    acceptIniciar_Control;

    ...

    acceptDefinir_Referencia(R:FLOAT)

    do

    referencia :=R;

    endDefinir_Referencia;

    ...

    endControl_Nivel;

    procedureSControlis

    ref : FLOAT;

    begin

    ...

    Control_Nivel.Iniciar_Control;

    ...

    Control_Nivel.Definir_Referencia(ref);

    ...

    endControl_Nivel;


    La cita extendida49 l.jpg
    La Cita Extendida.

    • EJECUCIÓN

    Cliente

    Servidor

    Cliente: Petición de servicio.

    Cliente: Como el Servidor está ocupado,

    se espera hasta le atienda.

    Accept

    Cliente: Una vez le contesta el Servidor

    puede continuar su ejecución.

    Ejecución de la

    CITA.


    La cita extendida50 l.jpg
    La Cita Extendida.

    • EJECUCIÓN.

    Cliente

    Servidor

    Servidor: Espera una petición de servicio.

    Accept

    Servidor: Cuando un cliente realiza una

    petición puede continuar su

    ejecución para atenderla.

    Ejecución de la

    CITA.


    La cita extendida51 l.jpg
    La Cita Extendida.

    • COMENTARIOS:

      • Cuando hay varios clientes haciendo peticiones a un mismo servidor, el orden en que se atienden éstas es FCFS.

      • La tarea que realiza la petición “conoce” a la tarea servidora. Sin embargo, la tarea servidora no.

      • entry’COUNT es un atributo de la entrada que permite conocer el número de tareas que hay en la cola de peticiones.


    La cita extendida52 l.jpg
    La Cita Extendida.

    COMENTARIOS:

    Familia de entry

    Especificación

    Cuerpo

    task body Sensoris

    begin

    loop

    accept Leer_Canal(1) (x:out VALOR) do

    -- Accede al sensor del canal 1

    endLeer_Canal;

    .....

    acceptLeer_Canal(2) (x:out VALOR) do

    -- Accede al sensor del canal 1

    endLeer_Canal;

    .......

    end loop;

    end Sensor;

    taskSensoris

    entryLeer_Canal(1..5) (x:out VALOR);

    endSensor;


    Selecci n de llamadas l.jpg
    Selección de Llamadas.

    • Cuando un servidor ofrece más de un servicio, no es fácil prever el orden de invocación de un punto de entrada.

    • Un ejemplo claro es la realización de una exclusión mutua de una variable compartida por varias tareas.

    task body Variable_Compartidais

    VAR : UN_VALOR;

    begin

    loop

    acceptModificar(x :UN_VALOR) do

    VAR := x;

    end Modificar;

    entry Examinar(x : out UN_VALOR) do

    x:=VAR;

    end Examinar

    end Variable_Compartida;

    taskVariable_Compartida is

    entryModificar(x :UN_VALOR);

    entry Examinar(x : out UN_VALOR);

    end Variable_Compartida;


    Selecci n indeterminista l.jpg
    Selección Indeterminista.

    • Ada ofrece la posibilidad de realizar una selección de llamadas indeterminista.

    • Así si una tarea ofrece distintos servicios, sólo se acepta uno de ellos, el primero que se solicite.

    • Para realizar esta selección se utiliza la estructura de control select.

    select

    <alternativa 1>

    or

    <alternativa 2>

    or

    ...

    end select;


    Selecci n indeterminista55 l.jpg
    Selección Indeterminista.

    task bodyVARIABLE_COMPARTIDA is

    var : un_valor;

    begin

    acceptModificar(x: un_valor)do

    var := x;

    end Modificar

    loop

    select

    acceptModificar(x: un_valor)do

    var := x;

    end Modificar

    or

    acceptExaminar(x:out un_valor) do

    x := var;;

    end Examinar;

    end select;

    end loop;

    endVARIABLE_COMPARTIDA;

    • Ejemplo


    Formas alternativas de selecci n l.jpg
    Formas Alternativas de Selección.

    (a) Terminación sincronizada de las tareas

    select

    <alternativa 1>

    or

    <alternativa 2>

    or

    terminate;

    end select;

    Permite sincronizar la

    terminación de todas las

    tareas dependientes.

    Terminan todas a la vez.


    Formas alternativas de selecci n57 l.jpg
    Formas Alternativas de Selección.

    (b) Else

    La parte del else se

    ejecutará siempre que al

    llegar a la sentencia

    select no hayan peticiones

    pendientes.

    select

    <alternativa 1>

    or

    <alternativa 2>

    else

    ...

    end select;

    Sólo se realizara la llamada

    a la tarea T si al llegar a la

    sentencia select T está

    preparada. En cualquier

    otro caso se ejecutara la parte

    del else.

    select

    T.E(...)

    else

    ...

    endselect;


    Formas alternativas de selecci n58 l.jpg
    Formas Alternativas de Selección.

    (c) Condición con guarda

    select

    when<condición> =>

    acceptE(...)do

    ...

    endE;

    ...

    endselect;

    En este caso sólo cuando la

    guarda sea verdadera

    se considerará la alternativa del accept


    Control de la ejecuci n l.jpg
    Control de la Ejecución.

    • En los STR una de las cosas más importantes que ha de hacer el planificador es controlar las ejecuciones de las tareas, con el fin de poder asegurar que se cumplen los plazos.

    • Este “control” se implementa en Ada con la llamada “Transferencia asíncrona de Control” (ATC).

    • La ATC permite entre otras cosas:

      • Recuperación frente a errores.

      • Cambios de modo.

      • Planificación

      • Interrupciones de Usuario.


    Control de la ejecuci n60 l.jpg
    Control de la Ejecución.

    select

    Servidor.Alarma

    -- acciones de la alarma

    then abort

    parte abortable

    end select;

    select

    alternativa

    then abort

    parte abortable

    end select;

    select

    delay until DEADLINE

    then abort

    -- acciones con plazo

    parte abortable

    end select;

    Sin accepts!!


    Control de la ejecuci n61 l.jpg
    Control de la Ejecución.

    select

    delay untilDEADLINE;

    put_line(“Accion de cómputo abortada”);

    then abort

    declare

    local : FLOAT;

    begin

    loop

    --calcula nuevo valor de resul

    local := Mejora_Respuesta(...);

    .....

    resul := local;

    end loop;

    end;

    end select;

    end loop;

    endCONTROL;

    task CONTROLis

    resul,valor : FLOAT; Reg :Regulador;

    begin

    loop

    valor := Leer_Sensor;

    Calcular_Regulador(Reg, valor, resul);

    --- resul tiene un valor estable

    .....


    Limitaci n de tiempo de espera l.jpg
    Limitación de tiempo de espera

    • A veces es necesario limitar el tiempo que una tarea está esperando a que ocurra un evento.

    • Para limitar el tiempo se utiliza la denominada llamada temporizada o selección temporizada.

    • Con este mecanismo se limita el tiempo de bloqueo de una tarea en espera.

    select

    <tarea>.<entrada>

    <instrucciones>

    or

    delay<duration>

    <instrucciones>

    end select;

    select

    accept <entrada>

    or

    delay <duration>

    <instrucciones>

    end select;


    Ndice63 l.jpg
    Índice

    3.1.- Introducción. Definición de conceptos.

    3.2.- Declaración y uso de tareas en Ada’95.

    3.3.- Comunicación y sincronización de tareas.

    Variables compartidas

    Paso de mensajes.

    3.4.- Casos de Estudio.


    Caso de estudio l.jpg

    Control_Temp

    Memoria

    Control_Nivel

    E/S

    Actuadores

    Operador

    Simulador

    Sensores

    Interfaz

    Caso de estudio

    Control por computador de temperatura y nivel de un depósito

    Tarea: Control de temperatura (Control_Temp)

    Cada 5 segundos

    Leer_Sensor_Temp(Val_Temp)

    Calcular_Acción(Ref,Val_Temp,Acc_Temp,…)

    Aplicar_Acción(Acc_Temp)

    Antes de 2 segundos


    Caso de estudio distribuci n de tareas l.jpg
    Caso de estudio: distribución de tareas.

    Estado

    Variables Compartidas

    Nivel

    Referencia Nivel

    Temperatura

    Referencia Temperatura

    ValvulaSalida

    ParametrosReguladorNivel

    VálvulaAguaCaliente

    ParametrosReguladorTemperatura

    VálvulaAguaFría

    Control Nivel

    Control Tª

    Operador

    Simulador


    Caso de estudio variables compartidas l.jpg
    Caso de estudio: Variables Compartidas

    package VARSis

    protected type VARIABLES is

    --Funciones de consulta

    function leer_Temperatura return float;

    function leer_Nivel return float;

    function leer_Ref_Nivel return float;

    function leer_Ref_Temperatura return float;

    function leer_estado return estados;

    --Procedimientos

    procedure Inicializar;

    procedure Modifica_VSalida(valor: in float);

    procedure Modifica_VAguaCaliente(valor: in float);

    procedure Modifica_VAguaFria(valor: in float);

    procedure Modifica_Ref_Nivel(valor: in float);

    procedure Modifica_Ref_Temperatura(valor: in float);

    procedure Modifica_Estado(valor: estados);

    --Funciones y procedimientos para el simulador

    function leer_VSalida return float;

    function leer_VAguaCaliente return float;

    function leer_VAguaFria return float;

    procedure Modifica_Temperatura(valor: in float);

    procedure Modifica_Nivel(valor: in float);

    Private

    Temperatura: Float := 15.0;

    Nivel: Float := 5.0;

    Ref_Temperatura : Float:=20.0;

    Ref_Nivel: Float := 15.0;

    VSalida : Float := 0.0;

    VAguaCaliente:float := 0.0;

    VAguaFria : float := 0.0;

    Estado : estados ;

    end VARIABLES;

    end VARS;


    Caso de estudio paquete reguladores l.jpg
    Caso de estudio: Paquete Reguladores

    package Reguladores is

    type Tipo_Regulador is (TodoNada, Proporcional);

    protected type Regulador is

    -- Funciones para consultar los parámetros del regulador

    function Leer_Tipo return tipo_regulador;

    function Leer_Histeresis return float ;

    function Leer_CProporcionalidad return float;

    function Leer_Referencia return Float ;

    -- Procedimientos para modificar los parámetros del regulador

    procedure Modifica_Tipo (valor: tipo_regulador);

    procedure Modifica_Histeresis (valor: Float);

    procedure Modifica_CProporcionalidad (valor: Float);

    procedure Modifica_Referencia (valor: Float);

    --Calcula la accion de control en funcion del valor de la entrada

    procedure Calcular_accion(Entrada : Float; salida : in out float);

    private

    Tregulador :Tipo_Regulador := TodoNada; -- Indica si el regulador es todo-nada o proporcional

    Referencia : Float := 20.0;-- Referencia que debe seguir el proceso

    Histeresis : Float := 1.0;-- Para el todo-nada, el margen que aceptamos como valido

    CProporcionalidad: Float := 5.0;-- Cte de proporcionalidad para el regulador proporcional.

    end Regulador;

    end Reguladores;


    Caso de estudio control de nivel l.jpg
    Caso de Estudio: Control de nivel.

    Estado

    Variables Compartidas

    Nivel

    Referencia Nivel

    Temperatura

    Referencia Temperatura

    ValvulaSalida

    ParametrosReguladorNivel

    VálvulaAguaCaliente

    ParametrosReguladorTemperatura

    VálvulaAguaFría

    Nivel

    Referencia Nivel

    VálvulaAguaFría

    ParametrosReguladorNivel

    Control Nivel


    Caso de estudio control de nivel69 l.jpg
    Caso de estudio: Control de Nivel

    task body Control_Nivel is

    periodo: constant duration:=0.6;

    Siguiente:Time;

    qn:float;

    begin

    buclePpal:

    loop

    -- Código de SINCRONIZACIÓN

    siguiente:=clock + periodo;

    Controlar:

    loop

    qn := V.Leer_VAguaFria;

    RegNivel.Calcular_Accion(V.Leer_Nivel,qn);

    V.Modifica_VAguaFria(qn);

    -- Código de FINALIZACIÓN

    delay until siguiente;

    siguiente:=siguiente+periodo;

    end loop Controlar;

    end loop buclePpal;

    end Control_Nivel;


    Caso de estudio operador l.jpg
    Caso de Estudio: Operador

    Iniciar/Terminar

    Variables Compartidas

    Nivel

    Referencia Nivel

    Temperatura

    Referencia Temperatura

    ValvulaSalida

    ParametrosReguladorNivel

    VálvulaAguaCaliente

    ParametrosReguladorTemperatura

    VálvulaAguaFría

    Operador

    Referencia Nivel

    Referencia Temperatura

    ParametrosReguladorNivel

    ParametrosReguladorTemperatura

    Iniciar/Terminar


    Caso de estudio operador71 l.jpg
    Caso de Estudio:Operador

    task body operador is

    orden1, orden2 : integer;

    rNivel, rTemperatura : Float;

    hist, cteprop : float;

    begin

    BuclePpal:

    loop

    Put_line(" MENU ");

    Put_line("Arrancar teclea 1");

    Put_line("Parar teclea 2");

    Put_line("Regulador de Nivel teclea 3");

    Put_line("Regulador de Temperatura teclea 4");

    Put_line("Terminar teclea 0");

    Ada.Integer_Text_Io.Get(Orden1);

    case Orden1 is

    when 0 =>

    when 1 =>

    when 2 =>

    when 3 => BucleRegNivel:

    loop

    end loop BucleRegNivel;

    when 4 =>BucleRegTemperatura:

    loop

    end loop BucleRegTemperatura;

    when others => null;

    end case;

    exit BuclePpal when V.Leer_Estado = Terminado;

    end loop BuclePpal;

    Código que permita terminar las tareas

    Código que permita arrancar las tareas

    Código que permita parar las tareas


    Caso de estudio simulador l.jpg
    Caso de Estudio: Simulador

    Iniciar/Terminar

    Variables Compartidas

    Nivel

    Referencia Nivel

    Temperatura

    Referencia Temperatura

    ValvulaSalida

    ParametrosReguladorNivel

    VálvulaAguaCaliente

    ParametrosReguladorTemperatura

    VálvulaAguaFría

    Nivel

    Temperatura

    ValvulaSalida

    VálvulaAguaCaliente

    VálvulaAguaFría

    Simulador


    Caso de estudio simulador73 l.jpg
    Caso de Estudio: Simulador.

    taskbody Simuladoris

    Periodo: constantduration:=0.4;

    Siguiente:Time;

    Qs, F1,F2:float; Te:float:=15.0;

    Tc:float:=45.0; cte1:float:=0.02;

    cte2:float:=3.0 pvs:float:=0.5;

    nivel_actual, temp_actual, qt_actual, qn_Actual : float;

    begin

    buclePpal:

    loop

    -- Código de SINCRONIZACIÓN

    siguiente:=clock + periodo;

    Simular:loop

    nivel_actual:=V.Leer_Nivel; Temp_actual:=V.Leer_Temperatura;

    qt_Actual:= V.Leer_VAguaCaliente; qn_actual:=V.Leer_VAguaFria;

    --Consideramos el caudal de salida del deposito como un valor

    --constante afectado por un error (ruido aleatorio)

    Qs := (Cte2 * Sqrt(Nivel_actual) * Pvs)+ float(Qal.Random(T));

    F1 := (Qn_actual * Te) + (Qt_actual * Tc) + ((Qtotal-Qs) * Temp_actual);

    F2 := (Qn_actual + Qt_actual + Qtotal - Qs);

    Temp_actual := F1 / F2;

    Nivel_actual := Nivel_actual + (Qn_actual - Qs + Qt_actual) * Cte1;

    Qtotal := Qtotal - Qs + Qn_actual + Qt_actual;

    V.Modifica_Temperatura(Temp_actual);

    V.Modifica_Nivel(nivel_actual);

    -- Código de FINALIZACIÓN

    delayuntil siguiente;

    siguiente:=siguiente+periodo;

    endloop Simular;

    endloopbuclePpal;

    end Simulador;


    Sincronizaci n variables comunes l.jpg
    Sincronización: Variables Comunes

    task body operador is

    orden1, orden2 : integer;

    rNivel, rTemperatura : Float;

    hist, cteprop : float;

    begin

    BuclePpal:

    loop

    Put_line(" MENU ");

    Put_line("Arrancar teclea 1");

    Put_line("Parar teclea 2");

    Put_line("Regulador de Nivel teclea 3");

    Put_line("Regulador de Temperatura teclea 4");

    Put_line("Terminar teclea 0");

    Ada.Integer_Text_Io.Get(Orden1);

    case Orden1 is

    when 0 =>V.Modifica_Estado(Terminado);

    when 1 =>V.Modifica_Estado(Ejecucion);

    when 2 => V.Modifica_Estado(Paro);

    when 3 => BucleRegNivel:

    loop

    end loop BucleRegNivel;

    when 4 =>BucleRegTemperatura:

    loop

    end loop BucleRegTemperatura;

    when others => null;

    end case;

    exit BuclePpal when V.Leer_Estado = Terminado;

    end loop BuclePpal;

    Estado

    task body Control_Nivel is

    periodo: constant duration:=0.6;

    Siguiente:Time;

    qn:float;

    begin

    buclePpal:

    loop

    while(V.Leer_Estado /= ejecucion)

    loop

    delay0.6;

    end loop;

    siguiente:=clock + periodo;

    Controlar:

    loop

    qn := V.Leer_VAguaFria;

    RegNivel.Calcular_Accion(V.Leer_Nivel,qn);

    V.Modifica_VAguaFria(qn);

    exit Controlar when V.Leer_Estado = Paro;

    exit BuclePpal when V.Leer_Estado = Terminado;

    delay until siguiente;

    siguiente:=siguiente+periodo;

    end loop Controlar;

    end loop buclePpal;

    end Control_Nivel;


    Sincronizaci n variables comunes barrera l.jpg
    Sincronización: Variables Comunes + Barrera

    task body operador is

    orden1, orden2 : integer;

    rNivel, rTemperatura : Float;

    hist, cteprop : float;

    begin

    BuclePpal:

    loop

    Put_line(" MENU ");

    Put_line("Arrancar teclea 1");

    Put_line("Parar teclea 2");

    Put_line("Regulador de Nivel teclea 3");

    Put_line("Regulador de Temperatura teclea 4");

    Put_line("Terminar teclea 0");

    Ada.Integer_Text_Io.Get(Orden1);

    case Orden1 is

    when 0 =>V.Modifica_Estado(Terminado);

    when 1 =>V.Modifica_Estado(Ejecucion);B.Abrir(4)

    when 2 => V.Modifica_Estado(Paro);

    when 3 => BucleRegNivel:

    loop

    end loop BucleRegNivel;

    when 4 =>BucleRegTemperatura:

    loop

    end loop BucleRegTemperatura;

    when others => null;

    end case;

    exit BuclePpal when V.Leer_Estado = Terminado;

    end loop BuclePpal;

    task body Control_Nivel is

    periodo: constant duration:=0.6;

    Siguiente:Time;

    qn:float;

    begin

    buclePpal:

    loop

    B.Entrar

    siguiente:=clock + periodo;

    Controlar:

    loop

    qn := V.Leer_VAguaFria;

    RegNivel.Calcular_Accion(V.Leer_Nivel,qn);

    V.Modifica_VAguaFria(qn);

    exit Controlar when V.Leer_Estado = Paro;

    exit BuclePpal when V.Leer_Estado = Terminado;

    delay until siguiente;

    siguiente:=siguiente+periodo;

    end loop Controlar;

    end loop buclePpal;

    end Control_Nivel;


    Sincronizaci n sincronizaci n directa l.jpg
    Sincronización: Sincronización directa

    task body operador is

    orden1, orden2 : integer;

    rNivel, rTemperatura : Float;

    hist, cteprop : float;

    begin

    BuclePpal:

    loop

    Put_line(" MENU ");

    Put_line("Arrancar teclea 1");

    Put_line("Parar teclea 2");

    Put_line("Regulador de Nivel teclea 3");

    Put_line("Regulador de Temperatura teclea 4");

    Put_line("Terminar teclea 0");

    Ada.Integer_Text_Io.Get(Orden1);

    case Orden1 is

    when 0 =>V.Modifica_Estado(Terminado);

    Monitor.Terminar; Control_Nivel.Terminar

    Control_Temperatura.Terminar;

    Simulador.Terminar;

    when 1 =>V.Modifica_Estado(Ejecucion);

    Monitor.Arrancar; Control_Nivel.Arrancar

    Control_Temperatura.Arrancar;

    Simulador.Arrancar;

    when 2 => V.Modifica_Estado(Paro);

    Monitor.Parar; Control_Nivel.Parar

    Control_Temperatura.Parar;

    Simulador.Parar;

    when 3 => …

    task body Control_Nivel is

    periodo: constant duration:=0.6;

    Siguiente:Time;

    qn:float;

    begin

    buclePpal:

    loop

    select

    accept arrancar;

    or

    accept Terminar; exit buclePpal;

    end select;

    siguiente:=clock + periodo;

    Controlar:

    loop

    qn := V.Leer_VAguaFria;

    RegNivel.Calcular_Accion(V.Leer_Nivel,qn);

    V.Modifica_VAguaFria(qn);

    select

    accept Parar;exit Controlar

    or

    accept Terminar; exit BuclePpal

    or

    delay until siguiente;

    siguiente:=siguiente+periodo;

    end select;

    end loop Controlar;

    end loop buclePpal;

    end Control_Nivel;


    Caso de estudio 2 control de un robot m vil l.jpg

    s3

    s4

    s2

    s5

    s1

    s6

    s8

    s7

    Caso de Estudio 2: Control de un Robot Móvil.

    • Características:

      • 26mm de radio.

      • 8 sensores de infrarrojos.

      • 2 ruedas movidas por dos

      • motores de corriente continua.

      • 2 encoders (uno por rueda).

    • Control

      • A partir de la información de los

      • encoders, hacer que el robot

      • alcance una serie de objetivos.

      • A partir de los sensores de

      • infrarrojos evitar todos los obstáculos

      • del camino.


    Caso de estudio 2 control de un robot m vil78 l.jpg
    Caso de Estudio 2: Control de un Robot Móvil

    El usuario va introduciendo

    los objetivos a alcanzar, así como los obstáculos que debe evitar.

    La comunicación con el robot se realiza vía serie, a partir de un conjunto de comandos propios del robot.


    Caso de estudio2 control de un robot m vil l.jpg
    Caso de Estudio2: Control de un Robot Móvil.

    PRIMERA VERSIÓN

    Variables Compartidas

    PosiciónActual

    Infrarojos

    OrientaciónActual

    Encoders

    VelocidadActual

    Motores

    Control

    E/S

    Operador

    Simulador


    Tarea poliformat l.jpg
    Tarea PoliformaT

    • Realizar un programa de control simple que, siguiendo el esquema propuesto en el caso de estudio del control de un robot móvil, sea capaz de llevar al robot desde una posición conocida a otra indicada por el usuario.


    Caso de estudio 2 control de un robot m vil81 l.jpg

    User_interface

    1

    Operator

    1..n

    Robot_Controller

    1

    Sensor

    1

    Robot_status

    Robot_interface

    1..n

    1

    map_cache

    Monitor

    1

    Control

    1

    1

    Supervisor

    Simulator

    1..n

    1

    Scenario_map

    Arena

    1

    Robot_positions

    Caso de Estudio 2 : Control de un Robot Móvil.

    SEGUNDA VERSIÓN


    ad