PDF de programación - Capitulo 7. Programación concurrente

CAPÍTULO 7. PROGRAMACIÓN CONCURRENTE



7

7.1

7.2

7.3

7.2.1

7.1.1

Programación concurrente. ............................................................................................ 2
La noción de proceso ............................................................................................. 2
Construcciones de programación concurrente ............................................... 4
Ejecución concurrente............................................................................................ 4
Procesos y objetos .......................................................................................... 6
Representación de procesos ................................................................................... 7
Corrutinas....................................................................................................... 7
Fork y join ...................................................................................................... 7
Cobegin .......................................................................................................... 8
Declaración explicita de procesos.................................................................. 8

7.3.1
7.3.2
7.3.3
7.3.4



Rafael Álvarez García
Última revisión 29-10-07
[email protected]


Nota importante:

Este documento no pretende reemplazar al material propuesto por la UNED para la
asignatura Sistemas en Tiempo Real.

Cualquier sugerencía, comentario o corrección sobre este documento, envíelo a
[email protected] para poder realizar los cambios necesarios.



1




7 Programación concurrente.


Virtualmente, todos los sistemas de tiempo real son inherentemente concientes. Los lenguajes
destinados a ser usados en este dominio tienen mayor potencia expresiva si proporcionan al
programador primitivas que se ajusten al paralelismo de las aplicaciones.



Denominamos programación concurrente a la notación y técnicas de programación que
expresan el paralelismo potencia] y que resuelven los problemas resultantes de la
sincronización y la comunicación. La implementación del paralelismo es un tenía de los
sistemas
la
programación concurrente. La importancia de la programación concurrente esta en que
proporciona un entorno abstracto donde estudiar el paralelismo sin tener que enfrascarse en
los detalles de implementación, (Ben-Ari, 1982)

informáticos (hardware y software) esencialmente

independiente de

7.1 La noción de proceso


Cualquier lenguaje, natural o informático, tiene un carácter dual: a la vez que es capaz de
expresarse, también limita el entorno en el que se aplica dicha capacidad expresiva. Si un lenguaje no
permite cierta noción o concepto particular, entonces aquellos que utilizan el lenguaje no podrán
emplear este concepto, y puede que, incluso, desconozcan por completa su existencia.


Pascal, C, FORTRAN y COBOL comparten la propiedad común de ser lenguajes de programación
secuenciales. Los programas escritos en estos lenguajes tienen un único hilo de control. Comienzan la
ejecución en cierto estado y avanzan ejecutando una sentencia cada vez, hasta que el programa
finaliza. La traza a través del programa puede diferir debido a variaciones en los datos de entrada,
aunque para una ejecución concreta del programa existe una única traza. Esto no es lo adecuado para la
programación de sistemas de tiempo real. Un programa concurrente puede verse como un conjunto de
procesos secuenciales autónomos, que son ejecutados en paralelo. Todos los lenguajes de
programación concurrente incorporan, explicita o implícitamente, la noción de proceso; cada. proceso
tiene un hilo de control.


La implementación real (esto es, la ejecución) de un conjunto de procesos tiene lugar normalmente

de tres formas. Los procesos pueden;



(1) Multiplexar sus ejecuciones sobre un único procesador.
(2) Multiplexar su ejecuciones en un sistema multiprocesador con acceso a memoria

compartida.

(3) Multiplexar sus ejecuciones en diversos procesadores que no comparten memoria (a estos

sistemas se les denomina, normalmente, sistemas distribuidos).


También es posible encontrar híbridos de estos tres métodos.

Solo en los casos (2) y (3) es posible una verdadera ejecución paralela de mas de un proceso. El
termino concurrente indica paralelismo potencial. Los lenguajes de programación concurrente
permiten al programador expresar actividades lógicamente paralelas sin tener en cuenta su
implementación.


Considerando así los procesos, queda claro que la ejecución de un programa concurrente no es tan
directa como la ejecución de un programa secuencial. Los procesos deben ser creados y finalizados, así



2

como distribuidos hacia / desde los procesadores disponibles. Estas actividades son efectuadas por el
sistema de soporte de ejecución (RTSS; Run-Time Support System) o núcleo de ejecución. El RTSS
posee muchas de las características del planificador de un sistema operativo, y esta ubicado,
lógicamente, entre el hardware y el software de aplicación. En realidad, puede tomar una de las
siguientes formas:



