i I

8) 'SEP DGIT SElT

11 CENTRO NACIONAL DE INVESTIGACION Y DESARROLLO TECNOLOGICO

I1 <' DEPURADOR DE PROGRAMAS CONCURRENTFS BAJO UNIX .' 11

11

I1

CENTRO DE INFORMACION

I I , T E S 1 S CEN IDET

II P A R A O B T E N E R E L G R A D O D E : M A E S T R O E N C I E N C I A S

)I D E L A C O M P U T A C I O N I! R E S E N T ' A t

1 /I O U E C O M O R E O U I C I T O 0 'i

11 1.1. JAVIER SALVADOR SOBERANIS FERNANDEZ I

I!

:CUERNAVACA, MOR. FEBRERO DE.1996

I

I1 I

I1 //

SISITEMA NACIONAL DE INSTITUTOS TECNOLOGICOS Centro Nacional h de Investigación y Desarrollo Tecnológico

/I

I1 DE LA COMI'UTACION

I

X A D E M I A DE LA MAESTRIA EN CIENCIAS I/

I1

II Cuernavaca Mor., a 27 de marzo de 1996

Dr. Juan Manuel Ricaño Castillo Director del CENIDET P r e s e n t e 1

I/

II

1/ I1 ,. !I

At'n: Dr. José Ruiz Ascencio. Jefe del Dpto. de Computación

!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 revisión :ic;idCiiiic:i cl Lrabiijo de tesis tituliido:

"Depurador de prograiiias . . cóiicurrentes'bajo el sisteiiia operativo

11

i/ ':

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. por lo que aprobamos que el trabajo sea presentado cn exaillcn oral.

1

/I I i 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 I) Of. No CCS-O67/96

I1 It

Cuernavaca Mor.. a 29 de ii~urzo de 19% 1

.I

L.I. Javier.Salvabor Soberanis Fernáiidez Candidato al gradole Maestro en Ciencias de la/ Computación P R E S E ’ N T E

/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<. C.C.P. C.P. Ing. David Chávez A. Dpto. de Servicios Escolares

Subdircccióii Acadhica

I( 11

Interior Internado I’ihiiirii S/N C.P. 62490 Auurtudo l’ostiil 5-164. C.P. 62ü5ü. Cueriiiiviicu Mor., Mfvico cenikfetl . . ~~~ ~~~

~~

Tcls. (73) 18-77-41 y 12-76-13, Fax. 12-24-34 I(

It

¡I I/

I/

, 'I

// I/

I/ I1

Con todo cariño y respeto a mis padres, que son mi principal motivo de superación.

I/ 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

I/

I1

I . Al Centro Nacional de Investigación y Desarrollo Tecnológico (CENIDET) I por las facilidades brindadas.

// A mi directbr de tesis M.C. y M.A. José Torres Jiménez, por SU apoyo y orientación para llevar a buen término ésta tesis.

Al profesor d.C. Luis García Gutiérrez por el apoyo brindado durante la maestría.

A mis maestros por su orientación y por brindarme sus conocimientos.

A mis compañeros de generación Anastacio Antolino H., Miguel A. Ortíz M., 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.

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.

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

A la Estaciónii de trabajo Sun Sparc20 alias “cadll” por su excelente desempeño durante el desarrollo de la tesis.

II

I1

,I I/ I/ I/ ‘1

I/

/I I

Ii

I

I/

II

CAPITULO 1 INTRODUCCI~N

I/ i ' 8)

1.1 Antecedentes Generales ............. .. ... ..... ...... ... .. .. .. ... .. ......... ......... .......... .. , ............ .....

1 . I .2 X\Window, GUl's y Estaciones De Trabajo .............................................. 1.1.3 Xt Inmnsic ........... ................... .. .. .. ... .. .. .. ..... .................. ........... ............ .. .. . 1.1.4 Herramientas en Propiedad ........ .. .. ... .... ..... .. .... ..... .............. ........ ..... .. .. , .. .; 1 . I .5 OSFIMotif ...................................................................................................

1.2 Depuradores (Debuggers) ........................................................................................ 1.2.1 Depurador adb ... .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.2 Depurador dbx ...... . . . . . . . . . . . . . . i.. . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.3 Depurador dbxtool ................................ ;.; ................................... : ............... 1.2.4 Tuibo Debugger .........................................................................................

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.3 Depurador udb .......................................................................... ..

1'!3.'1.4 Depurador pdd ........ .................................................. ........ ........

t 1.1.1 Unix ............ : .............................................................................................

. . I

" , I . /I

~. ~ I '

'I. I '1

i/

11

'It '

,, ./

< ,

1.3.i.5 I/ Totalview Debugger ....................................................................

'1

'I . . 1.4 Alcance y Restricciones ... . . , . . . . . . . . . . . ;. . . . . . . . . . . . . . . . . . . . . . .. .... .... ..... .;.. . . . . . .... ......S. ... .. ..... .. . 1.5 Beneficios ..I!..! ..................................................................... ....................................

CAPITULO 2 MARCO TEÓRICO

11 2.1 Procesos ......... ........................................................................................ .. .......... .....

2.1.1 Estad& 4 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.3 Proieso ........................................................................................

2.2 Procesos co&Urrentes ............................... .......................................................... .... 2.2.1 Problema de la 'Actualizaci6n Perdida' ...................................................... 2.2.2 Exclu&h Mutua . , . . . . . , . . . . . . . ... . . , . . . . . , . . . . . . . . , . . . . . . . . . . . . .. .. . . . . . ..... .......... .. .... . ..... ..... 2.2.3 Semaforos .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . , . . . . . . . .. . ..... . . .. ........... . ... ..... .. ... ..... ... .I/,

I!

I ij

I/ I!

I

1 1 2 3 3 3 4 4 4 4 5 5 5 5 6 6 1 1 8 9

10 10 11 12 14 14 15 15 16 16 17 17 18

... . _I

---.-- __- - -

i I!

I/

II II

CAPITULO 3 i ANALISIS DEL PROBLEMA

I1 . ., 3.1 Descripcion del Problema ........................................................................................ 20

21 22

I . 3.2 Soluciones,Posibles .................................................... ~ ............................................. 3.3 Metodología de Solución ........................................................................... ; .............

i/

I1

I/ ' IMPLEMENTACION DEL DEPURADOR

4.1 Diseño Conceptual del Depurador ........................................................................... 4.1.1 Sincronización y Control de los Procesos Depurados ................................

4;2 Elementos y Fiuncionamiento del Depurador .......................................................... ,,

4.2~1.1 La Interfaz del Depurador ............................... :

CAPITULO 4 /I

/I

i 23 23 26 28 28 29

\ 4.2.1.1.2 La Ventana de Edición y Seguimiento ......................... 29 30

11 4.2.1 . I .4 La Línea de Ordenes .: .................................................. 30 30

442.1.2 E] Modulo Precompilador ........................................................... 31

34 36 41

I/

4.2.1 Elementos del Depurador .......................................................................... ...........................

4.2.1 . I .I El Menú de Ia'InterfG ................................................

4.2.1.1.3 Ventana de Identificadores'De Procesos ......................

4.2.1.1.5 Ventana para Resultados de Consultas ..........................

4.2.1.3 'I El Preprocesador de Comandos .................................................. 33 4.2.1.4 El Analiiador de .Expresiones Lógicas ...... ; ........... ..................... .I

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/

., . . . ,

i i CAPITULO 5

u PRUEBAS REALIZADAS //

5.1 Ejemplo.- Análisis de la Primera Versión del Algoritmo de Dekker .......................... 43 46 5.2 Código de IaiPrimera Versión del Algoritmo de Dekker ............................................ 48 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 ........................................... 50 5.5 Código de la C%arta Versión del Algoritmo de Dekker ............................................. 52

5.8 Código del Algoritmo de Lectores y Escritores ............. ; .......................................... 61 5.9 Código del Algoritmo de Productor-Consumidor ...................................................... 66

'1 55 58

5.6 Código de 1a.Quinta Versión del Algoritmo de Dekker ........................ ; .................... 5.7 Ejemplo.- A ~ d s i s del Algoritmo de Lectores y Escritores ........................................

" 51

' . I/ '

!I

I/

11 CAPITULO 6

I/

I1

11 CONCLUSIONES

'I 6.1 Conclusiones ............. : .............................................................................................. 70

71 51

6.2 Trabajos Futuros ............................. ..................................... ; ......................... i ........ /I

4 i

ANEXO "A".; Estructuras de Datos usadas en la Implementación del Depurador. 72

Bibliografía .? ................................. i ................................................................... ; ........... 76 !!

I/

I/

I/

li

, /I

1)

