1. - Cenidet

i
I
8)
DGIT
'SEP
SElT
CENTRO NACIONAL DE INVESTIGACION
Y DESARROLLO TECNOLOGICO
11
<' DEPURADOR DE PROGRAMAS
I1
CONCURRENTFS BAJO UNIX .'
11
11
I1
CENTRO DE INFORMACION
T
I I ,
O U E
/I
1
E
S
C O M O
1
S
R E O U I C I T O
P A R A OBTENER E L G R A D O D E :
II
MAESTRO
DE
L A
I!
R
E
)I
'i
EN
CIENCIAS
C O M P U T A C I O N
S
E
N
T ' A
t
1.1. JAVIER SALVADOR SOBERANIS FERNANDEZ
11
I
I!
:CUERNAVACA, MOR.
I
I1
I
FEBRERO DE.1996
CEN I D E T
0
I1
/
SISITEMA
NACIONAL DE INSTITUTOS TECNOLOGICOS
Centro Nacional de Investigación y Desarrollo Tecnológico
h
/I
X A D E M I A DE LA MAESTRIA EN CIENCIAS
I1
DE LA COMI'UTACION
I/
I1
Cuernavaca Mor., a 27 de marzo de 1996
I
II
Dr. Juan Manuel Ricaño Castillo
Director del CENIDET
1
Presente
I/
II
At'n: Dr. José Ruiz Ascencio.
Jefe del Dpto. de Computación
1/
I1
!I
,.
!t
Nos es grato.comúnicarie, que conforme a los lineamientos establecidos para la
obtención del gradb
de maestría' de este: centro, y después de haber sometido a
11
revisión :ic;idCiiiic:i cl Lrabiijo de tesis tituliido:
i/
':
"Depurador de prograiiias. cóiicurrentes'bajo
.
el sisteiiia operativo
I/
UNIX"
, ii
que presenta el L.I!I Javier Salvador Soberanis Fernández. y habiendo cumplido con
todas las correcciones':que le fueron indicadas, estanios de'acuerdo con su contenido.
1
por lo que aprobamos que el trabajo sea presentado cn exaillcn oral.
/I
Ii
Sin más por el momento, quedarnos de ustcd.
I
I/
Coiiiisión de rcv
,
Y Cf;AEP.OLLU Tick0
M.C. Ismael Daza Velázquez
Y'
'I'els. (73) 18-77-41 y 12-76-13, Fax. 12-24-34
!I
.
,
SISTEMA NACIONAL DE INSTITUTOS TECNOLOGICOS
Centro Nakional de Investigación y Desarrollo Tecnológico
It
1
Subdirección Académica
Of. No CCS-O67/96
I)
It
I1
Cuernavaca Mor.. a 29 de ii~urzode 19%
1
.I
L.I. Javier.Salvabor Soberanis Fernáiidez
Candidato al gradole Maestro
en Ciencias de la/Computación
PRESE’NTE
/I
Después de [haber revisado su expediente escolar, y considerando que cumple
con los lineamientos establecidos en el reglamento académico para la ‘obtención del
grado de maestría:ide este centro, me es grato comunicarle que se le concede la
autorización para que proceda con la impresión de su tesis. Al mismo tiempo,
aprovecho para iAdicarle que, deberá acordar con los miembros del jurado la fecha y
hora de presenta&& del cxaiiieii respectivo.
I1
j!
Sin más por el momento, reciba mis feiicitacioncs por el término de su trabajo
de tesis, deseaiidolci,.éxito e? el exiiiiicn corrcspoiidicntc.
..I¡.
,
I1
C.C.P. M.C. Will?cr,ili Alcoccr I<. Subdircccióii Acadhica
C.C.P. C.P. Ing. David Chávez A. Dpto. de Servicios Escolares
I(
11
cenikfetl
.
I(
Interior Internado I’ihiiirii S/N C.P. 62490
Auurtudo l’ostiil 5-164. C.P. 62ü5ü. Cueriiiiviicu Mor., Mfvico
Tcls. (73) 18-77-41 y 12-76-13, Fax. 12-24-34
~~
.
~~~
~~~
It
¡I
I/
I/
,
'I
I/
/
I/
I1
I/
Con todo cariño y respeto a mis padres, que son mi
principal motivo de superación.
A mis hermanos Eloy y Erick.
A mi cuñada Alfa.
A mi sobrina Brianda.
A mis tios Ma.. Trinidad, Javier y Raul asi como a
la profra. Carmen quienes me han apoyado en todo.
--
/
~
-
/I
I/
I
A GMDECIMIENTOS
I/
I1
I/
I .
Al Centro Nacional de Investigación y Desarrollo Tecnológico (CENIDET)
I
por las facilidades brindadas.
II
/
A mi directbr de tesis M.C. y M.A. José Torres Jiménez, por
orientación para llevar a buen término ésta tesis.
SU
apoyo y
I1
Al profesor d.C. Luis García Gutiérrez por el apoyo brindado durante la
I/
maestría.
,I
I/
A mis maestros por su orientación y por brindarme sus conocimientos.
I/
A mis compañeros
de generación Anastacio Antolino H., Miguel A. Ortíz M.,
‘1
Claudia H. Ibarra P., Yasmín Hemández P., Paula A. Aguilar A., Claudia
Noguerón G:\ J’osé A. Martínez F., Hugo Italo Coronado C., Fortino Sosa M.
y Carlos Virgilio S. así como a Francisco San Martín R. por su amistad Y
compañerismo.
I/
A mis amigos Armando M., Citlalli L., Eldamira B.,Gloria, Hammed, Hugo
Estrada E., A k a Martínez R., Juan Gabriel González S., Victor Jesús Sosa
S., Ariel Lira:O. y a toda la flota de la pensión de Don Marcelo en San Antón,
por inolvidables momentos de convivencia.
/I
I
Al profesor M.C. Moisés González García, por la asistencia brindada durante
el tiempo que ‘kstuve trabajando en el laboratorio de Trabajo Asistido por
Computadora’(T.A.C.).
Ii
A la Estaciónii de trabajo Sun Sparc20 alias “cadll” por su excelente
I
desempeño durante el desarrollo de la tesis.
II
I/
-
I/
i
CAPITULO 1
INTRODUCCI~N
'
1.1 Antecedentes
Generales ............. ................................................ ............,.................
t
1.1.1 Unix ............:.............................................................................................
1 . I .2 X\Window,
GUl's y Estaciones De Trabajo ..............................................
I
.
.
1.1.3 Xt Inmnsic .............................. ..................................................................
",I .
1.1.4 Herramientas
en Propiedad .................................................
.................,...;
/I
~.
1 . I .5 OSFIMotif
...................................................................................................
I '
1.2 Depuradores (Debuggers) ........................................................................................
'I.
1.2.1 Depurador
adb ...........................................................................................
I '1
1.2.2 Depurador dbx ...... ..............i.. ....................................................................
i/
1.2.3 Depurador dbxtool ................................ ;.;...................................
:...............
11
1.2.4 Tuibo Debugger .........................................................................................
'It
'
1.3 ¿Por qué un'Depurador
Concurrente?.......................................................................
,,
1.3.1 Estado del Arte en Depuradores Concurrentes ..........................................
'I
1,J.l.
1 Depurador xab .........:..,..................................... ......,............ ........
'I /I
1!.3.1.2 Depuradores pdbx y xpdbx .........................................................
'1
1;3.#1.3Depurador udb .......................................................................... ..
1'!3.'1.4 Depurador pdd ........ ..................................................
................
1.3.i.5
I/
Totalview Debugger ....................................................................
8)
~
./
<
,
. .
1.4 Alcance y Restricciones .....,...........;. .....................................;...........
.............
1.5 Beneficios .I!.! ..................................................................... ....................................
'I
......S.
1
1
2
3
3
3
4
4
4
4
5
5
5
5
6
6
1
1
8
9
'1
CAPITULO 2
MARCO TEÓRICO
11
2.1 Procesos ......... ........................................................................................ .................
2.1.1 Estad& de Un Proceso .............................................................................
2.1.2 El Bloque de Control de un Proceso (Pcb) ...............................................
2.1.3 Opepciones sobre Procesos .......................................................................
2.1.4 Diferencias entre Proceso, Rutina y Conutina ..........................................
2.1.4.1 Rutina ..........................................................................................
i i . 4 . 2 Conutina ....1................................................. ...............................
2.i.4.3Proieso ........................................................................................
4
, ' ) .
2.2 Procesos co&Urrentes ...............................
.......................................................... ....
2.2.1 Problema de la 'Actualizaci6n Perdida' ......................................................
2.2.2 Exclu&h Mutua .,.....,............,.....,........,.................................... .................
.I/,
2.2.3 Semaforos ............................................. .............................. ......................
,
I
I!
ij
I/
I!
I
10
10
11
12
14
14
15
15
16
16
17
17
18
...
-
-.
i
.
__-
I!
I/
II
II
CAPITULO 3
ANALISIS DEL PROBLEMA
i
. .,I1
3.1 Descripcion del Problema ........................................................................................
I.
3.2 Soluciones,Posibles....................................................
.............................................
3.3 Metodología de Solución ........................................................................... ;.............
~
i/
20
21
22
I1
/I
I/
CAPITULO 4
IMPLEMENTACION DEL DEPURADOR
'
/I
i
4.1 Diseño Conceptual del Depurador ...........................................................................
4.1.1 Sincronizacióny Control de los Procesos Depurados ................................
4;2 Elementos y, Fiuncionamiento del Depurador ..........................................................
4.2.1 Elementos del Depurador ..........................................................................
4.2~1.1La Interfaz del Depurador ...............................
:...........................
4.2.1 . I .I El Menú de Ia'InterfG ................................................
\ 4.2.1.1.2 La Ventana de Edición y Seguimiento.........................
4.2.1.1.3 Ventana de Identificadores'De Procesos......................
4.2.1 .I .4 La Línea de Ordenes .:..................................................
11
4.2.1.1.5 Ventana para Resultados de Consultas..........................
442.1.2 E]Modulo Precompilador ...........................................................
4.2.1.3
'I
El Preprocesador de Comandos ..................................................
.I
4.2.1.4 El Analiiador de .Expresiones Lógicas ......;........... .....................
4.2.2 Descripción
'I/
de una Sesión de Depuración ......1........................................
4.2.3 Sintaxis
'I 1! de 10s Comandos del Depurador ................................................
I/
23
23
26
28
28
29
29
30
30
30
31
33
34
36
41
I/
.
.,,
..
i i
u
CAPITULO 5
PRUEBAS REALIZADAS
/
5.1 Ejemplo.- Análisis de la Primera Versión del Algoritmo de Dekker..........................
5.2 Código de IaiPrimera Versión del Algoritmo de Dekker ............................................
5.3 Código de la/egunda V,ersión del Algoritmo de Dekker ..........................................
5.4 Código de IaiTercera Versión del Algoritmo de Dekker ...........................................
5.5 Código de la C%arta Versión del Algoritmo de Dekker .............................................
'1
5.6 Código de 1a.Quinta
Versión del Algoritmo de Dekker ........................ ;....................
5.7 Ejemplo.- A ~ d s i del
s Algoritmo de Lectores y Escritores........................................
5.8 Código del Algoritmo de Lectores y Escritores .............;..........................................
51
5.9 Código del Algoritmo
de Productor-Consumidor ......................................................
"
'.
I/ '
43
46
48
50
52
55
58
61
66
_
I
!I
I/
I1
CAPITULO 6
CONCLUSIONES
11
11
I/
'I
6.1 Conclusiones
.............:..............................................................................................
51
6.2 Trabajos Futuros .............................
i
.....................................
.........................
i........
;
70
71
/I
4
ANEXO "A".; Estructuras de Datos usadas en la Implementación del Depurador. 72
Bibliografía .?
.................................
i ...................................................................
!!
I/
,
/I
I/
1)
I/
I/
li
Ill
...........
;
76
I/
ÍNDICE DE FIGURAS
Ii
'I
Fig. 1.- Sistema
Operativo Gráfico en una Estación de Trabajo .....................................
'
t
Fig. 2.- Muestra
de Widgets del OSFí Motif ....... ............................
................................
,b
Fig. 3.- Estados de un Proceso en El Sistema Operativo Unix .......................................
'I '
Fig. 4.- Ejemplo de Creación de Procesos en Unix Usando Fork() ................................
Fig. 5.- Representación Gráfica de una Operación P Sobre un Semáforo Binario ..........
'I
Fig. 6.- Representación
Gráiica de una Operación V Sobre un Semáforo Binario ..........
Fig. 7.- Depyción Concurrente Actual ........................................................................
Fig. 8.- Disefib Conceptual del Depurador .....................................................................
Fig. Sa.- Representación Gráfica del Ciclo de Control de los Procesos en Ejecución .....
,I
General del Depurador de Programd Concurrentes .................
Fig. 9.- Funcionamiento
Fig. 10.- Elementos del Depurador de Programas Concurrentes ......................................
Fig. 11.- Interfaz Gráfica del Depurador de Programas Concurrentes .............................
Fig. 12.- Formato'1 de Los Botones Identificadores de Proceso ........................................
Fig. 13.- Interahón del Preprocesador de Comandos con la Interfaz y los
i f l
Procesos.............................................................................................................
Fig.
del Analizador y Evaluador de Expresiones Booleanas con el
- 14.- Inter&ción
I
Preprocesador de Comandos y la Interfaz ........................................................
Fig. 15.- Opciones del Menú Archivo .....;......................................................................
Fig. 16.- V e n d a de Selección de Archivos ....................................................................
Fig. 17.- Programa con Tres Procesos en Ejecución mas El Programa Principal .............
Fig. 18.- MenÚbe Operaciones Sobre Breakpoints ......................................... :...............
Fig. 19.- Menú de Operaciones Sobre Variables ..............................................................
I1
Fig. 20.- Ventana de Respuestas a Las Consultas del Usuario ........................................
.
Fig. 21 .-P a n o d a General de una Sesión de Depuración con El Depurador
IL
Desanollado ........................................................................................... I .........
Fig. 22.- Grafo 'kdrrespondiente
!I
A La Tabla de Estados de la Primefa Versión del
Algoritmo de Dekker .......................................................................................
~
~
:,
I!
I!
2
3
11
13
18
18
20
23
26
27
28
29
30
33
34
37
38
39
39
40
40
'
Fig. 23.- Grafo Correspondiente a La Tabla de Estados del Algoritmo de Lectores y
. I/ ......................................................................................................
Escritores..
41
45
60
.!
/I
!I
Ii
.,
/I
li
!I
/I
ÍNDICE DE TABLAS
1 Estados Futuros de la Priniera Versión del Algoritmo de Dekker ....... 44
Tabla 1.- Tabla Ide
Tabla 2.- Tabla be Estados Futuros del Algoritmo de Lectores y Escritores ....................
59
I/
'!
1
IV
I/
I1
1
CAPITULO I
11
INTRODUCCI~N
I1
I1
El d e 4 1 1 0 de un programa de aplicación atraviesa varias fases. desde su concepción
hasta que el producto final se encuentra listo para ser utilizado. Una de las fases que requiere más
tiempo Y una dellas más importantes, es la depuración de errores lógicos en la concepción e
implementación de lalgoritmos para el procesamiento de información. Para llevar a cabo esta
tarea es muy Útili'contar con la ayuda de herramientas de depuración tales como los programas
depuradores (debuggers).
I/
'1
Un depurvor es un programa que permite controlar la ejecución de otro programa
(programa depurado). Entre las facilidades de un depurador esth: detener la ejecución del
programa depuradb, marcar puntos de parada (breakpoints), ejecutar paso a paso (step by step) o
10que es 10mism0, insirucción por instrucción o línea por línea, mostrar el valor que toman las
variables seleccionadas durante la ejecución del programa, modificar el valor de dichas vanables,
1
etc. Un depuradories, por lo tanto, una herramienta muy Útil para el programador durante la fase
de puesta a punto de un programa.
It
I/
1.1.1 Uaix
1.1 Antecedentes Generales
I
I1
11
11
UNIX es un sistema operativo que fue, en sus comienzos un experimento informático en
los laboratorios Bell XTBrT. El sisteqa UNIX fue diseñado como una simplificación del sistema
MULTICS desarrdllado en el MIT a finales de los sesenta. Originalmente programado en
ensamblador, pronto emigró a lenguaje C quedando solo unas cuantas subrutinas en
ensamblador. El sistema UNIX paso de ser un experimento a ser uno de los entomos de
desarrollo más imdortantes e influyentes en todo el mundo [COF92].
I/
I
Las caract4rísticas que hacen al sistema UNIX tan potente e influyente en nuevos
desarrollos son las siguientes:
I1
- Herranrienths
desofiure. Incorpora la filosofia de reutilización de softwarc
t
mediante la posibilidad de crear subrutinas que realicen tareas especificas. Esto
se refiere a la posibilidad de crear pequeflos programas mediante la programación
del shell, due realicen tareas que de otra manera involucrarían la ejecución de varios
comandos 'del sistema.
I/
1
- Porfabilidud El sistema UNIX ha sido implementado con pocos cambios a casi
cualquier hmputadora de tamaño moderado o grande, pekitiendo que aplicaciones
realizadas en una plataforma sean trasladadas a otra plataforma hardware con UNIX
debiendo kaijzar
un número mínimo de cambios en la aplicación.
I
/
11
1
I/
)I
I
i
-----
I1
_____
I
_
i
-_
11
I
Debido a que la mayoria de las compañías que generan software
un
sistema U N E Propio, las cantidad de cambios que involucra el trasladar un
ProgrAa de una plataforma hardware a otra puede v i a r .
I/
- F k d d i d a d . El sistema UNIX ha sido utilizado en una gran vanedad de
aplicaciones y extenderlo resulta fácil.
1
- Potencia ,Esun sistema sumamente robusto, ya que incorpora un extenso conjunto
de funciones y herramientas que no contemplan otros sistemas.
11
- Mulfiusuarioy muififarea.El sistema UNIX es un entorno multitarea de tiempo
I
comparhdo y mediante procesos se pueden tener varias tareas ejecutándose
simultáneamente.
I1
- Efegancid Su sintaxis clara y concisa, su riqueza en funciones hacen del sistema
UNIX uh sistema operativo elegante.
I/
- Urienfacibna rea! Las más recientes versiones del UNIX están organizadas para SU
uso en red,rpara lo cual se incluyen herramientas de comunicación internas,
aceptaci$n de rutinas de dispositivo adicionales y una organización flexible de su
sistema de p h i v o s [COF92].
I
I/
1.1.2 X Window, GUI's y Estaciones de Trabajo.
'I
En 10sdtimos d o s el X Window se ha convertido en un estándar para el desarrollo de
interfaces &&as 11 de usuario (GUI, graphics user interfaces) en estaciones de trabajo
independientes del
I dispositivo. Una interfaz gráfica de usuario (Fig. 1) se Puede definir
brevemente como
programa que se ejecuta en modo g r á k o Y que facilita la COrnunicación
computadora-us&o. Las estaciones de trabajo son computadoras de sobremesa con capacidades
gráficas y de com&ación superiores a las microcornputadoras de alto rendimiento.
I
I1
1
I
imagen, el Sistema operativo S U N Solaris)
li
2
-~
_I_
-
.i
.
-_ _-_
.
~_- -.--
-.
"-
-._
__
/I
dl
1.1.3 Xt Intrinsic.,;
//.
El X toolkit Intnnsics, también conocido como XI Intrinsics, permite a los
.
,
programadores crear
y usar bloques de pantalla estándar, estos bloques son objetos gráficos con
.I
ciertas propiedades ,cada uno, a estos bloques se les da el nombre de widgets, como por ejemplo
menús, barras de '/?esplazamiento (scroll bars), botónes y cuadros de dialogo.
11
1.1.4 Herramientas en Propiedad.
I/
I
El nivel más alto de programación para sistemas X Window es propietario. Las casas de
software desarroilan sus propias utilidades como extensiones a la utilidad Xt Intrinsic. Las
4 ." .
herramientas propietarias o en propiedad incluyen características de personalización que
prometen salidas atractivas, facilidad de uso y un rápido desarrollo de aplicaciones.
/
1.1.5 OSFMütif.. I
I/
La Open Software Fundation (OSF) es un consorcio formado por los mayores vendedores
de hardware, indiuyendo IBM, DEC y Hewlet-Packard: La utilidad OSFMotif llamada
frecuentemente Motif (Fig. 2), es la herramienta propietaria o en propiedad X Window más
usada, El mwm,l/(gestor de ventanas de Motif) gestiona 10s detalles de la creación Y
procesamiento de las'ventanas [LEV93].
3'
.
1.2 Depuradores (Debuggers).
li
"Algunos ambientes
de desarrollo de lenguajes de alto nivel suelen tener la facilidad de
agregar al código11 generado código que facilita la depuracióii. Este código será utilizado
posteriormente p& el depurador. En el caso del cornpilador de lenguaje C para UNIX. la opción g cumple esa f&cibn" [MAR93]. El sistema Solaris (UNIX Sistema V. versión 4)' de la
compañía SUN sumhstra tres herramientas de depuración: adb, dbx y dbxtool; A continuación
se da una breve dekckpción de cada uno de ellos.
1.2.1 Depurador
I!
Es un depurador interactivo de propósito general. Puede ser usado para examinar archivos
y ofrece un medio $biente controlado para la ejecución de programas.
El archivo.? depurar es normalmente un programa ejecutable, de preferencia con una
tabla de símbolos. Si el archivo no contiene una tabla de símbolos, puede ser examinado, pero las
11
características de manejo de símbolos del udb no podrán ser utilizadas. El archivo a depurar por
defecto es el u.ou/."
ti
1.2.2 Depurador dbx.
Es una utilidad para depurar y ejecutar programas escritos en lenguaje C a nivel de código
fuente, este depuraldor soporta otros lenguajes como Pascal y FORTRAN 77. Dbx acepta los
4.
mismos comandos que dbxtool, pero utiliza una interface estándar por terminal.
I'
El archivo a depurar es un archivo producido por el cornpilador cc u otro cornpilador, con
la opción -g para incluir una tabla de símbolos. Dicha tabla de símbolos contiene los nombres de
todos los archivos qud intervinieron en la creación del código objeto.
I
1.2.3'Depurador dbxtool.
11
Es un depurador a nivel de código objeto para programas escritos en lenguaje C, Pascal y
FORTRAN 77. Es una herramienta estándar que se ejecuta en un ambiente gráfico (Sunview,
que es un ambiente gkifico proporcionado por la compañía Sun), acepta los mismos comandos
que dbx, pero ofrece una interfaz de usuario más amigable.
I1
i
Se puede usar el ratón (mouse) para establecer puntos de parada (breakpoints), examinar
el valor de las variables y mucho más. Dbxtool está separado en subventanas para mostrar código
fuente, entrada de comandos y otros usos.
!
!/
I!
4
I
1.2.4 Turbo Debugger.
1
Uno de los programas de depuración más populares y que proporciona una gran cantidad
.
de facilidades esilel TURBO DEBUGGER de Borland que incluye las facilidades antes
mencionadas y que además permite puntos de parada condicionales y una utilidad que permite
regresar a un p d t o de ejecución anterior, pero esta utilidad tiene las siguientes limitaciones:
t
I/ . deshacer el efecto de las siguientes instrucciones-maquina: in, out, insb.
- No es posible
11
insw, outsb y outsw.
I1
- No es posible correr hacia atras un procedimiento o función que haya sido pasado con
Y
<F8>.
- No se puede
deshacer el efecto de una interrupción-software (instrucciones int en
1
código-máquina) que no haya sido depurada mediante <Alt>-<F7>.
1
.
-No es posible deshacer el efecto de instrucciones que escriban datos en disco, envíen
texto a la impresora, lean o escriban datos en los puertos de entrada y salida, etc.
[SWA90]. ,
/j
1.3 ¿Por qué un Depurador Concurrente?
la naturaleza de los errores que pueden,presentarse en la programación
en cuenta que no se conocía un depurador que pudiera depurar los
por un programa (para afirmar lo anterior se investigaron los
depuradores adb, db: y dbxtool que son los depuradores proporcionados por cl UNIX Sistema V
versión 4), era deseable el desarrollo de, un depurador que contuviera las características
11
a cabo una depuración eficiente de los procesos concurrentes generados
necesarias para llevar
81
por el programa sujeto a depuración.
I
‘I
1.3.1 Estado del Arte en Depuradores Concurrentes
internacional, la investigación sobre depuradores concurrentes
está dando sus pnmeros mitos, ya que se han dado a conocer herramientas de depuración que
soportan el multiprocesamiento. Algunos de los programas que mencionaremos a continuación
1)
aún se encuentraqen etapa experimental y son usados principalmente en los centros en donde
fueron desarrollad0s;’otros en cambio ya están disponibles a nivel comercial y soportan múltiples
plataformas h a r d w h
de los depuradores que a continuación se.mencionan fueron diseñados en
el procesamiento paralelo, o sea con múltiples procesadores, y dichos
arquitectura, algunos de estos procesadores fueron diseñados para
apoyar el procesamiiento distribuido.
/I
5
Por programas distribuidos se entiende que son aquellos programas que corren en una
red de computadoras; a los programas que corren en una soia máquina se les denomina
programas natiyd.
I/
1.3.1.1 Depurador xab
I/
ES un depurador para programas PVM (Parallel VirfuulMachine, otra librería de paso de
mensajes de Oak kidge National Laboratoiy, se ejecuta sobre TCPAP y soporta una red
heterogénea de 'computadoras, usualmente estaciones de trabajo, soportando los lenguajes
Fortran 77 y C).
1
Este depurador despliega cada llamada a una librería PVM cuando esta ocurre, pudiendo
ser usado como un depurador distribuido limitado.
i
En la actualidad no es posible usar el dbx, que es el depurador estándar de UNIX para
1)
programas PVM, esto se debe a que no se puede ligar al depurador un proceso en ejecución, pero
actualmente se puede usar un nuevo depurador paralelo propiedad de IBM llamado pdbx, del
cual hablaremos en ib siguiente secci6n.
i
Otro depurador paralelo que pronto estará a la disposición del publico es el ndb, el
Express debugger!!el cual puede ser ligado a procesos en ejecución [BER93].
1.3.1.2 Depuradores pdbx y xpdbx
'
I!
I
El pdbx es Un depurador basado .en el depurador dbx ,proporcionado por el sistema
operativo UNIX. Esste depurador permite manejar miiltiples instancias del dbx, que se ejecuten en
diferentes nodos de una IBM SP. La característica anterior permite al usuario observar la
ejecución de un programa corriendo en el ambiente paralelo de IBM, usando el paso de mensajes
a través de ethernet'lo usando un conmutador (switch) de alto desempeño, permite verificar
secciones criticas be,.un código y los nodos que no están siendo revisados pueden pararse O
dejarlos correr libr4m.ente.
n
El pdbx permite el manejo de puntos de parada (breakpoints) sobre nodos individuales O
grupos de nodos, d b i é n permite el manejo de grupos de procesos en forma interactiva para
facilitar esta función. Cuando el programa se detiene, es posible examinar los registros y pilas de
ejecución en uno o'harios nodos.
I/
El pdbx es un depurador de línea de comandos pero esta disponible la versión con
interfaz X Window, llamada xpdbx.
1.3.1.3 Depurador,'udb
I
Este depurador desarrollado por KSR (Kendail Square Research, fabricante de
computadoras paralelas escalables) cuenta con ambos modos; el modo de línea de comandos y CI
modo gráfico con i4tekaz X Window.
?
i
En este depurador pueden encontrarse reminiscencias del gdb desarrollado por FSF (Free
%?k?re ~mdujion,produce software libre de alta calidad disponible para el publico, este
software es Ilanydo popularmente “Software Gnu”). Este es un depurador totalmente funcional
que incluye dos formas diferentes de manejar los puntos de parada (breakpoints) paralelos y la
habilidad de monitorear subconjuntos de hilos (threads) definidos por el usuario [BER93].
1.3.1.4 Depurador pdd
1
Este nuevo depurador paralelo y distribuido desarrollado por IBM, cuenta con una
interfa gráfica X Window de pantalla completa y ha sido desarrollado durante muchos años por
IBM. Hasta dondy se sabe, aún no le han incluido todas las cdacterísticas de los depuradores,
pero el pdd tiene la ventaja de mostrar el código fuente del programa que esta siendo depurado.
i
El usuario puede usar el ratón (mouse) para pasar de un hilo de ejecución a otro, el código
fuente así como los datos locales del hilo se despliegan en forma coordinada [BER93].
I
1.3.1.5 TotaiView’Debugger
I
Las pruebas con la versión de prueba o versión beta del depurador Totalview de el IBM
RS/6000 se iniciaron a principios de Agosto de 1995. En el momento de escribir esta sección, se
I
tienen disponibles versiones del Totalview que soportan diferentes plataformas hardware.
l
El Totalview es un depurador multiproceso a nivel fuente con interfaz de ventanas (X
Window), convirtiéndose hasta este momento en uno de los depuradores más poderosos y
4
flexibles que soportan el multiprocesamiento. Este depurador tiene muchas ventajas sobre los
iI
depuradores convencionales del LJNIXtales como dbx y adb.
Las características más sobresalientes del Totalview son: la depuración de múltiples
procesos y que es’& depurador que también soporta el procesamiento distribuido, dando la
I
posibilidad al usua$o de depurar programas remotos. Para la depuración de procesos se despliega
el código fuente y la información de cada proceso en ventanas separadas, siendo posible liga el
11
depurador a procesos creados por otro proceso en ejecución.
I
1
Actualmente están disponibles versiones del Totalview que soportan las siguientes
plataformas:
I
- Sun 4 con SunOS o sistema operativo Solaris.
- DEC AlphL con el sistema operativo OSFA.
I
I
4
/I
1.
El TotalVjew ha sido transportado a las siguientes plataformas hardware o arq uitcctiiras
de microprocesador:
4
- Familias ;68k y 88k de Motorola,
'I
- Sun SPARC.
-Digital d p h a .
- AT&T DSP 32c.
- Intel 960.11
-Gray YMP.
~
,
I
i!
1.4 Alcance y Restricciones
I
Dentro del alcance de esta tesis se contemplaron las siguientes facilidades y restricciones
que debía contenerel depurador:
I
I
- Lograr una profundidad en la depuración de los procesos hasta 5 niveles.
- Correr los procesos depurados instrucción por instrucción (single step o step by
step).
h
- Correr los procesos depurados hasta un punto de parada (breakpoint).
- Incluir puntosi de parada condicionales.
1
- Detener la ejecución del programa.
I
- Desarrollariun ambiente gráfico utilizando X Window o Motif, que sea amigable al
usuario y que permita el seguimiento del código del proceso que se esté depurando.
Las consideraciones ergonómicas de la interfáz se basaron en la experiencia de el tesista
en el uso de depuradores.
I
- Incluir la facilidad de leer y desplegar el valor de las variables locales, globales y en
memoria compartida en el transcurso de la depuración.
1
- Modificación del valor de las variables locales, globales y en memoria compartida.
- El depurador NO
contempla la depuración concurrente de procesos independientes,
1
o sea, procesos que no hayan sido generados por un mismo programa.
- El depurador solo podrá ser aplicado a programas escritos en lenguaje ANSI C y
que utilicenilas facilidades que proporciona el UNIX para la programación
concurrente.'1
8
i
!
- El d e P b d o r P d r h ser aplicado a programas que no presenten
errores en la
compilación.
I
1.5 Beneficios
I1
'!
'I
Se desarrolló un paquete de software que realiza la deburación eficiente de los procesos
1)
que genere un programa y que además cuenta con las caracjensticas más importantes de los
paquetes de depdración actuales,
Los usuarios1 beneficiados con el paquete son los desarrolladores de software concurrente
en lenguaje ANSl C, bajo el sistema operativo UNIX Sistema 5 versión 4 y en estaciones de
trabajo RISC que cuenten con Motif.; ya que el depurador concurrente es una herramienta que
'I
hace posible la depuración de todos los procesos que genere dinámicamente un programa, con el
1
consiguiente ahorro de tiempo y esfuerzo.
h
El ahorro ;de tiempo en la detección de un mal manejo de la exclusión mutua y en el USO
de semáforos, se traduce en una disminución de los costos de desarrollo de software concurrente
$
bajoUNIX.
: ;
!
i
I
1
I!
e
9
.-
-- - - ---
- --------.
1
!I
- ----
CAPITULO 2
MARCO TEÓRICO
I
.:
2.1 Procesos
¡I
"Algunas Idefiniciones que ha tenido el término 'proceso' se presentan a continuación:
I1
II
- Un programa
en ejecución.
- Una actividad asíncrona.
- El 'espíritu !animado'de un procedimiento.
- El 'centro de control' de un procedimiento en ejecución.
- LOque se manifiesta por la existencia de un 'bloque de control de proceso' (PCB) en
11
.
el sistema operativo.
- La entidad a la que se le asignan procesadores.
- La unidad 'despachable'.
/
Aunque se han dado muchas otras definiciones, no hay una definición universalmente
aceptada, pero ellconcepto de 'programa en ejecución' parece ser el que se utiliza con más
frecuencia" [DE193].
I!
Cuando un programa es leído del disco por el kernel y es cargado en memona para
ejecutarse, se convierte en un proceso. En un proceso, no solo hay una copia del programa, sino
t
que además el keTnel (núcleo del sistema operativo) le añade información adicional para poder
manejarlo.
I
II
2.1.1 Estados de un Proceso
Durante suieiistencia un proceso puede atravesar por una serie de estados, cambiando de
uno a otro debido la ocurrencia de varios eventos. Dichos estados son los siguientes:
4
11
CORRIENDO o EJECUTÁNDOSE. Se dice que un proceso está en este estado cuando
II
tiene asignada la UCP. En sistemas ,monoprocesadores solo puede existir un proceso
ejecutándose a la vez.
'1
LISTO. Un; proceso se encuentra en este estado cuando está preparado para usar la UCP
cuando esté dispo$ble. En éste estado pueden haber varios procesos y son ordenados en una lista
según su prioridad, de tal manera que el siguiente proceso en recibir la atención del procesador
será el primero della lista. Existen varias politicas de asignación del procesador, algunas de las
cuales son: FIFO, Muitiniveies, etc.
II
10
.t
--
--
~------.-
--
-
-
--
Y
BLOQUEADO.
Un proceso entra en eslado bloqueado cuando está esperando un evento
I1
deteminado para ;continuar con su ejecución (p. ej. la finalización de una operación de E/S).
Puede haber varios procesos en estado bloqueado, formando una 'lista de procesos bloqueados' o
i
'lista de bloqueados';
dicha lista no está ordenada por prioridad ya que los procesos se
j .,
desbloqucan culndo ocurrc cI evento que están esperando y esto no succde siempre en orden.
'L
Algunas veces conviene asignar prioridades a los procesos bloqueados, ya que puede haber
I/
varios procesos esperando por un mismo evento. Puede darse el caso que existan varias listas de
11
procesos bloqueados,
de acuerdo al evento que esperan.
,
:I
ELIMINADO. Un proceso se elimina cuando ha terminado su ejecución.
j
ij
ESTADOS DE UN PROCESO
l.
"La forma en que se manifiesta un proceso en un sistema operativo es mediante un bloque
PCB) o un descriplor de proceso. El PCB es una
estructura de datos que contiene información importante acerca de un proceso, incluyendo:
de conirol de projeeso
(process control block,
I/
I
I
- el estadoI /actual del proceso.
- un identificador único del proceso.
11
un apuiftador hacia el padre del proceso (es decir, hacia el proceso que lo creó)
apuntad?reS a 10s hilos del Proceso (es decir, a los procesos creados por él),
- apuntadores hacia las zonas de memoria del proceso.
- la pnoridad del proceso.
- apuntadores a los recursos asignados ai proceso.
- un área para salvaguarda de los registros.
- el procesador en el que se está ejecutando el proceso
i
i
(en un sistema de procesadores múltiples).
I
El PCB es un almacén central de información que permite ai sistema operativo localizar
toda la información importante acerca de un proceso.
1
Cuando el sistema operativo conmuta la UCP entre varios procesos activos, utiliza las
áreas de salvagusda de los PCB para guardar la información que necesita para reiniciar un
proceso cuando élte obtenga la UCP." [DEI931
1
2.1.3 Operaciones sobre Procesos.
1
I
..
CREAR. Las actividades
llevadas a cabo cuando un proceso es creado son las siguientes:
i
- Nombrar,al proceso.
- insertar18 en la lista dc proce,sos.
- Determi& su prioridad inicial.
- Crear su PCB.
- Asignacionlinicd de recursos.
"La única forma de crear un proceso en el sistema operativo UNIx es mediante la
llamada a] sistema 'fork()'. El proceso que invoca a 'fork()' es el proceso padre, Y el Proceso
4
hijo." [MAR931
creado es el proceso
,I
I
La forma de invocar a fork() es la siguiente:
11
variable = fork();
I
Donde variable es una variable de tipo entero. La llamada fork0 devuelve un valor de
tipo entero en 'v&ab]e'. para el proceso padre, el valor devuelto es el PID (identificador de
proceso) de] proc& hijo y para el proceso hijo el valor devuelto por fork0 es cero. El código de)
proceso hijo comienza inmediatamente después de la llamada a fork(), (Fig. 4).
I
12
I
I(
--------
-
-
---------
il
I.
1)
DESTRUIR:. AI destruir un proceso se llevan a cabo las siguientes actividades:
.'IY :
~
- Quitar los!recursos al proceso.
- Eliminarlq d;e la lista de procesos.
.-
Borrar el PCB del proceso.
,I!
La destrucción de un proceso es mas dificil cuando éste ha creado procesos hijos. En'
.
'I
.
)I
algunos sistemas los procesos hijos se destruyen automáticamente' cuando su padre es destruido;
#I
en otros sistemas la creación de procesos es independiente y la destrucción del padre no tiene
efecto sobre los hijzs.,
I
.,
!I
En el caso be üNIX existen dos llamadas al sistema asociadas con la 'terminación de
procesos, estas son:!I/
exiio. Termina la ejecución de un proceso y devuelve un valor al sistema que indica la
I
forma en que el proceso terminó (status).
I!
w d r o . Suspende la ejecución del proceso que la invoca hasta que alguno de sus procesos
'I/
hijos termine.
/i
ii
13
-
si el proceso/I padre del que ejecuta la llamada a 'exit()' está ejecutando una llamada a
'wait()', se le notifica la terminación de su proceso hijo y se le envían los 8 bits menos
significativos del 4estado del proceso (status). Con esta información, el proceso padre puede saber
JI
en qué condiciones
terminó su proceso hijo.
Si el proceso padre no está ejecutando una llamada a 'wait()', el proceso hijo se
transforma en un proceso 'zombi'. Un proceso 'zombi' solo ocupa una entrada en la tabla de
procesos del sistema y su contexto es descargado de la memoria.
I
1
SUSPENDER. Un proceso está suspendido cuando se le han quitado temporalmente los
11
recursos asignados a él.
,I
in
REINICIAR.
proceso se reinicia cuando se le reasignan los recursos que se le quitaron
temporalmente al suspenderse.
CAMBIO DE PRIORIDAD. Cuando el atributo correspondiente en el PCB del proceso es
modificado.
I
BLOQUEO. El bloqueo de un proceso involucra las siguientes actividades:
1
- Quitarle el procesador
esperando la ocurrencia de un evento determinado.
- Algunas veces se le quitan recursos, para evitar problemas como el interbloqueo.
- Insertar el proceso en la cola de bloqueados.
I
t
I
DESBLOQUEO. AI desbloquear un proceso cuando ocurre el evento esperado se elimina
de la lista de bloqueados y se inserta en la lista de procesos listos
I/
DESPACHO. Se dice que un proceso es despachado cuando se le asigna el procesador.
d
11
2.1.4 Diferencias entre Proceso, Rutina y Corrutina
1
2.1.4.1 Rutina
'¡I
Una rutina' es un conjunto de estatutos y estructuras de datos propias. Tiene la
característica de ser una parte de código PASIVA, es decir, solo se ejecuta cuando se llama a
través de una instrdción CALL.
I
Cada vez que se llama, se ejecuta desde su primera insimcción. AI momento de ser
llamada solo se guardan parte de los registros del procesador, normalmente el apuntador del
programa [TOR94].' E s conveniente mencionar que por hardware se guardan ciertos registros; y
en lenguajes de alto;n?vel, es decir por software, pueden guardarse otros registros.
14
I
I
2.1.4.2 Corrutina
#
$1 .
Es un conjunto de estatutos y estructuras de datos propias. Es una parte de código
PASIVA, pero'!la forma de ejecutarse no es a través de una instrucción CALL sino a través de
una instrucciÓnTRANSFER.
solo la primera vez que se le pasa ei control con TRANSFER se ejecuta desde su primera
instmcción, 1% &hienteS
veces se ejecuta a partir de la instmcción siguiente al TRANSFER que
I
se c.iccutb en SUl código. Cuando se ejecuta un TRANSFER se guardan todos 10s registros de la
corrutina que ejecutó el TRANSFER y se cargan los registros de la corrutina a la cual se le
transfiere ei coifro~.
Algo importante sobre las comtina es que el control sobre qu6 corrutina se ejecuta está
't
codificado dentre de las propias corrutinas, lo que permite que sea en ellas donde se decide cual
será la siguiente komitina en ejecutarse.
I
'i
La ventaja de las comtinas es que es muy simple realizar aplicaciones que simulen
MULTIPROGFd4MACIÓN, el lenguaje MODULA-2 en su definición estándar contempla el
manejo de cornitinas [TOR94].
2.1.4.3 Proceso
Es un conjunto de estatutos y estructuras de datos propias. Es una parte de código
ACTIVA, su ejedución depende de un algoritmo de asignacihn del procesador y es la entidad a la
que se IC asignan recursos del sistcma como nicnioria principal y dispositivos; puede atravesar
una serie de estados, como se menciona en la sección 2.1.1.
t
Una vez que un proceso es creado, y se le asigna el procesador, comienza a ejecutarse
desde su primera,;instrucción, la siguientes veces que se le asigne el procesador correrá a partir de
la instrucción en la que se BLOQUEO o haya sido intemmpido.
I
Cuando se li: quita el procesador a un proceso, se guardan todos sus registros (cambio de
contexto), y al rd&ignarIe el procesador se cargan todos los registros del proceso al procesador.
i
Los procesos son los más utilizados debido a que las aplicaciones son más simples,
puesto que el control de la asignación del procesador no depende de ellos sino del algoritmo de
[TOR94]. Este algoritmo es ejecutado por el sistema operativo.
asignación del
1:
15
2.1.5 Hilos y Procesos
I
Algunos Sistemas como el O S 4 MVS, UNIX SUN y MACH ven a los procesos desde
dos puntos de &a:
COMO LA# /'UNDAD
QUE POSEE RECURSOS. A un proceso se le asigna
I
memoria Para Poder correr y periódicamente se le asignan otros dispositivos.
kea de
I
COMO UNA UNDAD DE DESPACHO. Un proceso traslapa su ejecución con la de otros
procesos y puede pasar durante su vida por varios estados como LISTO, CORRIENDO,
BLOQUEADO&.; y es despachado o administrado por el sistema operativo.
A la parte ,relativa a la unidad que posee recursos se le denomina PROCESO o TAREA,
mientras que a la; p h e que corresponde a la unidad de despacho se le denomina PROCESO
LIGERO o simplemente HILO (Thread).
I
11
El uso más sobresaliente del concepto de HILO es que se pueden tener múltiples HILOS
11
para el mismo proceso, de manera que toma mucho menos tiempo crear nuevos hilos que crear
un nuevo proceso."De este modo es más eficiente diseñar una aplicación que corra como un solo
proceso con MÚLTIPLES HILOS que correr dicha aplicación como PROCESOS MÚLTIPLES.
I1
Otra característica atractiva de los HILOS es que como solo existe un proceso, es directa
I
la compartición de datos entre los HILOS, mientras que en un esquema con múltiples procesos,
'1
se requiere la intervención del núcleo (kernel) del sistema operativo, para realizar la
compartición de d&os lo que hace más lenta la aplicación [TOR94].
2.2 Procesos Concurrentes
I
Los procesps son concurrentes si existen simultáneamente, o sea, si el inicio de uno
ocurre antes de la terminación del otro. Los procesos concurrentes pueden funcionar en forma
totalmente independiente unos de otros, o pueden ser ASINCRONOS lo cual significa que
pueden necesitar de ciertos mecanismos de sincronización y cooperación.
il
La concurrencia es muy útil para incrementar la eficiencia de programas que contengan
más de una secuendia de operaciones, cada una de ellas independiente de las demás.
1
El código con la característica antes mencionada puede dividirse en procesos, siendo cada
proceso una secuencia de instrucciones que se ejecuta concurrentemente a los demás procesos.
16
I¡
'
En un sentido estricto, la concurrencia Solo puede darse en' sistemas multiprocesadores:
Perol en sistemas
monoprocesadores es posible que se dé la concurrencia gracias a un algoritmo
t
de asignación del procesador, que hace que el procesador conmute entre diferentes procesos
ejecutando una barte de estos cada ciclo o QUANTUM.
I/
No es una tarea fácil determinar que actividades de un programa deben realizarse
concurrentemente
una vez que se implementan pueden surgir problemas.
, .
2.2.1 Problema
la 'Achializaci6n Perdida'
que tenemos dos transacciones (A y B) 'las cuales se ejecutan en forma
I
PARBEGIN
T IR ~ N S A C C I ~A;N
TRANSACCI~NB;
PAREND:
!I
TRANSA C C I O N ' ~
TRANSA CCIÓN B
I
TI, SALDOh := SALDOX
T2, SALDOB:= SALDOX
I!
~
:= SALDOA-1000;
T4, SALDOX := SALDOB-1000.
FIN DE TRANSACCI~NA
FIN DE TRAN S A C C I ~ NB
!
si TI < T2 $ 773 < 7-4
y SALDOX = 2000 en T I ; en T4 SALDOX debería ser Cero, Pero
a
D~
este
Problema
se
deduce que se debe i m p h e n t a r un control sobre
es
m n a de memoria comunes a mas de un proceso.
io
Y
2.2.2 Exclusión Mutua
I1
La exclusión mutua debe implementarse solo cuando más de un proceso tienen acceso a
datos compartidos modificables. Cuando los procesos realizan operaciones que no entran en
conflicto con otra;' operaciones en un proceso diferente se debe permitir que se ejecuten
I
concurrentementer Cuando un proceso tiene acceso a zonas de memoria compartida o datos
compartidos modificables (variables compartidas) se dice que entra en una SECCIÓN CRITICA.
Es evidente la diesidad
de establecer un control sobre dichas SECCIONES CRITICAS, o sea,
I/
que cuando un proceso alcance su sección critica se debe impedir que otros procesos entren en su
propia sección crítica hasta que el proceso que trabaja en su sección critica la abandone, despues
de lo cual solo unollde los procesos en estado de espera podrá entrar a su sección critica y los
demás procesos tendrán que esperar. Lo anterior significa que soto un proceso puede encontrarse
en su sección crit+a ai mismo tiempo.
/I'
17
/I
2.2.3 Semáforos
LOSsemáforos son la herramienta más usada para implementar la exclusión mutua.
Dijkstra define un semáforo como un objeto de tipo entero sobre el que se pueden realizar
I1
dos operaciones:, p Y V (Fig. 5 y Fig. 6), los nombres de estas operaciones provienen de los
thninos holandeses proberen (comprobar) y verhogen (incrementar). La operación P
decrementa el &lor del semáforo y se utiliza para adquirirlo. o bloquearlo. La operación V
incrementa el val.o(de1 semáforo y se utiliza para 1iberarlo.oinicializarlo. Un semáforo no puede
tomar valores negativos, cuando tiene un valor de cero, no es posible realizar más operaciones P
sobre el, si un proceso intenta realizar una'operación P sobre un semáforo cuyo valor es cero,
dicho proceso se bloquea .o duerme hasta que el proceso que adquirió el semáforo efectúa una
operación V sobre el mismo.
I
Las operaciones P y V deben ser atómicas para que funcionen correctamente. Esto es, una
It
operación P no puede ser interrumpida por otra operación P o V ni por ninguna otra operación,
esto vale igual pa+ ia operación V.
I
i
OPERACION 'P' SOBRE EL SEMAFORO
o que ejeeuta p(scm) toma el
y manipula in o las variables
Fig. 5.- Representación :gráfica de una operación
semáforo binario. ara imi>lementarla exclusión mutua sobie semáforo binario que habilita el acceso a una zona de
una zona de memoria compartida
memoria compartida,
jl
La atomicihad de estas operaciones garantiza que cuando varios procesos compitan por la
adquisición de un Semáforo, solo uno de ellos podrá realizar la operación.
Un semáforoten el sistema UNIX System V se compone de los siguientes elementos:
* ,;. .....i
q
. El valor del.semáforo.
. El identificador del último proceso que lo manipuló.
. El número de procesos espeiando'a que el valor del semáforo se incremente.
. El número de procesos esperando a que el semáforo tome el valor cero.
11
11
F
18
.De f0rm.a similar a los semáforos de tránsito, en programación, los semáforos tienen una
función informatiha, pero a diferencia de sus similares de transito. en programación, el valor del
semáforo representa la cantidad de recursos compartidos disponibles. Cuando un semáforo solo
11
puede tomar dos.i valores se dice que es binario, y son precisamente este tipo de semáforos los
usados para implementar la exclusión mutua.
:\
I
19
I
CAPITULO 3
ANALISIS DEL PROBLEMA
i
I
3.1 Descripción del Problema
La depuración de programas secuenciales es una tarea no muy compleja en términos
generales, pues solo se tiene un hilo de ejecución. Además existen muchos paquetes comerciales
I
que permiten realizar
la depuración de una forma simple y efectiva, como el TURBO
DEBUGGER de'!borland. En lo que se refiere a la depuración de un programa concurrente, no se
tiene conocimiento de un depurador que alcaiicc una profundidad en la depuración de procesos
superior a uno (verI figura 7). Como ejemplo. en el sistema operativo AIX (versión IBM del
el depurador con el que se cuenta solo puede seguir el hilo de ejecución
del proceso
de los procesos que se van generando dinámicamente.
DEPURACION CONCURRENTE ACTUAL
;I
ij
:i
PROCESO DEPURADO.
E n el estado actual de la depuración concurrente
i el proceso depurado lanza otros procebos, estos
1
uedan fuera del alcance del depurador.
,
~
"
Fig. 7 .- Depuración concurrente actual
il
Los depuradores como el adb y otros están basados en la llamada 'ptrace()', la cual es una
I!
llamada al sistema que permite la comunicación entre dos procesos: el proceso padre, que va a
actuar como depurador y el proceso hijo, que actúa como proceso depurado, pero si el proceso
'1
hijo genera otro proceso, no hay forma de saber como se comportará el nuevo proceso.
El principal problema que plantea el desarrollo de programas concurrentes es el siguiente:
el resultado de v&as ejecuciones de un programa secuencial, siempre será el mismo ya que se
tiene un solo hilo be' ejecución. En la programación concurrente no sucede lo mismo, ya que el
procesador está codutando entre los diferentes procesos en ejecución y el orden de asignación
del procesador no siempre es el mismo, por lo cual, si existen zonas de memoria compartida
1
entre dos o más procesos y no se implementa un control efectivo sobre el acceso a ellas, para
1)
evitar que dos'o más procesos accesen dichas zonas al mismo tiempo (lo que se conoce como
exclusión mutua), los resultados diferirán de ejecución en ejecución, sobre todo el o los
resultados que depenban del valor que tomen las variables comunes a todos los procesos, o sea
aquellas variables qui residan en zonas de memoria compartida.
!
'!
20
confiables.
El ambiente gráfico en el cual trabaja el depurador se desarrolló utilizando X Window y
Motif. Dicha interface gráfica contiene un menú de botones y está dividida en subventanas, cada
una de las cualeil tiene una función bien definida.
Una de las 'ventanas contiene un espacio para visuaiizar el texto del proceso depurado,
I1
otra ventana contiene
un botón por cada proceso generado dinámicamente.
I
/I
La funciin de los botones es permitir la visualización del código e información del
proceso que se tlija, otra ventana tiene la función de servir como entrada de comandos y la
última ventana tiene la función de mostrar el valor de las variables elegidas con anterioridad.
I/
Para el desarrollo de la tesis se utilizaron estaciones de trabajo SPARC con procesadores
RtSC trabajando /con el sistema operativo Solaris (UNIX Sistema V versión 4) de la compailía
3.2. Soluciones Posibles
Una de las posibles soluciones reside en el manejo de comtinas (la definición de comtina se
sección 2.1.4.2).
vi6 en el capitulo
La ventaja de las corntinas es que facilitan la realización de aplicaciones que simulen
multiprogramación. El sistema UNIX no contempla el concepto de 'corrutina' por lo que ésta
solución no se implementó y solo se menciona a manera de información general.
I
Otra solución es por medio de mensajes entre el depurador y los procesos depurados. El
código de depurdhón insertado en los procesos es activado a través de los mensajes enviados
desde el depurad&;.La sincronización entre el depurador y los procesos depurados se implementa
a través de un inte;cambio de mensajes entre ellos. Como se vio en el capitulo 2 el sistema
operativo LJNIX sí contempla el manejo de mensajes y proporciona herramientas para ello.
Una solución adicional es el control por medio de semáforos. Como se vio en el capitulo
2, los semáforos permiten el manejo de:
11
- Exclusión'I mutua.
- Sincrohiiación entre procesos.
Y la sincronización entre ei depurador y los procesos depurados se lleva a cabo
mdiante la inserción de operaciones de semáforos junto con el código de depuración
propiamente dich;.
I/
,
,
La solución
,I
elegida, que se describe en la siguiente sección es, con algunas
modificaciones la ultima opción de solución mencionada en esta sección.
Ir
3.3 Metodología de Solución
'1
Para lograr la depuración de los procesos generados en forma dinámica por un programa,
lo cual es el objetivo de esta tesis, se implementó un esquema de depuración que involucra las
siguientes etapas:
1
.
- Precompilación
del código original.- En esta etapa se recaba información sobre
variabl& funciones, etc.
1
En esta etapa se prepara 2 código original para
conten& el código de control y depuración propiamente dicho, y se inserta dicho
código.!
- Inserción del código de control.-
-.
Construcción de listas de símbolos. En esta etapa se guarda información sobre el
tipo, nonibre y alcance de las variables.
I/
2
- Compilación
y ejecución del código preprocesado. En esta etapa'se compila y ejecuta
'I
el programa preprocesado ejecutándose como un proceso hijo del depurador principal.
- Comunicación entre depurador y procesos usando memoria compartida y archivos.
Esto es necesario cuando se quiere depurar un proceso de un nivel inferior al de los
proceso$ &jos del proceso depurador.
- Sincroni,hónde los procesos mediante el uso de semáforos binarios.
Con ellos se
garantiza que solo habrá un proceso depurador y un proceso depurado al mismo tiempo.
1
Esta metodología de solución se seleccionó pensando en los problemas de
transportabilidad, y) que el basar la depuración en el análisis y preprocesamiento del código
fuente nos brindaluna independencia del hardware sobre el que se ejecute el depurador, ya que
solo se requiere que, use el sistema UNIX, contar con un compilador que soporte el ANSI C , y
que tenga las facilidades para correr una interfaz motif.
I
I
!
22
CAPITULO 4
IMPLEMENTACION DE EL DEPURADOR
j/
I
4.1 Diseño Conceptual del Depurador.
I
El reto másiimportante en el desarrollo del depurador de procesos concurrentes fue lograr
una profundidadlen la depuración de los procesos hasta cinco niveles.
I
.
Para lograr el objetivo antes mencionado, se implementó un esquema de depuración en el
que el depu-dor'bide la información a el proceso padre del proceso que el usuario desea depurar.
Como se,muestra en la figura (Fig. 8), el depurador principal solo puede depurar
directamente a sulproceso hijo que es el programa principal que se desea depurar, para el caso de
I
los procesos que están del nivel dos en adelante el control es indirecto llevándose a cabo a través
del proceso padri'del proceso a depurar.
'1
1
DEPURADOR DE PROGRAMAS CONCURRENTES
PROGRAMA
NIVEL 1
DEPURADOR
NlVEL 2
NIVEL 3
/I
NlWL 4
NIVEL 5
PROCESOS
GENERADOS
DINAMICAMENT
NIVEL 6
II
LA COMUh.,ACION SE REALlZA A TRAVEZ DE LA MEMORIA
COMPARTIDA Y ARCHIVOS
g. 8.- Diseno conceptual del depurador
4.1.1 Smcronizaci6n y Control de los Procesos Depurados.
El depurador se diseño en base a un algoritmo desarrollado para permitir la
sincronización de los procesos generados por el programa depurado.
I
En éste capítulo se presentarán: el algoritmo de sincronización, en base al cual está
desarrollado el depurador; los algoritmos de precompilación, evaluación de expresiones
lógicas y preprocedamiento de comandos.
I1
/
23
--
- --- _-~_
-
-____
__.-
__
I
La fuI“.%n que nos PropOrciOM ei sistema UNIX
para activar el bit de traza de un
Proceso Y que nos Permite acceder a sus datos, es la llamada ‘ptraceo’. Como se mencionó en
el Capitulo anterid! es en base a ésta llamada que están implementados los depuradores que
actualmente fundionan bajo UNIX.
I
-
11
La 1lam:da
‘ptraceo’ funciona con la relación proceso depurador
proceso
deemado, en donde el proceso depurado es un proceso hijo del proceso depurador; se puede
hacer funcionar a ‘ptraceo’ con varios hijos, pero SI los procesos hijos del proceso depurador
generan otros procesos, estos quedan fuera del alcance de ‘ptraceo’.
I
El algoritmo desarrollado permite que los procesos lanzados por los procesos hijos y
1
los procesos layados por cualquier otro proceso hasta una profundidad de cinco niveles
puedan ser depurados mediante el uso de ‘ptraceo’.
II
Para que el algoritmo funcione es necesario habilitar a cada proceso para ser el
depurador de sus;procesos hijos, si los tiene o los llega a tener, esto es, cada proceso cuenta
con el código necesario para llevar a cabo la depuración de sus procesos hijos. El módulo
I
encargado de crear las listas de simbolos y preparar el código original para contener el código
de depuración y
necesario es el precompilador desarrollado para este fin, el código
precompilado queda estructurado de la siguiente forma:
wl
I
...
INSTRUCCION ORIGINAL;
P(sem binario);
- 1
Obtener n p e r o de línea y nombre de función;
seguimientoo;
V(sem binario);
INSTI¿-UCCION ORIGINAL;
...
I/
‘1
La funciónitdel algoritmo - implementado en ‘seguimiento()’ - es permitir que en todo
momento solo exista un proceso depurado y un proceso depurador, los demás procesos
permanecen esperedo en la instrucción en donde se quedaron la ultima vez que fueron
depurados, para garintizar esto se hace uso de semáforos binarios y mensajes a través de la
memoria compartida.’
1
A continuación se presenta el algoritmo desarrollado para permitir la depuración de
procesos.
I1
24
I
1
seguimiento()
inicio
comienzo:
Si(proceso-actual != proceso-depurado)
inicio
I1
Si(ProCeSO-aCtual = = proceso-depurador)
inicio
.
V(sem-binano); activar Ccdigo depurador();
P(sembinaA0); ir a comienzo;
!I
tin
1
enotrocaso
inicio
V(sem binar¡#);
Mientras (proceso-actual != proceso-depurado y proceso-actual != proceso-depurador);
ir a comiemci!
fin
fm
. .
,i'
Si(la lineaactual, tiene un punto de parada (breakpint)) activa breakpoint;
Si(llamando-funcion y salta funcion activado) desactiva trazaSi((traza activadd o breakpoi% activado) y (proceso-actual = = proceso-depurado)) inicio
enviar numerh de linea;
Detener ejecdcion y devolver el control al proceso depurador;
desactiva-breakpoint ;
Si(proceso-actual != proceso-depurado)
inicio
',
1
V(sembinari0); ir a comienzo;
fin
fin
I'
fm
I
i!
Codigo-depurador()
inicio
siguiente:
Si@roceso actual no es igual a proceso-depurador) terminar depuracion;
en otro caso Si(dep4ar otro proceso hijo) orden = cambiar de proceso depurado;
en otro caso
inicio
Esperar orden;
Obtener elementos ,de la orden;
~
I
I
fin
!
ejecutar la orden;
devolver el resultado;
ir a siguiente;
I
fm
I
1
A continuación se presenta la figura 8a, en la cual se ilustra gráficamente el
funcionamiento del algoritmo anterior.
25
9z
iI
Y
3.- Una vez recabada la información se procede a insertar el código que hace
posible &I control y seguimiento de la ejecución de los procesos.
I
4.- Una vez terminado el preprocesamiento el código original es desplegado en la
v e n d a de edición y seguimiento de la interfaz del depurador.
que el usuario oprime el botón ‘Ejecutar’ el código preprocesado es
compilado y ejecutado.
/I
j
ii
6.- La comunicación entre los procesos y el depurador se realiza usando memoria
cornpakida y archivos.
. ,
/
La siguiente .figura ( Fig. 9), ilustra gráficamente el proceso descrito.
I
21
~-~-----
-
i
- -_
--
i
/
.I/.
4.2.1 Elementos del Depurador.
I1
i. implementado
.
El depurador
cuenta con los siguientes elementos (Fig. IO):
Fig. 10.- Estructura interna del depurador de procesos
concurrentes.
I1
-Una interfaz
amigable al usuario.
.I
- Un modulo preprocesador que lleva a cabo la inserción de código de control y
recaba inforrhación del programa a ser depurado.
- Un modulo preprocesador de comandos.
- Un analizador y eva1uador.deexpresiones.lógicasusado para procesar los
puntos de parada (breakpoints) condicionales:
. .
~
.
I/
~
i
4.2.1.1 La Interfaz del Depurador.
.
~.. . . .
.
'
i
Una de las etapas más importakes en la implementación del depurador fue el diseño de
una interfaz amiga6ie: que le permitiera ai usuario tener acceso a: las funciones proporcionadas
I)
por el depurador de ,manera fácil y rápida.
'1
I1
La interfaz del, depurador fue desarrollada usando X Window y Mors está formada por
un conjunto de ventanas, cada UM de las cuales tiene una funciónespecífica en la interacción del
usuario con el depudador.
11
Los elementos que forman la interfaz se muestran en la siguiente figura (Fig. 11).
1
28
!I
i:l
,
Iq,TER.FA Z: D E L D E P U U A I>O R*C 0 . N C U RRbE,N,TfE,
I... MENU A ü A S E DE BOTONES.
2.- EDITOR D E T E X T O .
>...VENTANA EN L A CU&L SEDESPLIEGA UN BOTON POR C A D A
PROCESO A C T I V O SUJETO A D E I U R A C I O N
CONSULTAS A L D E P U R A D O R
Fig. 11.- Interfaz gráfica de usuarlo (GUI) del depurador de program
concurrentes.
I/
4.2.1.1.1 El Menú de la Interfaz
El menú de la interfaz del depurador de procesos concurrentes está formado por botones,
los cuales son activados mediante el ratón.
Cada bokn de la interfaz ejecuta un comando o en su defecto, si es un botón del menú
principal y contiene un conjuito de opciones, al pulsarlo muestra un menú desplegable con las
opciones disponibles.
Existen botones cuya acción no necesita de ninguna información adicional por parte del
usuario, por/:lo tanto, el comando se ejecuta ,con solo seleccionar el botón indicado. Si el
comando del botón seleccionado necesita información adicional, por ejemplo: el número de línea
'1 va a insertar un,punto de parada (breakpoint), en este caso al oprimir el botón se
sobre la cuali,se
despliega el i!ombre del comando en la ventana correspondiente a la línea de ordenes para que el
11
usuario teclee la información adicional conforme a la sintaxis del comando, una vez terminada
esta operaciok el usuario oprime la tecla ENTER o RETURN y el comando se ejecuta.
'1 :
4.2.1.1.2 La p t a n a de Edición y Seguimiento
En kventana de edición y seguimiento, se muestra el código original del programa que
se va a depur,ar'y es en esta ventana en la cual se realiza el seguimiento de la ejecución de dicho
código, cuan& se usa la opción de ejecutar paso a paso o cuando el programa se detiene en un
punto de parada (breakpoint).
Esta ventana cuenta con facilidades de edición de texto, si se desea modihcar el
programa, pero si el programa se modifica, el código necesitará recompilarse para volver a
depurarlo. ;j
It
29
4.2.1.1.3 La Ventana de Identificadores de Proceso
En esta ventana se muestra un botón por cada proceso activo sujeto a depuración,
obviamente ai:inicio de la ejecución del programa ésta ventana muestra el botón que identifica al
programa principal, puesto que es también un proceso, los siguientes botones aparecerán con
11
cada llamadaa ‘fork()’. Cuando un proceso ejecuta una llamada a ‘exit()’, el botón identificador
de dicho prockso desaparece, ya que la llamada a ‘exit()’ termina con el proceso que la invoca.
Los botones no solo identifican a cada proceso en particular sino que tienen la función de
llaves de entrada al proceso que identifican, permitiéndole al usuario conmutar entre el código de
los distintos procesos en ejecución con solo seleccionar el botón que identifica cada proceso, al
entrar a un proceso, este se encontrará en la línea en la que lo dejo la última vez que estuvo en el.
I
La estructura de los botones identificadores de proceso es la que se muestra en la
siguiente figda (Fig. 12).
Fig.!l2.- Formato de los botones identificadores de proceso.
/I
I!
4.2.1.1.4 La Línea de Ordenes.
!
En esta ventana el usuario puede invocar los comandos del depurador sin necesidad de los
botones, también se usa como ya hemos visto para proporcionar información adicional a los
comandos del depurador que así lo requieran. Una vez tecleado el comando conforme a su
sintaxis, se ofxime la tecla ENTER o RETURN y el comando se ejecuta.
1)
4.2.1.1.5 La Ventana para Resultados d e Consultas.
.
,
!I
Cuando’el usuario desea consultar el valor de una variable, el resultado de la consulta se
muestra en esta ventana, también se muestran avisos sobre comandos ejecutados exitosamente o
errores comefidos por el usuario.
I/
El depurador cuenta también con un botón de ayuda en el que se muestra una descripción
de la sintaxi4 de cada comando así como también una breve descripción de lo que’hace cada
,.
botón del menú:
30
4.2.1.2 El Mddulo Precompilador
I1
Como!l se dijo anteriormente, el algoritmo de sincronización funciona gracias a la
preparación del código original y a la información que se recaba del mismo en la etapa de
precompilation,' siendo esta una etapa fundamental en el proceso de depuración.
'I1
cumdo un programa en lenguaje ANSI 'C' es seleccionado desde el menú, el código
onginal es catgado por el depurador y transferido al modulo precompilador, en el cual dicho
código es preprocesado. El preprocesamiento involucra las siguientes etapas:
I\
- ANÁLISIS LÉXICO .- En esta etapa se recaba información sobre:
- N h e r o de variables globales.
- TiPo y nombre de las variables globales.
- Numero de variables en memoria compartida.
- TiPo y nombre de las variables compartidas.
- Numero de funciones del programa.
- Tip.0y nombre de cada función.
- TiPo y nombre de los parámetros de cada función.
- Tipb y nombre de las variables locales de cada función;
.
/I
- INSER:CIÓN DE CODIGO DE CONTROL .- El código insertado consiste en
operaci?ries de semáforos para sincronizar los procesos, código necesario para la
comunicación del depurador con los procesos usando memoria compartida,
código'bece'sario para el seguimiento del programa y el código para que cada
procesd pueda obtener información de sus procesos hijos.
I/
El códigb./ preprocesado es el que se va a ejecutar al oprimir el botón 'Ejecutar', mientras
que el código original se transfiere al editor para el seguimiento del programa.
i
El códigd de control no afecta el comportamiento del programa, ya que su efecto solo
podría notarse como un aumento en el lapso de tiempo entre la ejecución de cada instrucción
original. El algoritmo que para llevar a cabo la precompilación e inserción del código de
depuración es el Siguiente:
L
I/
,I
Precompilar(nombre-archivo-entrada, nombre-archivo-salida, pasada)
inicio
I/
Abrir para lecnjra (archivo-de-entrada);
Abrir para escritura (archivo-de-salida);
leer-caracter-de(nombre-archivoentrada) ;
Mientras no sea fin de archivo
I/ !
inicio
Si(pasada = =
O)
<.!
inicio
- Poner defimitadores de bloque en donde falten;
llenar la lista-de-lineas con el numero de linea y la posicion del primer caracter de cada linea;
- Reempldbr los comentarios con espacios en blanco respetando los tabuladores y saltos de linea:
~
iI
i
- grabar cada linea procesada al archivo de salida;
fui
.I1
1
en otro caso Si(pasada = = I)
inicio
- Insertar dcclaraciones dc variables de control;
Si(es-fin-de-linea y es linea significativa y no es comentario)
inicio
- Injertar codigo de rastreo de funciones y lineas de codigo
significativas;
- Inskrtar codigo de control;
fin
- grab& cada linea procesada al archivo de salida;
'1
fui
en otro 'Laso .%(pasada = = 2)
inicio I
- Detebtar y procesar las lineas con 'fork()';
- Recabar informacion sobre :
1 tipo y nombre de variables globales;
tipo y nombre de variables compartidas;
I/ tipo y nombre de cada funcion;
tipo y nombre de los parametros;
'tipo y nombre de variables locales;
- Insert: codigo al inicio de cada funcion para detectar
la direccion de las variables locales y los parametros;
- grabar cada linea procesada al archivo de salida;
fin
I1
en otro caso Si(pasada = = 3)
inicio
- Deteciar,llamadas a funciones del usuario;
- Insertar codigo que indique la entrada a la huicion y el regreso;
- Detectar 'y procesar las instrucciones 'exit()';
- Deteciar y procesar las instrucciones 'wait()';
- Detecfar y procesar las instrucciones 'semop()';
- inserta al inicio de cada funcion d i g o para detectar
la direccion de las variables globales y los compartidas;
- insert$ el codigo de iniciaiizacion de las variables de control en
memoria compartida, as¡ como de los archivos;
- Inserta\ el codigo de depuracion;
- grabarjcada linea procesada al archivo de salida;
fin
I
en otro caso Si(pasada = = 4)
inicio
Poner numeros a las lineas del archivo de entrada;
I
- grabar cada
linea procesada al archivo de salida;
fin
leer-cdacter-de(nombre-archivo-entrada);
fin Mientras;:
.
4
/
-
1
I¡
cerrar(archivo-de-entrada);
cerrar(archiv0-de-salida):
fin F'recompilar.
,
.
'
I1
32
I T - Ir
4.2.1.3 El Preprocesador de Comandos.
It
Este módulo es el paso intermedio que siguen los comandos seleccionados por el usuario
antes de Ileg4, en su versión final, al proceso que se está depurando.
I
[I,*&
(.<Í~iiioi,''iJ/
-
~~
~~
Representación gráfica de la interacción del'
PREPROCESADOR DE COMANDOS con la interfazy los procesos
depur ados
Fig.
13.-
La función de este modulo es preprocesar, como su nombre lo indica, los comandos
seleccionados por el usuario (Fig. 13). El preprocesamiento consiste en cambiar los nombres de
las variable: involucradas en el comando por su dirección en memoria así como añadir
parátnetros a h o n a l e s relacionados con el tipo de variable involucrada. El preprocesamiento es
totalmente tfmsparente para el usuario. EI algoritmo que realiza éste preprocesamiento y ei
envio de la olden preprocesada es el siguiente:
I/
inicio
el final de orden-original)
,.
inicio
..
obten su abrevianira e incluirla en la orden
preprocesada; si no salir;
- Si es una c4ndicion para un punto de parada (breakpoint), llenar la'lista
de puntos de parada (breakpoinrs) condicionales y salir;
- Obtener nombre de variable;
Si la variadie esta en las listas de simbolos, buscar sus datos en el archivo;
si no mandar mensaje y salir;
- Poner en la ventana de respuestas a las consultas el nombre de la variable y la cadena
- Sustituir el nombre de variable por su direccion en la orden preprocesada;
Detectar el/tipo y modificadores de tipo de'la variable;
Si es UM obracion de modificacion del valor de una variable, obtener
el nuevo valor e incluirlo en la orden preprocesada;
Si la variable es un arreglo obtener lo indices del elemento que se'va a modificar;
si no el valor de los indices sera de -1;
- incluir en la orden preprocesada los limites, tipo y modificadores;
Si la variable no es un arreglo el valor de los limites sera de .1;
~
'
-
33
" = ";
- Si no cuenta con modificadores de tipo, el espacio que ocupan en la
orden prepr:+esada llevara un caracter '#';
puntero, incluir en la orden preprocesada la indicacion de puntero;
si no ese espacio io'ocupara un caracter '#';
fin
I1
- Enviar la orden preprocesada al proceso depurador;
fin
,
- Si la variable es
II
4.2.1.4 El Analizador
de Expresiones Lógicas.
I!
Una lge las características más importantes incluida en el depurador desarrollado es la
posibilidad de condicionar puntos de parada (breakpoints), ya que es una característica común
en los depufadores comerciales de la actualidad.
.I,
I
.
;Esteirnódulo es la base de la implementación de los puntos de parada (breakpoints)
,condicionales..El analizador de expresiones lógicas recibe, desde la linea de ordenes una
a la forma POSTFIJA para ser evaluada (Fig. 14).
interiaz y el preprocesador de comandos
Este módulo interactua con el preprocesador de comandos, ya que genera consultas para
averiguar e¡ valor de la o las variables involucradas en la expresión evaluada. El resultado dc la
evaluación~lserásiempre O (FALSO) o 1 (VERDADERO), lo cual decidirá si el depurador se
de parada (breakpoint).
detiene o ignora el. punto
.
Las c!ondiciones se establecen sobre' puntos de' ':parada (breakpoints) previamente
insertados como puntos de parada (breakpoints) simples o incondicionales. Los algoritmos que
llevan a cabo'el cambio de'notación y la evaluación de la expresión lógica son los siguientes:
'1
,
.
,
34
Conveniraqostfijo(condicion)
inicio
Inicializar la pila de operadores;
Mientras(n0 sea el final de la condicion)
inicio
11
formar token';
Si(token = = operando) agregarlo a la cadena postfija;
en otro caso Si(token es operador valido)
inicio
vacia = s!cary_checar(pila-operadores, op-sacado);
Mientras(!vacia y checargrecedencia(op-sacado,token))
inicio
Agregar op-sacado a la cadena postfija;
op-sacado = cadena nula;
vacia 2 sacarychecar(pi1a-operadores. op-sacado);
fin
Si(!vacia),l
,
inicio
meter(pila-operadores, op-sacado);
op-sacado = cadena nula;
I
~
I
Si(vacia o token no es un ')')
inicio ,I
meter@ila-operadores, token);
fui
fin
fin
Mientras(!pila-operadores-vacia)
inicio
sacar(pi1a:opkradores. op-sacado);
Agragar op-sacado a la cadena postfija;
op-sacado. = cadena nula;
fin
devolver(Evaluar expresion(postfija));
fin Convertir-i',p i t f i j o
j/
'
.I
I
'1
checargrecedencia(ant,posi)
I* Determina'!¡ existe o no precedencia del simbolo ANT sobre el sunbolo POST cuando ANT esta a la
izquierda de POST *I
,
'
inicio
Si(ant = = "(") devuelve O; I* pred('(',op) = False y pred('(',')') = False *I
Si@ost = = ;(") devuelve O; I* pred(op,'(') = False *I
Si@ost = = ;)") devuelve 1; I* pred(op,')') = Tnie *I
Si(ant== ' ,I< " o a n t = = " < = " o a n t = = " > " o a n t = = " > = " ) d e v u e l v e ] ;
Si(mt = = "'=="II ant = = "!=")
inicio
SI(pSf = y " & & " O p o s t = = " 1 J " o p o s t == "!="opost = = "==")devuelve];
91;
findevuelve
Si(ant = = "&&")
inicio
Si@ost = = "&&" o post
devuelve O:
==
"
1 I ") devuelve 1;
35
.
i
Si(ant = = - 1 1 "I)
inicio
t '
Si(post = = "'1 I ") devuelve 1:
devuelve O;
fin
I1
fin checarprecedencia
Evaluarexpresion(postfija)
inicio
Inicializar la pila de operandos;
Mientras( no sea el final de la cadena postfija)
inicio
formar tokjn:
Si(token e; un operando)
inicio
Si(esconstante-numerica(token)) almacena su valor;
en otro ;aso si(esconstanteatfanumerica(token)) almacena su valor;
en otro caso es una variable
inicio
- orden = ver token;
- enviar orden al preprocesador de comandos y esperar respuesta:
- buscar token en listas de simbolos para averiguar su tipo;
- leer.el valor devuelto por el proceso en una variable del tipo
de dato adecuado;
- alm4cenar el valor leido;
fin
metei(pila-operandos, valor):
fin
¡,
en otro caso Si(token es un operador valido) inicio
sacar(pifa operandos,operando2):
sacar(pifa-operandos,operandol);
Si(oper&dÓZ'es constante numerica o es constante alfanumerica) igualar al tipo de dato de operandol;
1,operand02);
valor = ,,Comparar(operador,operando
meter(pi¡a operandos,valor);
fui
1 fui
sacar(pila-operandos.valor):
devolver(va¡or);
fin Evaluar-exbresion
A.
)I
'
I!
4.2.2 Descripción de una Sesión de Depuración.
,:,
11
En esta sección se describen los pasos que seguirá el usuario en una sesión de depuración
t
en el depurador de programas concurrentes. Las etapas del proceso son las siguientes:
36
/
1.- Selección y ejecución del programa a'depurar.
. *
.En la opción Archivos del menú (Fig. 15). se selecciona la subopción Abrir. Una vez
hecho lo anterior aparece una ventana de selección de archivos (Fig. 16). dentro de la cual se
despliegan los 'nombres de los archivos disponibles eii el directorio; la selección se realiza
pulsando dosveces
el botón del mouse en el nombre del archivo (programa en 'C') elegido o en
.I
su defecto seleccionando
el nombre del archivo y despues el botón Ok.
'I
Como resultado de los pasos anteriores el programa seleccionado pasa por el proceso de
precompilación, después de lo cual el código fuente del programa aparece en la ventana de
edición y seguimiento, esto indica que el programa está listo para ser ejecutado bajo el control
del depurado!.
2.- Seguimiento y control d e la ejecución del programa.
I
Una,vez que el código fuente del programa a depurar aparece en la ventana de edición y
seguimiento, el siguiente paso es oprimir el botón Ejecutar del menú principal. AI inicio de la
ejecución del programa, aparece un botón en la ventana de identificadores de procesos, ya que el
programa pincipal se lanza como un proceso hijo del programa depurador; cada vez que el
I
programa lance
un proceso, aparecerá el correspondiente botón identificador en la ventana de
I1
identificadores de procesos.
I
'
37
t
j/
Una vez que el programa esté ejecutándose, puede usarse el botón trazu. Después de cada
pulsación de ei botón trazu, el proceso que se está ejecutando avanza una instrucción,
proporcionando lo que se conoce como ejecuciónpaso upaso (step by step). Pueden establecerse
puntos de parada (breakpoints). En el menú principal existe un submenú con las diferentes
operaciones 'Lobre los puntos de parada (breakpoints) (Fig. 18), además de las operaciones de
inserción y 'Iborrado, el depurador permite el condicionamiento de cada punto de parada
(breukpoinl), '
La pulsación del botón continuar hace que el proceso que se está ejecutando continúe su
Jl
ejecución n o F a l hasta encontrar un punto de parada (breakpoint), si no existen puntos de parada
(breakpoints] el proceso se ejecutará hasta su terminación.
,
Una,& las funciones de los botones identificadores de proceso es' como su nombre io
'1
indica, identificar a cada proceso en ejecución mostrando el número PID (identificador de
proceso) dellproceso padre y el número PID propio del proceso, pero. además dichos botones son
la llave o puerta de entrada al proceso identificado por cada botón (Fig. 17); esto quiere decir lo
siguiente, cuando el usuario pulsa uno de los botones, e1 &sor de seguimiento se posiciona en la
primera instkcción del proceso identificado por el botón o en la última instrucción ejecutada por
'r(
el proceso cuando
no es la primera vez que se accede a'el. Cuando un proceso alcanza una
instrucción le+(), su botón identificador desaparece indicándole al usuario que el proceso
terminó.
38
Aparte de las operaciones ya mencionadas el usuario puede consultar y modificar el valor
de las vuriuples tanto locales, globales y compartidas del programa depurado (Fig. 19). Las
respuestas del depurador a las consultas realizadas por el usuario se muestran en la ventana de
resultados de consultas del depurador.
39
I
Las ordenes del depurador pueden ser tecleados directamente en la ventana de comandos
del depurador o en su defecto, si el usuario no recuerda el nombre de la orden puede pulsar el
botón correspondiente en el menú principal, si la orden no necesita información adicional se
ejecutará inmediatamente, de 10 contrario, escribirá la orden en la ventana de comandos del
I1
depurador para que el usuario teclee la información adicional que se necesite.
It
La ventana de respuestas a las consultas es editable (Fig. 20), esta característica le
permite al usuario incluir anotaciones sobre los resultados mostrados a lo largo de la ejecución de
los procesos (Fig. 21).
I
40
I se' consulta el valor de una variable, solo se muestra el valor de la variable en el
Cuando
momento de'I hacer la consulta, si el valor de la variable cambia ese cambio no se refleja en la
ventana de respuestas a las consultas.
II
Cabe hacer mención de que en cualquier punto de la ejecución de los procesos que
11
forman el programa concurrente es posible interrumpir y reiniciar la ejecución de todo el
1
programa con solo pulsar el botón Reiniciar.
4.2.3 Sintaks de los Comandos del Depurador
I/
Visualizar valores de variables:
nombre ddl comando : ver
nombre adreviado : v
I
: ver <nombre de variable>
sintaxis I
Modificar valores de variables:
nombre del comando : poner
nombre abreviado : p
: poner <nombre de variable> <valor> <lugarl> <lugar2>
sintaxis
: lugar1 .- se usa en caso de modificar un elemento de un arreglo o
observaciones
cadena
lugar2.- se usa cuando se va a modificar un elemento de una cadena
que forma parte de un arreglo de cadenas.
/I
1
41
Insertar breakbo'ints:
nombre del "comando : parar
nombre abdviado
:b
:
parar <numero de línea>
sintaxis
Condicionar hbreakpoint:
nombre del!comando : cond
nombre abreviado : s
: cond <numero de línea> <expresión boolean@
sintaxis
: La expresión booleana debe estar en notación INFIJA, con o sin
observaciones
paréntesis.
I
1.
.
,
,
.
.¡I
'!
/i
i
ejemplo: (x == y) && (z == 8)
Los operadores soportados son los siguientes:
&& : and lógico.
> : mayor que..
< : menor que..
11 : or lógico.
>= : mayor o igual que..
!= : diferente de..
<=
: menor o igual que..
== : igual que..
I .
Borrar un breakpoint:
.
.
nombre de'l comando : limpia
nombre abreviado : 1
: limpia <numero de línea>
sintaxis
I
Borrar todos los breakpoint:
nombre del comando : lmtodos
nombre abreviado . : t
: lmtodos
sintaxis
I
Ejecución libre hasta encontrar un breakpoint:
nombre del comando : sigue
nombre aireviado
:c
I
[
:
sigue
sintaxis
42
I
CAPITULO 5
PRUEBAS REALIZADAS
Para comprobar el buen funcionamiento del depurador de programas concurrentes
‘I
desarrollado, se sometieron a depuración los programas resultantes de codificar en ‘C’ siete de
t
los algoritmos concurrentes más importantes. Los algoritmos codificados son los siguientes:
- Dekker versión 1.
- D e e e r versión 2.
- D e q e r versión 3.
- Dekker versión 4.
- Dekker versión 5.
- Lectores y escritores.
- Productor
consumidor.
r
Mediante el uso del depurador pudieron comprobarse las Características y el
funcionamiento de cada uno de estos algoritmos, ya que el usuario puede ejecutar los procesos
lanzados eniel orden que desee, teniendo la oportunidad de colocar a los procesos en una
/I
y asignar valores a las variables en memoria compartida.
situación específica
I
5.1 EJEMPLO.- Análisis de la Primera Versión del Algoritmo de Dekker.
II
En este ejemplo se tiene el pseudocódigo de la primera versión del algoritmo de Dekker,
1
con las insfrucciones significativas de cada proceso numeradas (El .. E5), cada número
representa un estado del proceso.
Los &bios de estado que se den durante la ejecución del programa dependerán de qué
proceso a v i c e , en este ejemplo los cambios de estado que ocurren son cuando AVANZA EL
PROCESO 1, cuando AVANZA EL PROCESO 2 y cuando AVANZAN AMBOS PROCESOS.
Se construyó ( sin usar el depurador) una tabla cuyas columnas fueron ESTADO
ACTUAL y’lcomo ESTADOS FUTUROS se tuvieron todos los posibles cambios de estado que
/
pudieran darse.
Se pa& de un estado inicial que es el estado 1,l (EI,El) y se obtuvieron todos los
posibles esfados futuros, después, se tomó como estado actual el siguiente estado futuro NO
analizado’ y’/[seobtuvieron todos sus posibles estados futuros. Se continuó de esta manera hasta
que cada estado futuro fue analizado.
t
Usando el depurador de procesos concurrentes, se pudo depurar el código en ‘C’ de este
algoritmo~y’lcomprobarla ocurrencia de cada uno de los estados indicados en la tabla. Una vez
Jj
botones
que el programa
principal ejecutó los fork’s para lanzar cada proceso, se usaron .los
.
identificadores de proceso para pasar a cada uno de los procesos que.fueron lanzados.
{
(
43
6.
A continuación se muestran el pseudocodigo de la priiiiera versión del algoritmo de
Dekker con Its instrucciones significativas numeradas y la tabla de estados resultante.
Primera Versión del Algoritmo de Dekker
program Dekkirl;
var processnumber : integer:
El
E2
E3
EA
E5
procedure procesol ;
begin
while true do begin
while processnumber = 2 do;
slcción-critica-uno; ;
I
processnumber := 2; ;
op-actividades-uno;
end
end;
1
procedure proceso2;
begin
while true do begin
while processnumber = 1 do;
sección-critica-dos;
. processnumber := I;
otras-actividades-dos;
end
end;
El
E2
E3
E4
E5
begin
processnumbef := 1;
parbegin
procesol; proceso2;
parend
end.
I
Tabla de Estados Futuros de la Primera
Versión del Algoritmo de Dekker
1.3-=2
21
1
22
13
2.3
3.1
I
32
1
,
I
-
1.4
24
4,1
42
1.5
25
51
52
3.5
5.3
4.5
5,4
55
2lpmessninber=2
3,l pocessnnber=1
22prKswkw-2
3,2fmxsuTk=l
23
23
\
41
4.2
24
24
5,1
52
25
33
1,1
1.2
4.5
1.3
55
1,4
1.5
22
3,2fmxsuTk=l
2 2 7 = l
23pocecsurlier=2
1.4
24
32
MESPCoIBLE
32
1.5
24
NOESposlBLE
42
NOESmBE
25
NOESmBLE
5.2
NOESPOSIBLE
21
3.1
1,2
1.3
4.1
1.4
51
1.5
1.1 ,
~
25
4,2
4.2
1.1
21
52
5.3
3.1
54
4.1
55
5.1
44
Grafo Correspondiente a la
Tabla de Estados Futuros de la Primera
Versión del Algoritmo de Dekker
r,
I
45
A continuación se presenta el código en 'C' de cada uno de los algoritmos sometidos a
depuración cok el depurador de programas concurrentes.
1
#include
#include
#include
#include
#include
#include
5.2 Código del Algoritmo de Dekker Versión 1
< signal.h>
<s y s l 6 s . h >
<sysliy.h >
< syslsh,m.h>
< sysisemh >
< sys/errno.h>
int *vcl,pid,ml;
char car2[40]; I,
iI
#define processnumber (*vel)
i1
main0
{
int a;
l
memoria();
processnumber
- 1;
1-
if ((pid = fork()) = = O)
I
if ((pid = fork()) = = O)
I
I
I
1
I
éxit(0);
memoria()
{
key-t llave;
I
Y
llave = (key-t)IPC
, - PRIVATE;
46
(
int h=O,
CRITICO = O;
1,
'
I
while(h¿ 1ooO)
I/
(
while (processnumber = = 2) (
t+!+;
I
CRITICO++;
proces,inumber = 2;
p20
(
int h=O,
'I
CRITICO = O;
t.
It
whiles < IMM)
(
while (processnumber = = 1) {
ti+;
CRI/ICO++;
processnumber = I;
h+
+;
1
éxit( 18);
1
'I
t
5.3 Código del Algoritmo de Dekker Versión 2
#include
#include
#include
#include
#include
#include
I
<signal.h >
< sys/tyypes.h>
<sys/ipc.h>
< sys/shin.h>
< sys/sem.h>
< sys/eho.h >
l.
int *pl-i, *p2+ .
int pid,ml.m2;
char car2[60];
'1
#define plinside (*pl-i) /* contenido de mem comp * /
#define p2mide (*p2-i)
11
main()
memoria(); I
plinside = O;
p2inside = O;
'1
if ((pid = fork()) = = O)
Ir
!
if ((pid =.fork()) = = O)
'(
P20;
1
1
exit(0);
1
1
i
8;
,
[
memoria()
(
k e y t llave; :
llave = (key-t)lPC-PRIVATE
m l =; shmget(1lave. sizeof(int}. 0660 I IPC CREAT);
if(m1 = = 11) { perror("shmget "); exa(2): )
pl-¡ = (¡ni8.) shmat(ml,(char *)O. O);
if((hi)&plinside == -1) ( perror(" shmgei."); exit(2); )
shmget(1lave. sizeof(int), 0660 I IPCCREAT);
if(m2 == $1) ( perrot("shmget "); exit(2); )
p2-i = (int shmat(m2.(char *)O, O);
if((int) &p2fnside = = -1) ('perror(" shmgei "): exit(2); )
m2
p)
11
48
int h=O, t, CRITICO = O;
while(h< i ~ )
,{
0 .'
while (p2mside) {
t++;
I
plinside = 1;
CRITICO
;
plinside = O;
h++;.\
++
1
exit(0);
I.
I
1
int h=O, 1, CRITICO = O;
while(h < 1ooO)
.(
while (plinside) (
p2inside = 1;
CRITICO+ +;
p2inside ;= O;
hff;'
49
I
5.4 Código del Algoritmo de Dekker Versión 3
#include
#include
#include
#include
#include
#include
<signal.h>
< sys/types.h >
< sys/ipc.h>
<iys/shm.h>
<sys/sem.h>
< syderrn0.h >
1:
,
L
int *pl-w, ,!*p2w;
int pid,inl,;
char car21ffJI;
#define plwantstoenter ( * p i w ) /* contenido de'mem comp *I
#define p2wahoenter (*p2-w)
int pid,ml,,m2;
char car2[$];
main()
{
int a;
!I
memoria():
I
piwanistoenter
= O;
pi-wantsiloenter = O;
.,
if ((pid = fork()) = = O)
I
50
memoria()
{
k e y t llave;
I
li
llave = (key-$)iPCPRIVATE;
'I
mi = shmgetfllave. sizeof(ini). 0660 I IPCCREAT);
if(ml = = -I) { perfor(' shmget "); exit(2); )
p l w = (int t) Shmat(ml,(char *)O, O);
if((int) &plw,mstoenter = = - I ) { perfor(" shmget "); exit(2);
I1
1
m2 = shmge$llave, sizeof(int), 0660 1 IPCCREAT);
if(m2 = = -1) { perror(' shmget "); exit(2); )
p2-w = (int 2) shmat(m2,(char *)O, O);
if((int) &p2Nantstoenter = = -I) { perror(" shmget "): exit(2); )
PI0
{
int h=O, CRITiCO = O;
while(h< IOOO)
III
I
plwantstoenter = I ;
while l(p2wantstoenter);
CRITICO+
plwantstoenter = O;
h++;
+;
P20
{
int h=O, CRITICO = O;
while(h< IOOO)
{
p2wantstoenter = 1;
while'(plwantstoenter);
CRI$ICO+
p~wihtstoenter= O;
h++';
Y
+;
1
exit(0);
!
,
.
,
,8
I
51
' I
,
I
5.5 Código.delAlgoritmo de Dekker Versión 4
!
#include
#include
#include
#include
#include
#inciude
< sign4.h >
< sys/&s.h>
< syslik.h>
<s y s l V . h >
< syslym.h>
< syslerm0.h >
int * p i w , 'p2-w;
ht pid,ml;
char car2[60];
/I
:'
#detime plwantstoenter (+pi-w) I* contenido de mem comp *I
#defme pZwantstoenter (92-w)
int pid,ml,m2;
char carZ1601;
1
main()
{
int a;
I/
I
memoria();
plwantstoenter = O;
p2wantstoenter = O;
I,
if ((pid = fork()) = = O)
(
'I
52
memoria0
I
key-t llave;
I
llave = (keyit)lPC-PRIVATE;
m l = shmgei(llave, sizeof(int), 0660 I IPCCREAT);
$(mi = = -1) { perror(" shmget "); exit(2); )
pl-w = (int *) shmat(ml,(char *)O,O);
iI
if((int) &piwantstoenter
= = - I ) { perror(" shmget "); exit(2); ]
'1
m2 = shmget(llave, sizeof(int), 0660 I IPCCREAT);
if(m2 = = -1) { perror(" shmget "); exit(2); }
p2-w = (inti:) shmat(m2.(char *)o, O);
if((int) &p2wantstoenter = = -1) { perror(" shmget "); exit@); )
I'
1
Pi0
{
int m, i, h=O, CRITICO = O;
while@ < "0)
{
plwantstoenter = I;
while '~p2wantstoenter)
1
{
I1
plwantstoenter = O;
for(i=l; i<200; i + + ) {
m++;
piwdtstoenter = O;
h++i
exit(0);
53
inc m. i, h=O, CRITICO = O;
whilea < IOOO)
I/
{
p2wantAtoenter = I ;
while (plwantstoenter)
{
p~whtstoenter= O;
for(iL1; i<200; i + + ) {
mi+;
1; I
p2whtstoenter = I ;
}
CRITICO+ +;
p2wanIstwnter = O;
h+ +;'!
.:
I
exit(0);
1
54
I
5.6 Código del Algoritmo de Dekker Versión 5
#include
#include
#include
#include
#include
#include
1
< signT1.h >
< sys/types.h >
< sys/ipc.h>
<sys/shm.h>
< sysl7em.h >
< sys/errno.h>
I)
int ' p l w , *p2-w, ' f p ;
¡ni pid,ml:
char car2[60];
1
#define plwantstoenter ( * p l w ) I* contenido de mem comp *I
#define pZwan$toenter (*pZ-w)
#define favoredprocess ( * f p )
int pid,ml .m2,m3;
char car2[60];
1
main()
memoria(); ,
plwantstoenter = O;
p2wantstoenter = O;
favoredprocess = 1;
I1
I1
if ((pid = fork()) = = O)
l
55
memoria()
I
,
,
k e y t llave;
.
,
1
llave = (key-t)IPC-PRIVATE;
m l = shmget(llave, sizeof(int), O660 I IPC-CREAT);
if(m1 = = -1) { perror(" shmget "); exit(2); }
p l w = (int *) shmat(ml,(char *)O, O);
11
if((int) &plwantstoenter = = -1) ( perror(" shmget "): exit(2); }
m2 = shmgei(l/ave, sizeof(int), 0660 I IPCCREAT);
if(m2 = = -l> ( perror(" shmget "); exit(2); }
p 2 w = (int '*) shmat(m2,(char *)O, O);
11
if((int) &p2wantstp1ter = = -1) ( perror("shmget "): exit(2); }
I
m3 = shmget(llave, sizeof(int), 0660 I IPCCREAT);
if(m3 = = -1) { perror(" shmget "): exit(2); }
fj
= (int *) shmat(m3,(char *)O, O);
if((int) &fav{redprocess = = -1) { penor(" shmget "); exit(2); }
I
{
8,
int m, i, h=O, CRITICO = O;
while@ < l@I)
(
plwantstoenter = I ;
whil?/ (pzwantstoenter)
!I
"
1
I
if(favoredprocess = = 2) (
piwantstoenter = O;
&hile(favoredprocess = = 2);
piwantstoenter = I ;
1
1
11
CRI,yICO+ +;
favoredprocess = 2;
plwantstoenter = O;
h++;
exit(0);
1
56
.'
1
p20
(
int m. i, h=O.~CRITICO= O;
while@< 1ooO)
I
p2wantstoenter = I ;
while (pi wantstoenter)
(
)I
if(favoredprocess = = I ) (
p2Wantstoenter = O;
while(favoredprocess = = 1);
p2wantstoenter = I ;
LRITICÓ+ +;
favoredprocess = 1;
p2wanktoenter = o;
h++;’)
1
I
exit(0);
,
lí
57
siguientes:
'
~
/
58
Tabla de Estados Futuros Correspondiente al
Algoritmo de Lectores y Escritores
I
I
ESTADOS TRANSITORIOS
/I
'
ESTADOS INVALIDOS
OOOM
OOLO
OOLM
1KLM
59
1
l
1
Grafo Correspondiente a la Tabla de Estados Futuros
del Algoritmo de Lectores y Escritores
1
#include
#include
#include
#include
#include
#include
5.8 Código del Algoritmo de Lectores y Escritores
I
< signa1.h >
< sys/types.h>
<sys/ipc.h >
< sys/;hm.h >
<syslsem.h>
< sys/ermo.h>
DECLARACIONES P A M SEMAFOROS **%%%**%***********/
/**%%%*%***
I
extern errno;
#define PERM O600
FPermisos para los semaforos *I
ushort semarray[3];
I
I* numero de vmaforos en el conjunto *I
#define NSEY , 3 I* ( sizeof( semarray )/sizeof( ushort )) *I
#define N-OP 1
I* el numero de operaciones *I
1
union semun (
int val;
struct semid-ds *but
ushon *array;
~
1;
union semunJ arg;
int pid,ml .m2,m3,m4,sem;
char car2[60];
I1
61
I****** C R E A ~ I O NY OPERACIONES DE SEMAFOROS *****I
'I
creasem(semkey), ,
key-t
semkeyi '
I* la llave del semaforo * I
( I* crea un conjunto de semaforos ' 1
I* regresa - 1 <n error */
in<semid, status = O;
arg.arrayT&( semarray[O]);
* arg.array
= I;
j
*(arg.array+l) = O;
*(arg.array+Z) = O;
semid 7 semget(semkey, NSEM, PERM 1 IPC-CREAT
if(semid = = -I)
I
if(errno = = EEXIST)
semid = semget(sernkey, NSEM, O);
else perror("semget"1;
I
s t a b = semctl(semid,O,SETALL, arg);
printf("va1or de inicializacion %d\n",status);
stabs = semctl (semid,O,GETVAL, arg);
printf("val0r del semaforo binario = %d\n".status);
s t a i s = semctl (semid,l,GETVAL, arg);
printf("va1or del semaforo general 1 = %d\n",status);
status)= semctl (semid,Z,GETVAL, are);
prlntf("valor del semaforo general 2 = %d\n",staius);
I
I
I
'I
if(status
= = -I ) {
I
,perfor("creasem");
' return -1;
l!
else
feNrn semid;
I
!
Y'
V(semid,n)
int semid,n;
{ I* operacion V */
struct sembuf p-buflN-OP];
int status;
'1
p-buflO].sem-num = n:
p-bufI0].sem-op = I ; . I* la funcion V */
p-buRO].sem-flg = SEM UNDO;
SUNS 4 semctl(semid,n,GETVAL,arg);
*
if(staNdl> O && = = O) reNm O;
retum(semop(semid, p-buf, N-OP) = = -I);
}
II
'
I
62
1 IPC-EXCL);
P(semid,n)
int semid,n;
{ I* operacion * I
stmct sembuf p_buf(
N-OP
~unsigned char i;
I;
p-buflOj.sem-num = n;
p-buf[O].sem-op = -1; I* la funcion P *I
p-buf[O].sem-flg = SEM-UNDO,
return(kmop(semid, p b u f , N-OP) = = -1);
1
I\
..................................................
.iI
main()
{
int a;
1
'
sem = creasem((key-t)getpid());
memoria();
cont-lec = O;
cont-esc = O;
lec-acce = O:
escribiendo O;
4
if ((pid = fork()) = = O)
í
Lector-i();
I
1
I
else {
if ((pid = fork()) = = O)
{
Escr iro@
!r ;
I
I
1
Y
exit(0);
1
memoria()
{
k e y t llave;
,I
.
llave = (key,t)lPC -PRIVATE;
m l = shmget(llave, sizeof(int). 0660 1 IPC CREAT);
if(ml = = -1) ( perror(" shmget "); exit@);}
shmat(ml,(char *)O, O);
c lec = (di*)
if((int) &co+-lec = = -1) { perror(" shmget "); exit(2); }
63
!I
1 . .
m2 = shmget(llave, sizeof(int), o660 1 IPCCREAT);
if(m2 = = -1) { perror(" shmget "); exit(2); }
c esc = (int *) Shmai(m2,(char *)O, O);
if((int) &conte$c == - I ) { perror(" shmget "); exit(2); )
~
m3 = shmget(llave, sizeof(in0, O660 1 IPCCREAT);
if(m3 = = - 1 ) ,{ perror(" shmget "); exit(2); }
I
1 a = (int *) shmat(m3.(char *)O. O);
'I
if((int) &lecacce := = -1) { perror(" shmget "); exit(2); ]
m4 = shmget(llave, sizeof(int), O660 1 IPCCREAT);
if(m4 = = -1) perror(" shmget "); exit(2); }
esc = (int *) shmat(d,(char +)O, O);
if((int) &escri$endo = = -1) { perro[(' shmget "); exit(2); }
ll{
1
if(escribiend0. I I contesc ! = O)
{
cont-lec =,cont-lec
I;
V(sem, MVTEX);
P(sem, LEC);
cot-lec =,cont-lec - 1;
1
I
+
'I
+ 1;
lec-acce = lec-acce
if(co-lec != O) {
V(sem, LT);
1
else {
V(sem, MUTEX);
/* LECTURF *I
P(sem, MUTEX);
lec-acce = lec acce - 1;
I1 if(iec-acce =
= O && con1-esc != O)
64
EscritorJ)
{
P(sem, MUTEX);
if(1ec-acce ! = O I ;I escribiendo)
{
iI
coni esc = coni-esc
1;
V(sein, MUTEX);
P(sem, ESC);
cont-esc = coni esc - 1;
}
escribiendo = 1;
V(sem, MUTEX);
Ii
+
~
y -
!I
I' E S C R I T U q ' I
P(sem, MUTEX);
escribiendo = b;
if(coni-iec ! =
{
V(sem, LEG);
lo)
'i
élse {
if(con-esc !,= O)
65
1) 5.9 Código del Algoritmo de Productor - Consumidor
#include
#include
#include
#include
#include
#include
/******Sf**
11
.
<signaJ.h>
< sys/types.h >
< sysíipc.h >
< sys/shm.h >
< sys/&m.h >
< sys/errno.h>
li
DECLARACIONES PARA SEMAFOROS ....................
extern errno;
#define PERM![ 0600
I* Permisos para los semaforos *I
ushon semarray[3];
I1
I* numero de semaforos en el conjunto *I
#define NSEM '3 I* ( sizeof( semarray )/sizeof( ushort )) */
#define N-Or ' 1
I* el numero de operaciones *I
'I
union semun {
'
inf val;
struct semidlds *but
ushori *array;
1;
(I
union semun ,Iarg;
.............................................................
I
int pid,ml ,sem,*vcl ;
char car2[60];.
Y
#define unidades ('vcl) /* contenido de mem comp *I
#define MAX !lo,
#define BUFF, O
#define PROD 1
#define CONS 2
I1
66
I
I****** CREACION Y OPERACIONES
!I
DE SEMAFOROS *****/
creasem(semkey),l
/* la llave del semaforo *I
key-t
semkey;: i
{ /* crea un conjbto de semaforos *I
/* regresa -1 en error *I
int semii, Status = O;
1
arg.array=&( semarray[~l);
* arg.a+ay = 1;
*(arg.array+mi) = o;
*(arg.array+2) = O;
i/
semid 7 semget(semkey, NSEM, PERM I IPCCREAT
if(semid = = -1)
'1 if(ermo = = EEXIST)
semid = semget(semkey, NSEM, O);
, else perror("semget");
else { , "
~
status = semctl(semid,O.SETALL, arg);
printf("valor de inicializacion %d\n",stanis);
stads = semctl (semid,O,GETVAL, arg);
prin{f("valor del semaforo binario = %d\n",status);
staNs = semctl (semid, I ,GETVAL, arg);
printf("va1or del semaforo general 1 = %d\n",status);
status 2 semctl (semid,2,GETVAL. arg);
prinif("va1or del semaforo general 2 = %d\n",status);
1
,'
1
'
,i
else
,
1
return -1;
.i
f
returnsemid;
!I
V(semid,n) ' I
int semid,n; i , , .
( /* operacion V */
struct sembuf p-buf[NOP];
int status?
!I
p-bufl0].sem-num = n;
p-buftO].sem-op = 1; I* la funcion V *I
p-buffO].sem-flg = SEM-UNDO;
status = kemctl(semid,n,GETVAL,arg);
if(status 3 O) return O;
I
return(semop(semid,
p-buf, N-OP) = = -1);
,
61
1 IPCEXCL);
P(semid.n) ' ,
int semid,n: . .,
{ I* operacion:P *I
I/
. stnxt sembuf p-bufl N-OP I;
unsigned dhar i;
'
il
p-bufl~].semnurn = n;
p_buflO].sem-op = -1; I* la funcion P "I
p-buflO].sem-flg = SEM-UNDO;
1
retum(semop(semid, p-buf, N O P ) == -1);
?
1
..................................................
'1
main()
1
l
int a;
sem = creasem((key-t)getpid());
memoria();
unidades = O;
1
if ((pid = fork()) = = O)
Jl
{
,I
Productor();
Consumidor();
!I
1
exit(0);
{
li ,
key-t llave;
llave = (key-t)IPC-PRIVATE;
I!
ml = shmget(llave, sizeof(int), O660 I IPCCREAT);
if(m1 = = $1) { penor(" shmget "); exit(2); }
vcl = (int *) shmat(ml,(char *)O, O);
I/
if((int) &unidades = = -I) { penor$"shmget "); exit(2); }
1
I1
68
I
Productor()
I
int espacio;
1
do {
I** PRODUCE UNIDAD DE INFORMAClON **I
P(sem, BUFF);
I** DEPOSITA UNIDAD **I
.. .
unidades =,unidades + I;
espacio = MAX - unidades;
if(unidades.j= = 1) {
V(sem. CONS):
'I,
1.
.
'..
v(s~rn,B U ~ F ) ; :
}while(espacio,.!= O);
Pfsem:'PROD):
exit(0);
I
Consumidor0
{
l.
int que-consumir;
.
.
I
P(sem, CONS);
do {
I/
P(sem, BUVF);
I** TOMA UNIDAD DE INFORMAClON **I
unidades = unidades + 1 ;
queconsumir = unidades;
if(unidadei = = MAX - I )
{
W e m , PROD):
I
I1
V(sem, BUFF);
)whiIe(que-consumir ! = O);
exit(0);
}
!I
69
CAPITULO 6
CONCLUSIONES
I1
1
6.1 Conclusiones
,
En la actualidad los programas multiproceso, ya sean de ejecución concurrente, paralela O
ii
distribuida h i dejado de ser una mera novedad y curiosidad en el ambiente computacional. Se
ha demostrado, a través de muchas aplicaciones que han sido desarrolladas separando, cuando es
posible, cada"tarea en procesos independientes para funcionar dentro de ambientes que soportan
1 .
el multiprocesamiento y/o multiprogramación, que dichos programas se ejecutan de forma
mucho'mas ehciente que los programas de procesamiento secuencial, reduciendo su tiempo de
respuesta y aerovechando mucho mejor el o los.procesadores.
I!
Los depuradores que soportan el multiproceso, como herramientas Útiles en la depuración
de programas concurrentes, representan un desarrollo relativamente nuevo dentro del ámbito de
las ciencias tomputacionales. Actualmente empresas importantes como IBM y SUN CUYOS
sistemas operativos y ambientes de desarrollo hacen uso de el multiprocesamiento están
desarrollando herramientas que auxilian al programador de aplicaciones en el trabajo de análisis
4
de programas concurrentes o paralelos; existen también desarrollos orientados hacia la
1
depuración de programas distribuidos.
i
De todo lo anterior se deduce que la investigación orientada al desarrollo de herramientas
que auxilien: en la programación multiproceso, es un tema de actualidad, cuyos resultados
representan adelantos tecnológicos que pueden ser aplicados en la educación, como herramientas
que auxilieil en la comprensión de la programación multiproceso,' así como al análisis de
It
programas concurrentes de aplicación comercial.
.!
El desarrollo
del depurador de programas concurrentes que es tema de esta tesis nos ha
I
permitido demostrar los siguientes puntos:
li
- Qui es factible la depuración de programas coiicurrentes mediante la inserción de
código de control en el programa a depurar después de analizar su código fuente.
- Qu?I/ la lógica del programa concurrente a depurar no se ve afectada por la acción
del código de control insertado en su código fuente.
- Que'1 el uso de semáforos y memoria compartida como instrumentos de control y
sincronización de los procesos depurados brinda resultados positivos.
- QUA'I la depuración de procesos a niveles de profundidad superiores a uno es posible
usando los mecanismos anteriores como parte del código de control insertado en el
código fuente del programa a depurar.
I
t
70
6.2 Trabajos Futuros
I1
El desarrollo de este depurador marca una línea de investigación que de seguirse, dará
I/
como resultado la generación de herramientas de apoyo a programadores que además de
representar uh adelanto tecnológico serán productos comercializables.
I1
El depurador de programas concurrentes desarrollado solo incluye las características
11
básicas reconocidas en las herramientas de su tipo, pudiendo llevarse a cabo mejoras en un futuro
cercano. Algunos de los trabajos propuestos para complementar y mejorar lo que se ha
desarrollado'hastaahora son los siguientes:
1
- Incluir las consultas sobre el contenido de estructuras de datos complejas y tipos de
datos definidos por el usuario.
v
- Incluir la posibilidad de depurar el código de las librerías o archivos de cabecera
dehnidos por el usuario.
1
- Incluir la posibilidad de soportar el control de los mecanismos de paso de mensajes
11
y comunicación
de procesos en red que proporciona el sistema operativo UNIX.
I
- Incluir la posibilidad de depurar programas multiproceso de ejecución distribuida.
- Inlluir
la opción de dejar que el programa concurrente a depurar se ejecute sin el
1
control del depurador pero generando un diagrama del flujo o una tabla de estados
que sea una representación gráfica de la ejecución del programa
- I n Ih i r la generación de una ventana para cada proceso y un esquema de depuración
que permita que cuando un proceso avance una instrucción, los demás procesos
realicen o intenten realizar la misma operación , o sea, la simulación del planificador de
procesos (shedder ).
I
- Diseñar e implementar un esquema de depuración que utilice información y10 tenga
la posibilidad de interactuar directamente con el núcleo del sistema operativo (kernel).
1,
11
- Incluir
la ejecución en reversa (back-tracking) en cada proceso, restaurando el valor
dellas variables.
- incluir la posibilidad de depurar hilos (threads).
I).
I
71
ANEXO "A"
ESTRUCTURAS DE DATOS USADAS EN LA IMPLEMENTACI~N
DEL DEPURADOR
I/
char *RESERVADASO = (
"auto", : "double", "int",
"struct",
"long",
"switch",
~
~ "~
~ I ~m
~ "register",
: ' ,~
~"typedef",
'
"extern", "return", "union",
"const', !. ",float", "short", "unsigned",
'"continue:". '"for".
"signed", "void",
"sizeof", "volatile",
"default"! "goto",
"if",
"static", , "while",
"do",
"-ss",
"near", " e s " ,
"near",
"stnict",
export", "new",
" cdecl",
-far", %rm, "union", "register",
"NULL".j, "include", "define", "main", "ushort",
"fprintf". "pemr", "FILE", ,"key-t", "sembuf"
1
4
-
~
1;
!
II
char TIPOS.-SIMPLES[l = {
"char", 7 "int", "float", "double",
"enum", "FILE", "key-I","Sfruct", "union", "ushort"
};
11
char *MODfFICADORES[] = {
"long",
"short", "signed".
"unsign&d$,"sembuf"
~
char *FUNCIONES-UNIX[J = {
"fork",' "shmctl", "shmat", "shmget", "exit", "getpid", "wait", "semctl", "semop"
iypedef struct {
int PIDgioc creado;
int PIDgadrigroc,
11
int PIDqfoc;
int traza; I
int valwait;
char meniwait[20];
char men6aje[80];
1 envio; '1
envio *ordenes-usuario;
12
1
union mem(
int xi;
short xh;
longxl;
'
11
unsigned xu;:
shon int xhi;
long jnt xli;
unsigned intixuf;
unsigned short int xubi;
unsigned long in1 xuli;
float y;
char byte131;
't
1;
typedef struct (
int palabra! ;
int palabra2
JMEM-DOBLE;
I!
union doble{l
MEM-DOBLE zona;
'
doubley;
long double z;
'
1;
I***
I***
I***
*****I
,Ir
DEFINICIONDE ESTRUCTURAS QUE CONTENDRAN LA INFORMACION DE
*****I
VARIABLES GLOBALES, VARIABLES LOCALES Y FUNCIONES DEL PROGRAMA ****I
A DEPURAR
1
iI
smct LISTA-CONDICIONADOS
(
int PID;
lint lineabreakpint;
char condicion[256];
struct LISTA-CONDICIONADOS *si&
)l;fta-condicionados;
struct LISTA-PROCESOS
,
{- I'I .
int PID, PIDqadre;
unsigned char eliminado,reprtado;
ini valexit;
struct LISTA-PROCESOS *sig;
)listagrocesos;
I
73
struct LISTA-VAR-GLOBALES
'
'1
char modificador 1[10];
c l h modificador[lO];
cdL tipo[i01;
c& nombre[20];
chkr 1imitei[i01;
c&r 1imite2[101;
'I
int esquntero;
in{ direccion;
int visible;
stAct LISTA-VAR-G~OBALES *síg;
}list~~vvglobales;
S t m
LISTA~VAR-COMPARTIDAS
I
l
.
c d u modificadorl[lO];
c&r modificador[101;
c&r tipo[i01;
c d k nombre[20];
c h b limitel[lO];
cdkr limite21101;
'
int espuntero;
in$ direccion;
:in4 visible;
sthct LISTA-VAR-COMPARTIDAS *sig;
Jlista~vcompartidas;
chnar tipo[lO];
char nombre[20];
chkr limitei[i~];
c&r 1imite2[10];
in; direccion:
./
in? activa;
in! visible;
in!, espuntero;
int, esqarametro;
.chL túncion[201;
st&t LISTA-VAR. .oc
}~ista!!v~oca~es;
StmCt
ES *sig;
LISTA-~ U T I N A S
1
'
char nombre[20] ;
,char tipo[lO];
,strnct LISTA-RUTINAS *si&
14
1
struct LINEAS
{
int num-linea;
int pos-car-¡ni;
stdct LINEAS 'sig;
1
}lisia-lineas;
1
union tipos{
int xi;
l
shonxh;
'
long xl;
unsigned xu;
shon int xhi;
long int xli; ': ,
unsigned int xui;
unsigned shoh int xuhi;
unsigned loni in1 xuli;
I
float y;
double y2;
long double z;
char car;
char cadena[256];
1
'
1
1;
,
,
I¡
struct define-operandos {
char tipo[20]:
union tipos dato;
struct stack-operadores {
in1 top;
,I
char operador[801[31;
1;
'I
{
int top; I/
struct define-operandos operando[80];
S ~ N Cstack-bperandos
~
1;
!I
7s
BIBLIOGRAFIA
p/Is -s , Levi [y] Radin, Joseph “Aplique X WINDOW..
[LEV931
Qbome-Mc Graw Hill, 1993.
[COF92]
Coffin, Stephen, “UNIX Sistema V versión 5 Manual de Referencia”.
Mc Graw Hill, 1992.
[MAR931
?4arquez García, Fco Manuel, “UNIX. Programación avanzada”.
Addison-Wesley iberoamericana [y] ra-ma, 1993.
[SWA90]
Swan, Tom, “Mastering Turbo Debugger”, Hyden Books, 1990.
[DEI931
Deitel,
H.M., “Sistemas Operativos”, Segunda edición,
I
Addison-Wesley iberoamericana, 1993.
[TOR941
Torres Jiménez, Jose, “Apuntes de Sistemas Operativos”, 1994.
[STE92]
Stevens, W. Richard, “Advanced Programming in the UNIX Environment”.
Addison-Wesley publishing Company, h c .
[BER93]
Bergmark, Donna, “Update on Tools for Parallel Programming at the
CNSF”, Technical Report, Cornell University, Marzo, 1993.
1
i
II
¡I
I
16