(1) Una estructura software programada como parte de la aplicaci6n (esto es, como un
componente del programa concurrente). Esta es la aproximación adoptada por el lenguaje
Modula-2.

(2) Un sistema software estándar generado junto al código objeto del programa por el

compilador. Esta es la estructura habitual en los programas de Ada y Java.

(3) Una estructura hardware micro codificada en el procesador, por motivos de eficiencia. Un

programa occam2 que se ejecuta en un transputer tiene este sistema de ejecución.


El algoritmo que utiliza el RTSS para planificar (esto es, para decidir que proceso se ejecuta a
continuación en el caso de haber mas de uno ejecutable) afectara al comportamiento temporal del
programa, aunque, para programas bien construidos, el comportamiento lógico no dependerá del
RTSS. Desde el punto de vista del programa, se asume que el RTSS planifica los procesos de forma no
determinista. En el caso de los sistemas de tiempo real las características de la planificación son
relevantes.


Todos los sistemas operativos proporcionan mecanismos para crear procesos concurrentes.
Normalmente, cada proceso se ejecuta en su propia maquina virtual, para evitar interferencias con
otros procesos no relacionados. Cada proceso consta, realmente, de un único programa. Sin embargo,
en los últimos años se tiende a permitir la creación de procesos dentro de los programas. Los sistemas
operativos modernos permiten crear procesos dentro del mismo programa accediendo de modo
compartido, y sin restricciones, a la memoria común (estos procesos suelen llamarse hilos o hebras).
Por tanto. en los sistemas operativos que se ajustan a POS1X. es preciso distinguir entre la
concurrencia de programas (procesos), y la concurrencia dentro de un programa (hilos). también es
frecuente distinguir entre aquellos hilos visibles desde el sistema operativo y aquellos que provienen
únicamente del soporte de ciertas rutinas de biblioteca.


Ha habido un amplio debate entre programadores, diseñadores de lenguajes y diseñadores de
sistemas operativos, sobre si lo apropiado es que sea el lenguaje quien de soporte para la concurrencia,
o si éste debiera ser proporcionado únicamente por el sistema operativo. Los argumentos a favor de
incluir la concurrencia en los lenguajes de programación son los siguientes:



(1) Lleva a programas mas legibles y fáciles de mantener.
(2) Existen muchos tipos distintos de sistemas operativos; al definir la concurrencia en el len-

guaje se consiguen programas mas portables.

(3) Puede que el computador embebido ni siquiera disponga de un sistema operativo residente.


Claramente, estos fueron los argumentos que mas pesaron sobre los diseñadores de Ada y Java.

Los argumentos en contra de la concurrencia en el lenguaje son los siguientes:



(1) Cada lenguaje tiene un modelo de concurrencia distinto; resulta mas sencillo componer
programas de distintos lenguajes si todos utilizan el mismo modelo de concurrencia del
sistema operativo.

(2) Puede no ser fácil implementar eficientemente cierto modelo de concurrencia de un len-

guaje sobre algún modelo de sistema operativo.

(3) Comienzan a aparecer estándares de sistema operativo, y por tanto los programas se

vuelven mas portables.

3

La necesidad de soportar diversos lenguajes fue una de las principales razones por las que la
industria aeronáutica civil, al desarrollar su programa de Avionica Modular Integrada, opto por una
interfaz de programación de aplicaciones núcleo estándar (llamada APEX) que soporta concurrencia,
en vez de adoptar el modelo de concurrencia de Ada (ARINC AEE Committee, 1999). El debate, sin
duda, continuara durante algún tiempo.

7.1.1 Construcciones de programación concurrente


A pesar de que las construcciones de programación concurrente varían de un lenguaje (y sistema

operativo) a otro, deben proporcionar tres servicios fundamentales, que se citan a continuación;



• La expresión de ejecución concurrente mediante la noción de proceso.
• La sincronización de procesos.
• La comunicación entre procesos.


Al considerar la interacción entre procesos, es útil distinguir entre tres tipos de comportamiento:



•

Independiente

• Cooperativo
• Competitivo


Los procesos independientes no se co