I/

Ill

I/ Ii ÍNDICE DE FIGURAS 'I

Fig. 1.- Sistema Operativo Gráfico en una Estación de Trabajo ..................................... 2 Fig. 2.- Muestra de Widgets del OSFí Motif ....... ~ ............................ ~ ................................ 3 Fig. 3.- Estados de un Proceso en El Sistema Operativo Unix 11 Fig. 4.- Ejemplo de Creación de Procesos en Unix Usando Fork() ................................ 13 Fig. 5.- Representación Gráfica de una Operación P Sobre un Semáforo Binario .......... 18 Fig. 6.- Representación Gráiica de una Operación V Sobre un Semáforo Binario .......... 18 Fig. 7.- Depyción Concurrente Actual ........................................................................ 20 Fig. 8.- Disefib Conceptual del Depurador ..................................................................... 23

' t

,b

'I ' .......................................

'I

Fig. Sa.- Representación Gráfica del Ciclo de Control de los Procesos en Ejecución ..... 26 Fig. 9.- Funcionamiento General del Depurador de Programd Concurrentes ................. 27 Fig. 10.- Elementos del Depurador de Programas Concurrentes ...................................... 28 Fig. 11.- Interfaz Gráfica del Depurador de Programas Concurrentes ............................. 29 Fig. 12.- Formato de Los Botones Identificadores de Proceso ........................................ 30

Procesos ............................................................................................................. 33

,I

'1

Fig. 13.- Interahón del Preprocesador de Comandos con la Interfaz y los

Fig. 14.- Inter&ción del Analizador y Evaluador de Expresiones Booleanas con el

i f l

I :,

I!

- Preprocesador de Comandos y la Interfaz ........................................................

Fig. 16.- V e n d a I! de Selección de Archivos .................................................................... Fig. 15.- Opciones del Menú Archivo ..... ;.. ....................................................................

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

Fig. 23.- Grafo Correspondiente a La Tabla de Estados del Algoritmo de Lectores y . I/ Escritores.. ...................................................................................................... /I

I1

' .

.........

Algoritmo de Dekker .......................................................................................

.!

!I Ii .,

/I

34 37 38 39 39 40 40

41

45

60

li

/I !I ÍNDICE DE TABLAS

I1 Tabla 1 .- Tabla de Estados Futuros de la Priniera Versión del Algoritmo de Dekker ....... 44 Tabla 2.- Tabla be Estados Futuros del Algoritmo de Lectores y Escritores .................... 59

I/

IV '!

1

I/

1 I1

CAPITULO I 11

I1 INTRODUCCI~N 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 10 que es 10 mism0, 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, etc. Un depuradories, por lo tanto, una herramienta muy Útil para el programador durante la fase de puesta a punto de un programa.

1.1 Antecedentes Generales

1

It

I I/

1.1.1 Uaix 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

//

I/ 1 11

)I I

i

_I_ -_ -~ I_

----- _____ I1

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 .

aplicaciones y extenderlo resulta fácil.

I/

- Fkddidad. El sistema UNIX ha sido utilizado en una gran vanedad de

1 - Potencia ,Es un sistema sumamente robusto, ya que incorpora un extenso conjunto de funciones y herramientas que no contemplan otros sistemas.

11 I - Mulfiusuarioy muififarea. El sistema UNIX es un entorno multitarea de tiempo

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/

- Urienfacibn a 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 10s dtimos 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

brevemente como programa que se ejecuta en modo g ráko 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.

independientes del I dispositivo. Una interfaz gráfica de usuario (Fig. 1) se Puede definir

I

I1 1I

li

imagen, el Sistema operativo S U N Solaris)

2

--.--- -._ _ _ ~- _- -. .. -_ . _-_ -

.i "- /I

1.1.3 Xt Intrinsic.,; dl

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

1.1.4 Herramientas en Propiedad.

.I

11

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

4 . " .

// 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ódigo 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.

11

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 características de manejo de símbolos del udb no podrán ser utilizadas. El archivo a depurar por defecto es el u.ou/."

11

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 mismos comandos que dbxtool, pero utiliza una interface estándar por terminal.

4.

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/ . - No es posible deshacer el efecto de las siguientes instrucciones-maquina: in, out, insb. 11

I1 insw, outsb y outsw.

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

1.3 ¿Por qué un Depurador Concurrente? /j

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 necesarias para llevar a cabo una depuración eficiente de los procesos concurrentes generados por el programa sujeto a depuración.

