Tema3

1. Tema 3 Programación concurrente

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

3. Í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.

4. 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:

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

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

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

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

9. + T1 T2 T3 - 50 100 150 200 250 300 350 400 Introducción. T1 = { 100, 20 } T2 = { 150, 40 } T3 = { 300, 100 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

28. Í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.

29. Comunicación entre tareas. • Las tareas o procesosnecesitancomunicarse y sincronizarse. • Existen dos formas para realizar esta comunicación: • Variables Compartidas • Paso de Mensajes

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

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

32. Í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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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