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