1.3.1 Estado del Arte en Depuradores Concurrentes

11

8 1

I ‘ I

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

1)

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 Virfuul Machine, 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 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.

1)

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/

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

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 C I 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 tienen disponibles versiones del Totalview que soportan diferentes plataformas hardware.

I

ll 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 flexibles que soportan el multiprocesamiento. Este depurador tiene muchas ventajas sobre los depuradores convencionales del LJNIX tales como dbx y adb.

4 iI

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 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 l iga el depurador a procesos creados por otro proceso en ejecución.

I

11

I

Actualmente están disponibles versiones del Totalview que soportan las siguientes

plataformas: 1 I I

- Sun 4 con SunOS o sistema operativo Solaris. - DEC AlphL con el sistema operativo OSFA.

I

/I

4

11. El TotalVjew ha sido transportado a las siguientes plataformas hardware o arq uitcctiiras de microprocesador:

4 'I - Familias ;68k y 88k de Motorola, - Sun SPARC. -Digital dpha .

- Intel 960.11 -Gray YMP. ~

- AT&T DSP 32c.

, 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

h step).

- Correr los procesos depurados hasta un punto de parada (breakpoint).

- Incluir puntos de parada condicionales.

- Detener la ejecución del programa.

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

ii 1

I i

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

'1 concurrente.

i

8

! - El dePbdor P d r h ser aplicado a programas que no presenten errores en la compilación.

II

I1 1.5 Beneficios '! ' 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 usuarios 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 hace posible la depuración de todos los procesos que genere dinámicamente un programa, con el consiguiente ahorro de tiempo y esfuerzo.

1

'I 1 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

1 I!

e 9

! i

- --- - ---- -- -- - --------. -- - .-

1 !I

I .:

CAPITULO 2 MARCO TEÓRICO

2.1 Procesos ¡I "Algunas I definiciones 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. - LO que se manifiesta por la existencia de un 'bloque de control de proceso' (PCB) en

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

11 el sistema operativo.

. //

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 que además el keTnel (núcleo del sistema operativo) le añade información adicional para poder manejarlo.

t

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 4 la ocurrencia de varios eventos. Dichos estados son los siguientes:

11 CORRIENDO o EJECUTÁNDOSE. Se dice que un proceso está en este estado cuando

tiene asignada la UCP. En sistemas ,monoprocesadores solo puede existir un proceso ejecutándose a la vez.

II

' 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

.t

10

- -- ------.- -- - ~-

Y BLOQUEADO. Un proceso entra en eslado bloqueado cuando está esperando un evento

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 'lista de bloqueados'; dicha lista no está ordenada por prioridad ya que los procesos se desbloqucan culndo ocurrc cI evento que están esperando y esto no succde siempre en orden. Algunas veces conviene asignar prioridades a los procesos bloqueados, ya que puede haber varios procesos esperando por un mismo evento. Puede darse el caso que existan varias listas de procesos bloqueados, de acuerdo al evento que esperan.

I1

i

j .,

'L I/

11

: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 de conirol de projeeso (process control block, PCB) o un descriplor de proceso. El PCB es una estructura de datos que contiene información importante acerca de un proceso, incluyendo:

I I/

I

// - el estado actual del proceso. - un identificador único del proceso.

- apuntad?reS a 10s hilos del Proceso (es decir, a los procesos creados por él), - la pnoridad del proceso. - apuntadores hacia las zonas de memoria 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

11

un apuiftador hacia el padre del proceso (es decir, hacia el proceso que lo creó)

i i

(en un sistema de procesadores múltiples).

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

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

I 1 . . CREAR. Las actividades llevadas a cabo cuando un proceso es creado son las siguientes:

- 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 creado es el proceso hijo." [MAR931

i

I 4 ,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).

12

I

-------- ----- - il I.

--I

--------- - I(

1) DESTRUIR:. AI destruir un proceso se llevan a cabo las siguientes actividades:

- Quitar los!recursos al proceso. - Eliminarlq d;e la lista de procesos.

.- Borrar el PCB del proceso.

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 Y : ~

,I! . .

., I

!I En el caso be üNIX existen dos llamadas al sistema asociadas con la 'terminación de

I/ procesos, estas son:!

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!

wdro . Suspende la ejecución del proceso que la invoca hasta que alguno de sus procesos 'I/

/i hijos termine.

ii 13

/I si el proceso 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

en qué condiciones terminó su proceso hijo. significativos del 4 estado del proceso (status). Con esta información, el proceso padre puede saber

JI

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 11

SUSPENDER. Un proceso está suspendido cuando se le han quitado temporalmente los recursos asignados a él.

,I

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

I

I

modificado.

BLOQUEO. El bloqueo de un proceso involucra las siguientes actividades:

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

DESBLOQUEO. AI desbloquear un proceso cuando ocurre el evento esperado se elimina

1 I t

de la lista de bloqueados y se inserta en la lista de procesos listos I/

d DESPACHO. Se dice que un proceso es despachado cuando se le asigna el procesador.

11 2.1.4 Diferencias entre Proceso, Rutina y Corrutina 1

2.1.4.1 Rutina '¡I

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

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].' Es conveniente mencionar que por hardware se guardan ciertos registros; y en lenguajes de alto;n?vel, es decir por software, pueden guardarse otros registros.

I

14

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

I

Algo importante sobre las comtina es que el control sobre qu6 corrutina se ejecuta está codificado dentre de las propias corrutinas, lo que permite que sea en ellas donde se decide cual será la siguiente komitina en ejecutarse.

' t

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.

ii 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 asignación del [TOR94]. Este algoritmo es ejecutado por el sistema operativo.

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 kea de # / I memoria Para Poder correr y periódicamente se le asignan otros dispositivos.

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.

I

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 11

El uso más sobresaliente del concepto de HILO es que se pueden tener múltiples HILOS 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

la compartición de datos entre los HILOS, mientras que en un esquema con múltiples procesos, 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].

I '1

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 de asignación del procesador, que hace que el procesador conmute entre diferentes procesos

t

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 R ~ N S A C C I ~ N I A; TRANSACCI~N B;

PAREND: !I

TRA NSA CCION'~ TRA NSA CCIÓN B I

TI, SALDOh := SALDOX ~ I! T2, SALDOB:= SALDOX

:= SALDOA-1000; T4, SALDOX := SALDOB-1000.

FIN DE TRA NSACCI~N B !

FIN DE TRANSACCI~N A

si TI < T2 $ 773 < 7-4 y SALDOX = 2000 en T I ; en T4 SALDOX debería ser Cero, Pero a io es

