PDF de programación - Componentes Software para Sistemas Distribuidos de Tiempo Real

Componentes Software para

Sistemas Distribuidos de Tiempo Real

Tesis Doctoral

Departamento de Lenguajes y Ciencias de la Computación

Universidad de Málaga, España

Presentada por

Daniel Garrido Márquez

Dirigida por

Dr. Manuel Díaz Rodríguez



D. Manuel Díaz Rodríguez, Titular de Universidad del Departamento de Lenguajes y
Ciencias de la Computación de la Universidad de Málaga



Certifica

Que D. Daniel Garrido Márquez, Ingeniero en Informática por la Universidad

de Málaga, ha realizado en el Departamento de Lenguajes y Ciencias de la Computación
de la Universidad de Málaga, bajo su dirección, el trabajo de investigación
correspondiente a su Tesis Doctoral titulada


Componentes Software para Sistemas Distribuidos de Tiempo Real



Revisado el presente trabajo, estimo que puede ser presentado al tribunal que ha de
juzgarlo, y autorizo la presentación de esta Tesis Doctoral en la Universidad de Málaga.



En Málaga, a 9 de Diciembre de 2005



Fdo: Manuel Díaz Rodríguez
Titular de Universidad
Departamento de Lenguajes y
Ciencias de la Computación
Universidad de Málaga



Agradecimientos



En la realización de este trabajo, no pocas personas merecen mi agradecimiento. En
primer lugar, Manuel Díaz, director de la tesis, por toda la ayuda prestada no sólo en
la tesis, sino en toda la labor que vengo realizando desde mi llegada a la Universidad.
En segundo lugar, todos los miembros del Departamento de Lenguajes y Ciencias de la
Computación y del grupo GISUM que me han ayudado de alguna u otra forma en la
finalización de este trabajo; y en particular, a José María Troya, por todo el apoyo
recibido. De manera muy especial a Paco Rus, Luis Llopis, Enrique Soler y José María
Alvarez. En tercer lugar, a Tecnatom S.A. sin cuya ayuda, gran parte de este trabajo no
podría haber sido realizado. Y, finalmente, a mi mujer, mis padres y familiares, por el
apoyo recibido y la paciencia que han tenido hasta que este trabajo ha sido finalizado.



Índice



Índice.............................................................................................................................................................i
Lista de figuras ............................................................................................................................................iv
Lista de tablas..............................................................................................................................................vi
Prólogo ...................................................................................................................................................... vii
Capítulo 1. Introducción...............................................................................................................................1
1.1. Sistemas Distribuidos de Tiempo Real..............................................................................................3
1.1.1. Definición de sistema distribuido ...............................................................................................4
1.1.2. Programación en sistemas distribuidos.......................................................................................5
1.1.3. Planificación en sistemas distribuidos ........................................................................................7
1.1.4. El medio de comunicación..........................................................................................................9
1.2. El paradigma de programación basado en componentes .................................................................13
1.2.1. La plataforma .NET..................................................................................................................14
1.2.2. El modelo de componentes de Java ..........................................................................................17
1.2.3. El modelo de componentes CCM .............................................................................................19
1.2.4. Tendencias actuales sobre componentes y tiempo real.............................................................23
1.3. CORBA y RT-CORBA ...................................................................................................................27
1.3.1. Fundamentos de CORBA .........................................................................................................29
1.3.2. Arquitectura CORBA de tiempo real........................................................................................38
1.3.3. Gestión de prioridades ..............................................................................................................39
1.3.4. Servidores multihebra...............................................................................................................41
1.3.5. Sincronización ..........................................................................................................................42
1.3.6. Configuración de protocolos.....................................................................................................43
1.4. SDL y la extensión de tiempo real...................................................................................................44
1.4.1. Fundamentos de SDL ...............................................................................................................45
1.4.2. Carencias de SDL para tiempo real ..........................................................................................49
1.4.3. Extensiones de tiempo real para SDL.......................................................................................50
1.5. Aportaciones....................................................................................................................................54
Capítulo 2. Un modelo de componentes distribuido para tiempo real........................................................57
2.1. Dos visiones: desarrollador y usuario..............................................................................................59
2.1.1. La vista del desarrollador..........................................................................................................59
2.1.2. La vista del usuario...................................................................................................................60
2.2. Tipos de componentes .....................................................................................................................60
2.2.1. Componentes genéricos............................................................................................................61
2.2.2. Componentes activos................................................................................................................68
2.2.3. Componentes pasivos ...............................................................................................................71
2.3. Interacciones entre componentes.....................................................................................................72
2.3.1. Recepción de peticiones: wait...................................................................................................73
2.3.2. Invocación de servicios: call.....................................................................................................75
2.3.3. Generación de eventos: raise....................................................................................................77
2.4. Anotaciones WCET.........................................................................................................................78
2.4.1. Anotaciones sobre bloques de código.......................................................................................79
2.4.2. Anotaciones sobre sentencias condicionales.............................................................................80
2.4.3. Anotaciones sobre bucles..........................................................................................................80
2.4.4. Creación de bloques secuenciales.............................................................................................81
2.4.5. El proceso de cálculo de los WCET .........................................................................................81

i

2.5. Vista del usuario: Instanciación de componentes............................................................................83
2.6. Vista del usuario: Configuración de componentes ..........................................................................84
2.6.1. Definición de ranuras ...............................................................................................................84
2.6.2. Utilización de ranuras...............................................................................................................85
2.6.3. Instanciación de ranuras ...........................................................................................................86
2.7. Restricciones de tiempo real............................................................................................................86
2.7.1. Restricciones sobre métodos de interfaces ...............................................................................87
2.7.2. Restricciones sobre eventos......................................................................................................88
2.8. Composición de componentes.........................................................................................................89
2.9. Componentes como aplicaciones ....................................................................................................91
2.10. Proceso de desarrollo.....................................................................................