m n a de memoria comunes a mas de un proceso.

2.2.2 Exclusión Mutua

D~ este Problema se deduce que se debe imphentar un control sobre

Y 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 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, 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

I/

/ I '

17

2.2.3 Semáforos /I LOS semá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 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.o inicializarlo. 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

I1

operación V sobre I el mismo.

Las operaciones P y V deben ser atómicas para que funcionen correctamente. Esto es, una 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

It

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>lementar la exclusión mutua sobie semáforo binario que habilita el acceso a una zona de una zona de memoria compartida

jl memoria compartida,

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

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

. .. q

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 puede tomar dos valores se dice que es binario, y son precisamente este tipo de semáforos los usados para implementar la exclusión mutua.

11 .i

:\

I

19

I

CAPITULO 3 i ANALISIS DEL PROBLEMA

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 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 (ver figura 7). Como ejemplo. en el sistema operativo AIX (versión IBM del

I

I

el depurador con el que se cuenta solo puede seguir el hilo de ejecución de los procesos que se van generando dinámicamente. del proceso

DEPURACION CONCURRENTE ACTUAL ;I i j

PROCESO DEPURADO. :i

,

i el proceso depurado lanza otros procebos, estos uedan fuera del alcance del depurador.

En el estado actual de la depuración concurrente

1

~

" 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 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 hijo genera otro proceso, no hay forma de saber como se comportará el nuevo proceso.

I!

'1

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 entre dos o más procesos y no se implementa un control efectivo sobre el acceso a ellas, para 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.

1 1)

! '! 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,

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.

I1 otra ventana contiene un botón por cada proceso generado dinámicamente. I /I

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 vi6 en el capitulo sección 2.1.4.2).

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 'I - Exclusión 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.

3.3 Metodología de Solución

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:

Ir '11

1 . - Precompilación del código original.- En esta etapa se recaba información sobre variabl& funciones, etc.

11 - Inserción del código de control.- 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.!

tipo, nonibre y alcance de las variables. -. Construcción de listas de símbolos. En esta etapa se guarda información sobre el

I/

2

- Compilación y ejecución del código preprocesado. En esta etapa'se compila y ejecuta el programa preprocesado ejecutándose como un proceso hijo del depurador principal. 'I

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

garantiza que solo habrá un proceso depurador y un proceso depurado al mismo tiempo.

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.

- Sincroni,hón de los procesos mediante el uso de semáforos binarios. Con ellos se

1

I II !

22

CAPITULO 4 j/ IMPLEMENTACION DE EL DEPURADOR

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.

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

I .

I

'1

1 DEPURADOR DE PROGRAMAS CONCURRENTES

NIVEL 1

NlVEL 2

NIVEL 3

/I NlWL 4

NIVEL 5

NIVEL 6 I

PROGRAMA DEPURADOR

PROCESOS GENERADOS DINAMICAMENT

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

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

I El algoritmo desarrollado permite que los procesos lanzados por los procesos hijos y

los procesos layados por cualquier otro proceso hasta una profundidad de cinco niveles puedan ser depurados mediante el uso de ‘ptraceo’.

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 encargado de crear las listas de simbolos y preparar el código original para contener el código de depuración y wl necesario es el precompilador desarrollado para este fin, el código precompilado queda estructurado de la siguiente forma:

1

II

I

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/

La funciónitdel ‘1 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.’

A continuación se presenta el algoritmo desarrollado para permitir la depuración de 1 procesos. I1

24 I

seguimiento() 1 inicio

comienzo: Si(proceso-actual ! = proceso-depurado) inicio I1

Si(ProCeSO-aCtual = = proceso-depurador) inicio !I .

V(sem-binano); activar Ccdigo depurador(); P(sembinaA0); ir a comienzo;

tin enotrocaso 11 inicio

V(sem binar¡#); Mientras (proceso-actual ! = proceso-depurado y proceso-actual ! = proceso-depurador); ir a comiemci!

fm . . , i ' fin

Si(la lineaactual, tiene un punto de parada (breakpint)) activa breakpoint; Si(llamando-funcion y salta funcion activado) desactiva traza- Si((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;

I

I' fin fin

fm

i! Codigo-depurador() ~

inicio I 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 I

Esperar orden; Obtener elementos ,de la orden;

fin ! ejecutar la orden; devolver el resultado; ir a siguiente; I

fm I

11 A continuación se presenta la figura 8a, en la cual se ilustra gráficamente el

funcionamiento del algoritmo anterior.

25

9z

iI Y I

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.

v e n d a de edición y seguimiento de la interfaz del depurador. 4.- Una vez terminado el preprocesamiento el código original es desplegado en la

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

i. .

4.2.1 Elementos del Depurador. I1

El depurador implementado cuenta con los siguientes elementos (Fig. IO):

Fig. 10.- Estructura interna del depurador de procesos concurrentes.

I1 -Una interfaz amigable al usuario. - Un modulo preprocesador que lleva a cabo la inserción de código de control y

- Un modulo preprocesador de comandos. - Un analizador y eva1uador.de expresiones.lógicas usado para procesar los

.I

recaba inforrhación del programa a ser depurado.

puntos de parada (breakpoints) condicionales: ~ . .

. . ~ . . . . ~. I/

.. ii i

4.2.1.1 La Interfaz del Depurador. '

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 por el depurador de ,manera fácil y rápida. I)

'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

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.

Iq,TE R.FA Z: D E L D E P U U A I> O R* C 0 . N C U RRbE,N,TfE, il , :

I... MENU A ü A S E DE BOTONES. 2.- EDITOR DETEXTO. >...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

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 sobre la cuali,se va a insertar un,punto de parada (breakpoint), en este caso al oprimir el botón se despliega el i!ombre del comando en la ventana correspondiente a la línea de ordenes para que el 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.

4.2.1.1.2 La p t a n a de Edición y Seguimiento

'1

11

'1 :

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

11

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.

La estructura de los botones identificadores de proceso es la que se muestra en la II

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 de 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.0 y 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/

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.

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:

I/

L ,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 inicio I/ !

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

ii fui .I1 en otro caso Si(pasada = = I ) inicio 11 - Insertar dcclaraciones dc variables de control;

- grabar cada linea procesada al archivo de salida;

Si(es-fin-de-linea '1 y es linea significativa y no es comentario) inicio - Injertar codigo de rastreo de funciones y lineas de codigo

- Inskrtar codigo de control; fin

significativas;

- grab& cada linea procesada al archivo de salida; fui en otro 'Laso .%(pasada = = 2) inicio I

. - Detebtar y procesar las lineas con 'fork()'; - Recabar informacion sobre :

11 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; 4 '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 II en otro caso Si(pasada = = 4) inicio 1

- Poner numeros a las lineas del archivo de entrada; - grabar cada linea procesada al archivo de salida; I

fin leer-cdacter-de(nombre-archivo-entrada);

fin Mientras;:

cerrar(archi vo-de-entrada); cerrar(archiv0-de-salida):

I¡

fin F'recompilar. ' , .

I1

32

I T - -

Ir It

4.2.1.3 El Preprocesador de Comandos.

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/ - Fig. 13.- Representación gráfica de la interacción del' PREPROCESADOR DE COMANDOS con la interfazy los procesos de pur ad os

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)

obten su abrevianira e incluirla en la orden inicio

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;

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

' - Poner en la ventana de respuestas a las consultas el nombre de la variable y la cadena " = ";

33

- Si no cuenta con modificadores de tipo, el espacio que ocupan en la

- Si la variable es orden prepr:+esada llevara un caracter '#';

si no ese espacio io'ocupara un caracter '#'; puntero, incluir en la orden preprocesada la indicacion de puntero;

fin I1 - Enviar la orden preprocesada al proceso depurador;

, fin

II I!

4.2.1.4 El Analizador de Expresiones Lógicas.

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 detiene o ignora el punto de parada (breakpoint).

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 I Si(!vacia),l inicio ~ ,

meter(pila-operadores, op-sacado); op-sacado = cadena nula;

Si(vacia o token no es un ')') inicio ,

fui

II I

meter@ila-operadores, token);

j/

fin .I

' fin fin Mientras(! pila-operadores-vacia) inicio

sacar(pi1a:opkradores. op-sacado); Agragar op-sacado a la cadena postfija; op-sacado. = cadena nula;

devolver(Evaluar expresion(postfija)); fin Convertir - ipi t f i jo ',

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== ' , < " o a n t = = I " < = " o a n t = = ">"oant==">=")devuelve] ; Si(mt == "'=="II ant == "!=") inicio

fin devuelve 91; inicio

SI(pSf = y " & & " O p o s t = = "1J"opos t == "!="opost == "==")devuelve];

Si(ant == "&&")

Si@ost = = "&&" o post = = " 1 I ") devuelve 1; devuelve O:

35

ii Si(ant = = - 1 1 "I) inicio t '

fin I1

Si(post = = "'1 I ") devuelve 1: devuelve O;

fin checarprecedencia

.

Evaluarexpresion(postfij a) inicio A . 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 )I

- 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

- alm4cenar el valor leido;

metei(pila-operandos, valor):

de dato adecuado;

fin

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; valor = ,,Comparar(operador,operando 1 ,operand02); ' meter(pi¡a operandos,valor);

fui 11 - fui sacar(pila-operandos.valor): devolver(va¡or);

fin Evaluar-exbresion I!

4.2.2 Descripción de una Sesión de Depuración. ,:, 11 t

En esta sección se describen los pasos que seguirá el usuario en una sesión de depuración 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 su defecto seleccionando el nombre del archivo y despues el botón Ok.

.I

' 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 de la ejecución del programa.

Una,vez I 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 programa lance un proceso, aparecerá el correspondiente botón identificador en la ventana de identificadores de procesos.

I I1

t

I '

37

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

Jl

, Una,& las funciones de los botones identificadores de proceso es' como su nombre io

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

'1

'r(

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 depurador para que el usuario teclee la información adicional que se necesite. I1

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

II

40

II ' Cuando se consulta el valor de una variable, solo se muestra el valor de la variable en el momento de hacer la consulta, si el valor de la variable cambia ese cambio no se refleja en la ventana de respuestas a las consultas.

'I

II

11 1

Cabe hacer mención de que en cualquier punto de la ejecución de los procesos que forman el programa concurrente es posible interrumpir y reiniciar la ejecución de todo el programa con solo pulsar el botón Reiniciar.

4.2.3 Sintaks de los Comandos del Depurador

Visualizar valores de variables: nombre ddl comando : ver nombre adreviado : v sintaxis II

I/

: ver <nombre de variable> I

Modificar valores de variables: nombre del comando : poner nombre abreviado : p sintaxis 1 observaciones

: poner <nombre de variable> <valor> <lugarl> <lugar2> : lugar1 .- se usa en caso de modificar un elemento de un arreglo o

lugar2.- se usa cuando se va a modificar un elemento de una cadena cadena

que forma parte de un arreglo de cadenas. /I

41

Insertar breakbo'ints: nombre del "comando : parar nombre abdviado : b sintaxis : parar <numero de línea>

Condicionar hbreakpoint: nombre del! comando : cond nombre abreviado : s sintaxis observaciones

: cond <numero de línea> <expresión boolean@ : La expresión booleana debe estar en notación INFIJA, con o sin

I 1 . paréntesis.

. , , . ejemplo: (x == y) && (z == 8)

.¡I '! && : and lógico. > : mayor que.. < : menor que..

Los operadores soportados son los siguientes:

1 1 : or lógico.

== : igual que.. != : diferente de.. >= : mayor o igual que..

<= : menor o igual que.. /i i

Borrar un breakpoint: I . . .

sintaxis I nombre de'l comando : limpia nombre abreviado : 1

: limpia <numero de línea>

Borrar todos los breakpoint: nombre del comando : lmtodos nombre abreviado . : t sintaxis I : lmtodos

Ejecución libre hasta encontrar un breakpoint: nombre del comando : sigue nombre aireviado : c sintaxis I[ : sigue

42

CAPITULO 5 I PRUEBAS REALIZADAS

Para comprobar el buen funcionamiento del depurador de programas concurrentes desarrollado, se sometieron a depuración los programas resultantes de codificar en ‘C’ siete de los algoritmos concurrentes más importantes. Los algoritmos codificados son los siguientes:

‘I t

- Dekker versión 1. - Deeer versión 2. - Deqer versión 3. - Dekker versión 4. - Dekker versión 5. - Lectores y escritores. - Productor consumidor.

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 situación específica y asignar valores a las variables en memoria compartida.

r

/I 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, 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.

1

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’/[se obtuvieron 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’lcomprobar la ocurrencia de cada uno de los estados indicados en la tabla. Una vez que el programa principal ejecutó los fork’s para lanzar cada proceso, se usaron los botones identificadores de proceso para pasar a cada uno de los procesos que.fueron lanzados.

Jj . .

{ (

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:

procedure procesol ; begin

El while true do begin E l E2 while processnumber = 2 do; E2

slcción-critica-uno; ; E3 E4

E3 EA processnumber : = 2; ; E5 op-actividades-uno; E5

I

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;

begin processnumbef : = 1; parbegin

parend procesol; proceso2;

II end.

Tabla de Estados Futuros de la Primera Versión del Algoritmo de Dekker

I

1 I

-

1.3-=2 21 2lpmessninber=2 22 3 , 2 f m x s u T k = l

3,l pocessnnber= 1

3 , 2 f m x s u T k = l 23pocecsurlier=2 1 22 2 2 p r K s w k w - 2 2 2 7 = l MESPCoIBLE

13 23 1.4 24 2.3 23 \ 24 NOESposlBLE 3.1 41 32 4.2 1.4 24

32 32 1.5

42 NOESmBE 25 ~

24 24 25 NOESmBLE 4,1 5,1 4,2 5.2 42 52 4.2 NOESPOSIBLE 1.5 25 1.1 21

, 25 33 21 3.1 51 1,1 52 1,2 52 1.2 5.3 1.3 3.5 4.5 3.1 4.1 5.3 1.3 54 1.4 4.5 55 4.1 51 5,4 1,4 55 1.5 55 1.5 5.1 1.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.

5.2 Código del Algoritmo de Dekker Versión 1 11

#include < signal.h> #include < s y s l 6 s . h > #include <sysl iy .h > #include < syslsh,m.h > #include < sysisemh > #include < sys/errno.h>

int *vcl,pid,ml; char car2[40]; I,

#define processnumber (*vel)

main0

iI i1

int a; l {

memoria(); processnumber - 1;

if ((pid = fork()) = = O) 1- I

if ((pid = fork()) = = O)

I I I 1 éxit(0); I

I

Y memoria()

key-t llave; {

llave = (key-t)IPC , - PRIVATE;

46

int h=O, 1, CRITICO = O; (

' I

while(h¿ 1ooO) I/

t+!+; while (processnumber = = 2) (

(

I CRITICO++;

proces,inumber = 2;

p20 ( 'I

int h=O, t. CRITICO = O; I t

whiles < IMM)

while (processnumber = = 1) { (

CRI/ICO++; ti+; processnumber = I; h+ +;

1 éxit( 18);

'I 1

t

5.3 Código del Algoritmo de Dekker Versión 2

II #include <signal.h > #include < sys/tyypes.h> #include <sys/ipc.h> #include < sys/shin.h> #include < sys/sem.h> #include < sys/eho.h > int *pl-i, *p2+ l. . int pid,ml.m2; char car2[60];

#define plinside (*pl-i) /* contenido de mem comp * / #define p2mide (*p2-i)

'1

11

main()

I memoria(); plinside = O; p2inside = O; '1

if ((pid = fork()) = = O) Ir

! if ((pid =.fork()) = = O) ' (

1 P20; 11

memoria() [

i

1 8 ;

exit(0); ,

1

( k e y t llave; :

llave = (key-t)lPC-PRIVATE ml =; 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); )

m2 if(m2 == $1) ( perrot(" shmget "); exit(2); ) p2-i = (int p) shmat(m2.(char *)O, O); if((int) &p2fnside = = -1) ('perror(" shmgei "): exit(2); )

shmget(1lave. sizeof(int), 0660 I IPCCREAT);

11

48

int h=O, t, CRITICO = O; while(h< i ~ )

0 . ' t++;

while (p2mside) { ,{

I plinside = 1; CRITICO + + ;

plinside = O; h + + ; . \

1 I

I. 1 exit(0);

int h=O, 1, CRITICO = O; while(h < 1ooO)

while (plinside) ( . (

p2inside = 1 ; CRITICO+ +;

p2inside ;= O; h f f ; '

49

I

5.4 Código del Algoritmo de Dekker Versión 3

#include <signal.h> #include < sys/types.h > #include < sys/ipc.h> #include <iys/shm.h> #include <sys/sem.h> #include < syderrn0.h >

1: , L

int *pl-w, ,!*p2w; int pid,inl,; char car21ffJI;

#define plwantstoenter (*piw) /* contenido de'mem comp *I #define p2wahoenter (*p2-w)

int pid,ml,,m2; char car2[$];

main()

int a;

memoria(): piwanistoenter = O; .,

pi-wantsiloenter = O;

if ((pid = fork()) = = O)

{

!I I

I

50

memoria() I

k e y t llave; {

li llave = (key-$)iPCPRIVATE;

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); 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); )

'I

I1

P I 0 {

int h=O, CRITiCO = O; while(h< IOOO)

I I II plwantstoenter = I ;

while l(p2wantstoenter); CRITICO+ +;

plwantstoenter = O; h + + ;

P20 { Y

int h=O, CRITICO = O; while(h< IOOO)

{ p2wantstoenter = 1; while' (plwantstoenter); CRI$ICO+ +;

p~wihtstoenter = O; h++'; !

1 , , 8

exit(0); . , I

' I 51

, 5.5 Código.del Algoritmo de Dekker Versión 4

I !

#include < sign4.h > #include < sys/&s.h> #include < syslik.h> #include < s y s l V . h > #include < syslym.h> #inciude < 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; 11 main()

int a; I/ {

I memoria(); plwantstoenter = O; p2wantstoenter = O;

if ((pid = fork()) = = O) I,

( 'I

52

memoria0

key-t llave;

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); if((int) &piwantstoenter = = - I ) { perror(" shmget "); exit(2); ]

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

II

iI

'1

1 I'

P i 0 { 1

int m, i , h=O, CRITICO = O; while@ < "0)

plwantstoenter = I; while '~p2wantstoenter)

plwantstoenter = O; for(i=l; i<200; i + + ) {

{

{ I1 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 + + ) {

1; I p2whtstoenter = I ;

} .:

CRITICO+ +; p2wanIstwnter = O; h+ +;'!

{

mi+;

I exit(0);

1

54

I

5.6 Código del Algoritmo de Dekker Versión 5

1 #include < signT1.h > #include < sys/types.h > #include < sys/ipc.h> #include <sys/shm.h> #include < sysl7em.h > #include < sys/errno.h>

I) int ' p l w , *p2-w, ' fp ; ¡ni pid,ml: char car2[60]; 1 #define plwantstoenter (*p lw) I* contenido de mem comp *I #define pZwan$toenter (*pZ-w) #define favoredprocess (* fp ) int pid,ml .m2,m3; char car2[60]; 11 main()

memoria(); ,

plwantstoenter = O; p2wantstoenter = O; favoredprocess = 1;

I1 I1 if ((pid = fork()) = = O)

l

55

memoria() , . , ,

k e y t llave;

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); 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); if((int) &p2wantstp1ter = = -1) ( perror(" shmget "): exit(2); }

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

11

11

11

I

I

8,

int m, i , h=O, CRITICO = O; while@ < l@I)

{

!I "

plwantstoenter = I ; whil?/ (pzwantstoenter)

(

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

11 p20 (

int m. i, h=O.~CRITICO = O; while@< 1ooO)

p2wantstoenter = I ; while (pi wantstoenter)

I

( )I if(favoredprocess = = I ) ( p2Wantstoenter = O; while(favoredprocess = = 1);

p2wantstoenter = I ;

LRITICÓ+ +; favoredprocess = 1; p2wanktoenter = o; h++;’)

I , 1

exit(0);

lí

57

siguientes: ~

' /

58

Tabla de Estados Futuros Correspondiente al Algoritmo de Lectores y Escritores

I I ESTADOS TRANSITORIOS

/I OOOM OOLO

' OOLM

ESTADOS INVALIDOS

1 KLM

59

11

ll Grafo Correspondiente a la Tabla de Estados Futuros

del Algoritmo de Lectores y Escritores

1

1 5.8 Código del Algoritmo de Lectores y Escritores

II #include < signa1.h > #include < sys/types.h> #include <sys/ipc.h > #include < sys/;hm.h > #include <syslsem.h> #include < sys/ermo.h>

/**%%%*%*** DECLARACIONES P A M SEMAFOROS **%%%**%***********/

I extern errno; #define PERM O600 FPermisos para los semaforos *I

ushort semarray[3];

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;

II

1; union semunJ arg;

int pid,ml .m2,m3,m4,sem; char car2[60];

I1

61

I****** CREA~ION Y OPERACIONES DE SEMAFOROS *****I

creasem(semkey) , ,

key-t semkeyi ' I* la llave del semaforo * I ( I* crea un conjunto de semaforos ' 1

in< semid, status = O;

'I

I* regresa - 1 <n error */

arg.arrayT&( semarray[O]); * arg.array = I ;

*(arg.array+l) = O; *(arg.array+Z) = O;

j

semid 7 semget(semkey, NSEM, PERM 1 IPC-CREAT 1 IPC-EXCL); if(semid = = - I )

semid = semget(sernkey, NSEM, O); I if(errno = = EEXIST) I

else perror("semget"1;

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 II 'I I

if(status == - I ) {

' return -1; ,perfor(" creasem");

else ll ! feNrn semid;

I !

Y' V(semid,n) int semid,n; { I* operacion V */

int status; struct sembuf p-buflN-OP];

'11 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

62 ' I

P(semid,n) int semid,n; { I* operacion *I

stmct sembuf p_buf( N-OP I; ~- - unsigned char 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, pbuf , N-OP) = = -1); 1 I\

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

main() .iI int a;

{

11 sem = creasem((key-t)getpid()); memoria(); ' cont-lec = O; cont-esc = O; lec-acce = O: escribiendo 4 O;

if ((pid = fork()) = = O)

1 I

Lector-i(); í

I else {

if ((pid = fork()) = = O)

Escr ir or!@; {

1 I I

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@);} c lec = (di*) shmat(ml,(char *)O, O); 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); } 1 a = (int *) shmat(m3.(char *)O. O); if((int) &lecacce := = -1) { perror(" shmget "); exit(2); ]

m4 = shmget(llave, sizeof(int), O660 1 IPCCREAT); if(m4 = = -1) ll{ perror(" shmget "); exit(2); } esc = (int *) shmat(d,(char +)O, O); if((int) &escri$endo = = -1) { perro[(' shmget "); exit(2); }

~

I 'I

1

if(escribiend0. I I contesc ! = O)

cont-lec =, I cont-lec + I ; V(sem, MVTEX); P(sem, LEC); cot-lec =,cont-lec - 1;

lec-acce = lec-acce + 1; if(co-lec ! = O) {

V(sem, LT);

V(sem, MUTEX);

{

1 'I

1 else {

/* LECTURF *I

P(sem, MUTEX); lec-acce = lec acce - 1; if(iec-acce = = O && con1 - esc ! = O) I1 -

64

EscritorJ) Ii P(sem, MUTEX); if(1ec - acce ! = O I ;I escribiendo)

{

iI coni esc = coni-esc + 1;

P(sem, ESC); ~

cont-esc = coni esc - 1;

{

V(sein, MUTEX);

} y - escribiendo = 1; V(sem, MUTEX);

I' ESCRITUq ' I

P(sem, MUTEX); escribiendo = b; if(coni-iec ! = lo) {

!I

V(sem, LEG); 'i

élse { if(con-esc !,= O)

65

1) 5.9 Código del Algoritmo de Productor - Consumidor

11 . #include <signaJ.h> #include < sys/types.h > #include < sysíipc.h > #include < sys/shm.h > #include < sys/&m.h > #include < sys/errno.h>

l i /******Sf** DECLARACIONES PARA SEMAFOROS ....................

extern errno; #define PERM![ 0600

ushon semarray[3];

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

union semun {

I* Permisos para los semaforos *I

I1

'I inf val; struct semidlds *but ushori *array;

union semun arg; 1; ( I , 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

I

I1

66

I I****** CREACION Y OPERACIONES DE SEMAFOROS *****/

!I creasem(semkey),l key-t semkey;: i /* la llave del semaforo *I { /* crea un conjbto de semaforos *I

int semii, Status = O; /* regresa -1 en error *I

11 arg.array=&( semarray[~l);

* arg.a+ay = 1; *(arg.array+mi) = o; *(arg.array+2) = O;

i/

'1 if(ermo = = EEXIST)

semid 7 semget(semkey, NSEM, PERM I IPCCREAT 1 IPCEXCL); if(semid = = -1)

~

, else perror("semget"); semid = semget(semkey, NSEM, O);

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

return -1; ,' .i 1 ' f

else , ,i returnsemid;

1

!I V(semid,n) ' I int semid,n; i , , .

( /* operacion V */

int status? struct sembuf p-buf[NOP];

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; return(semop(semid, p-buf, N-OP) = = -1);

!I

I

,

61

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;

retum(semop(semid, p-buf, N O P ) == -1); 1 ? 1

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . '11

main()

int a;

sem = creasem((key-t)getpid()); memoria(); 11 unidades = O;

11 l

if ((pid = fork()) = = O) Jl

Productor(); {

, I

Consumidor();

1 !I exit(0);

li key-t llave; ,

{

llave = (key-t)IPC-PRIVATE;

ml = shmget(llave, sizeof(int), O660 I IPCCREAT); if(m1 = = $1) { penor(" shmget "); exit(2); } vcl = (int *) shmat(ml,(char *)O, O); if((int) &unidades = = - I ) { penor$" shmget "); exit(2); }

I!

I/

1 I1

68

I

11

Productor()

int espacio; I

do { I** PRODUCE UNIDAD DE INFORMAClON **I P(sem, BUFF); I** DEPOSITA UNIDAD **I

'I, .. . unidades =, unidades + I; espacio = MAX - unidades; if(unidades.j = = 1) {

V(sem. CONS): 1 . . '..

v(s~rn, B U ~ F ) ; : }while(espacio,.! = O); Pfsem : 'PROD): exit(0);

I

Consumidor0

l . int que-consumir;

P(sem, CONS);

{

. . I

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

} !I

V(sem, BUFF); )whiIe(que-consumir ! = O); exit(0);

69

CAPITULO 6 I1 CONCLUSIONES

11 6.1 Conclusiones ,

En la actualidad los programas multiproceso, ya sean de ejecución concurrente, paralela O

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

ii

1 .

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 de programas concurrentes o paralelos; existen también desarrollos orientados hacia la depuración de programas distribuidos.

4 1

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 programas concurrentes de aplicación comercial. It

.! El desarrollo del depurador de programas concurrentes que es tema de esta tesis nos ha

- 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? la lógica del programa concurrente a depurar no se ve afectada por la acción

- Que el uso de semáforos y memoria compartida como instrumentos de control y

I permitido demostrar los siguientes puntos: li

I/

del código de control insertado en su código fuente.

'1 sincronización de los procesos depurados brinda resultados positivos.

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

I t

70

6.2 Trabajos Futuros

I1 I/

El desarrollo de este depurador marca una línea de investigación que de seguirse, dará 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 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'hasta ahora son los siguientes:

11

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

I y comunicación de procesos en red que proporciona el sistema operativo UNIX.

- 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 h i r la generación de una ventana para cada proceso y un esquema de depuración I 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 ).

II - 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", ~ ~ ~ m ~ ~ ' 1 " ~ I ~ ~ : ' , "register", "typedef",

"extern", "return", "union", "const', !. ",float", "short", "unsigned", '"continue:". '"for". "signed", "void", "default"! "goto", "sizeof", "volatile", "do", 4 "if", "static", , "while", " - 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; !

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",

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;

"semop"

12

union mem( 11 int xi; short xh; longxl; '

unsigned xu;: shon int xhi; long jnt xli; unsigned intixuf; unsigned short int xubi; unsigned long in1 xuli; float y; char byte131;

't

11

1; typedef struct (

int palabra! ; int palabra2

JMEM-DOBLE; I!

union doble{l MEM-DOBLE zona; doubley; ' ' long double z;

1; ,Ir

I*** DEFINICION DE ESTRUCTURAS QUE CONTENDRAN LA INFORMACION DE *****I

*****I 1

I*** I*** A DEPURAR

VARIABLES GLOBALES, VARIABLES LOCALES Y FUNCIONES DEL PROGRAMA ****I

iI smct LISTA-CONDICIONADOS

int PID; lint lineabreakpint; char condicion[256]; struct LISTA-CONDICIONADOS *si&

(

)l;fta-condicionados;

struct LISTA-PROCESOS { II - 'I .

int PID, PIDqadre; unsigned char eliminado,reprtado;

struct LISTA-PROCESOS *sig; ,, ini valexit;

)listagrocesos; I

73

struct

' '1 char modificador 1[10]; c l h modificador[lO]; cdL tipo[i01; c& nombre[20]; chkr 1imitei[i01; c&r 1imite2[101; int esquntero; in{ direccion; int visible;

}list~~vvglobales;

'I

stAct LISTA-VAR-G~OBALES *síg;

LISTA-VAR-GLOBALES

S t m LISTA~VAR-COMPARTIDAS l I

1 '

. c d u modificadorl[lO]; c&r modificador[ 101 ; c&r tipo[i01; c d k nombre[20]; c h b limitel[lO]; cdkr limite21 101 ; int espuntero; in$ direccion; :in4 visible; sthct LISTA-VAR-COMPARTIDAS *sig;

'

Jlista~vcompartidas;

char nombre[20] ; ,char tipo[lO]; ,strnct LISTA-RUTINAS *si&

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.

}~ista!!v~oca~es;

StmCt LISTA - ~ U T I N A S

.oc ES *sig;

14

struct LINEAS 1 int num-linea; int pos-car-¡ni; stdct LINEAS 'sig;

{

1 }lisia-lineas;

union tipos{ 11 int xi; l

shonxh; ' ' long xl; unsigned xu; 1 shon int xhi; long int xli; ': , unsigned int xui; unsigned shoh int xuhi; unsigned loni in1 xuli; float y; double y2; long double z; char car; 11 char cadena[256];

I

, , 1;

I¡ struct define-operandos { char tipo[20]: union tipos dato;

struct stack-operadores {

char operador[801[31; in1 top; ,I

1; 'I

S ~ N C ~ stack-bperandos { int top; I/

struct define-operandos operando[80];

!I 1;

7s

[LEV931

[COF92]

[MAR931

[SWA90]

[DEI931

[TOR941

[STE92]

[BER93]

BIBLIOGRAFIA

/I - p s s , Levi [y] Radin, Joseph “Aplique X WINDOW.. Qbome-Mc Graw Hill, 1993.

Coffin, Stephen, “UNIX Sistema V versión 5 Manual de Referencia”. Mc Graw Hill, 1992.

?4arquez García, Fco Manuel, “UNIX. Programación avanzada”. Addison-Wesley iberoamericana [y] ra-ma, 1993.

Swan, Tom, “Mastering Turbo Debugger”, Hyden Books, 1990.

Deitel, H.M., “Sistemas Operativos”, Segunda edición, Addison-Wesley iberoamericana, 1993.

Torres Jiménez, Jose, “Apuntes de Sistemas Operativos”, 1994.

Stevens, W. Richard, “Advanced Programming in the UNIX Environment”. Addison-Wesley publishing Company, h c .

Bergmark, Donna, “Update on Tools for Parallel Programming at the CNSF”, Technical Report, Cornell University, Marzo, 1993.

1

ii I

II

¡I

I 16