UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN FACULTAD DE INGENIERIA E.A.P. INGENIARIA EN INFORAMTICA Y SISTEMAS MONITORES: "PROBLEMA DE SANTA CLAUS PRESENTADO POR: Uriel Jonatan Villaca Paco CODIGO 2013-39111 DIRIGIDO A DOCENTE/ CURSO: Ing. Ana Cori Moron Algoritmos paralelos TACNA- PERU 2014 1
INTRODUCCIÓN Cuando estamos enfrente de algún caso de concurrencia entre procesos es necesario conocer las diversas soluciones y alternativas para controlar la exclusión mutua y sincronización entre dos o más procesos. Entre las cuales están dos herramientas para controlar el acceso a la sección crítica: semáforos y monitores. Los semáforos nos ofrecen un control del acceso a la sección crítica interna de los procesos, mientras que los monitores controlan el acceso mediante procesos externos. Para aprender mejor el uso de semáforos y monitores es necesario conocer también los problemas clásicos de concurrencia. Los problemas clásicos de concurrencia son solucionados de diversas maneras y nos dan idea de como aplicar los monitores y semáforos correctamente y cuáles pueden ser nuestros errores al encontrarnos con problemas similares. El Problema de Santa Claus es un problema clásico de concurrencia, donde se tiene como objetivo obtener la sincronización y exclusión mutua entre procesos. Este problema nos da una idea de cómo analizar en busca de una solución cuando se tiene problemas de este tipo, además si tuviéramos un caso similar en la vida real (posiblemente en un caso laboral) podríamos aplicar una solución adecuada. 2
EL PROBLEMA DE SANTA CLAUS 1. DEFINICIÓN: 1.1. Definición de Semáforos La idea de un semáforo para el control del tráfico de coches se puede emplear sin grandes modificaciones para el control de acceso a datos. Un semáforo es una estructura particular que contiene un valor mayor o igual a cera y que maneja una cola de procesos esperando por unas condiciones particulares en el propio semáforo. Aunque parezcan sencillos, los semáforos son muy potentes, lo que incrementa consecuentemente las complicaciones. Empecemos (como siempre) dejando fuera el control de errores: lo meteremos en nuestro código cuando encaremos un programa más complejo. Los semáforos pueden utilizarse para controlar el acceso a recursos: el valor del semáforo representa el número de procesos que pueden acceder al recurso; cada vez que un proceso accede al recurso el valor del semáforo debe ser decrementado e incrementado de nuevo cuando el recurso sea liberado. Si el recurso es exclusivo (sólo un proceso puede acceder) el valor inicial del semáforo será 1. 3
OperaciónWait (P): Si el valor del semáforo no es nulo, esta operación decrementa en uno el valor del semáforo. En el caso de que su valor sea nulo, la operación suspende el proceso que lo ejecuta y lo ubica en la lista del semáforo a la espera de que deje de ser nulo el valor. Operación Signal (V): Incrementa el valor del semáforo, y en caso de que haya procesos en la lista de espera del semáforo, se activa uno de ellos para que concluya su operación Wait. 1.2. Definición de monitores En la programación paralela, los monitores son objetos destinados a ser usados sin peligro por más de un hilo de ejecución. La característica que principalmente los define es que sus métodos son ejecutados con exclusión mutua. Lo que significa, que en cada momento en el tiempo, un hilo como máximo puede estar ejecutando cualquiera de sus métodos. Esta exclusión mutua simplifica el razonamiento de implementar monitores en lugar de código a ser ejecutado en paralelo. 4
En el estudio y uso de los semáforos se puede ver que las llamadas a las funciones necesarias para utilizarlos quedan repartidas en el código del programa, haciendo difícil corregir errores y asegurar el buen funcionamiento de los algoritmos. Para evitar estos inconvenientes se desarrollaron los monitores. El concepto de monitor fue definido por primera vez por Charles Antony Richard Hoare en un artículo del año 1974. La estructura de los monitores se ha implementado en varios lenguajes de programación. Un monitor tiene 4 componentes: -Un conjunto de variables locales que podemos denominar permanentes. Dichas variables se utilizan para almacenar el estado interno del recurso. -Un código de inicialización que se ejecuta antes de la primera instrucción ejecutable del programa, inicia las variables. -Un conjunto de procedimientos internos que manipulan las variables permanentes. -Una declaración de los procedimientos que son exportados y por lo tanto pueden ser accedidos por los procesos activos que accedan al monitor. 5
1.3. El problema de Santa Claus Santa Claus pasa su tiempo de descanso, durmiendo, en su casa del Polo Norte. Para poder despertarlo, se ha de cumplir una de las dos condiciones siguientes: 1. Que todos los renos de los que dispone, siete en total, hayan vuelto de vacaciones. 2. Que algunos de sus duendes necesiten su ayuda para fabricar un juguete. Para permitir que Santa Claus pueda descansar, los duendes han acordado despertarle si tres de ellos tienen problemas a la hora de fabricar un juguete (figura 1). En el caso de que un grupo de tres duendes están siendo ayudados por Santa, el resto de los duendes con problemas tendrán que esperar a que Santa termine de ayudar al primer grupo. En caso de que haya duendes esperando y todos los renos hayan vuelto de vacaciones, entonces Santa Claus decidirá preparar el trineo y repartir los 6
regalos (figura2), ya que su entrega es más importante que la fabricación de otros juguetes que podría esperar al año siguiente. El último reno en llegar ha de despertar a Santa mientras el resto de renos esperan antes de ser enganchados al trineo. Figura 1: Duendes despiertan a Santa para que los ayude. Figura 2: Santa se va a repartir regalos. 1.3.1. Solución con Semáforos Para solucionar este problema, se pueden distinguir tres procesos básicos: i) Santa Claus, ii) duende y iii) reno. Respecto a los recursos compartidos, es necesario controlar el número de duendes que, en un determinado momento, necesitan la ayuda de Santa y el número de renos que, en un determinado momento, están disponibles. 7
Evidentemente, el acceso concurrente a estas variables ha de estar controlado por un semáforo binario. Respecto a los eventos de sincronización, será necesario disponer de mecanismos para despertar a Santa Claus, notificar a los renos que se han de enganchar al trineo y controlar la espera por parte de los duendes cuando otro grupo de duendes esté siendo ayudado por Santa Claus. En resumen, se utilizarán las siguientes estructuras para plantear la solución del problema: Duendes: Variable compartida que contiene el número de duendes que necesitan la ayuda de Santa en un determinado instante de tiempo. Renos: Variable compartida que contiene el número de renos que han vuelto de vacaciones y están disponibles para viajar. Mutex: Semáforo binario que controla el acceso a Duendes y Renos. 8
SantaSem: Semáforo binario utilizado para despertar a Santa Claus. RenosSem: Semáforo contador utilizado para notificar a los renos que van a emprender el viaje en trineo. DuendesSem: Semáforo contador utilizado para notificar a los duendes que Santa los va a ayudar. Proceso Santa Claus: Santa está durmiendo a la espera de que lo despierten. Si lo despiertan, será porque los duendes necesitan su ayuda o porque todos los renos han vuelto de vacaciones. Por lo tanto, Santa tendrá que comprobar cuál de las dos condiciones se ha cumplido. Si todos los renos están disponibles, entonces Santa preparara el trineo y notificará a todos los renos. Si hay suficientes duendes para que sean ayudados, entonces Santa los ayudará, notificando esa ayuda de manera explícita mediante el semáforo DuendesSem. Proceso Reno: 9
El proceso reno es bastante sencillo, ya que simplemente ha de despertar a Santa cuando todos los renos están disponibles y, a continuación, esperar la notificación de Santa. Una vez más, el acceso a la variable compartida renos se controla mediante el semáforo binario mutex. Proceso Duende: Finalmente, en el proceso duende se ha de controlar la formación de grupos de duendes de tres componentes antes de despertar a Santa. Si se ha alcanzado el número mínimo para poder despertar a Santa, entonces se le despierta mediante signal sobre el semáforo SantaSem. Si no es así, es decir, si otro duende necesita ayuda pero no se ha llegado al número mínimo de duendes para despertar a Santa, entonces el semáforo DuendesMutex se libera. El duende invocará a obtener Ayuda y esperará a que Santa notifique dicha ayuda mediante DuendesSem. Note cómo después de solicitar ayuda, el duende queda a la espera de la notificación de Santa. 10
2. OBJETIVOS Solucionar la exclusión mutua y condición de sincronización en el problema de Santa Claus con semáforos y monitores. Aprender más acerca de los monitores. 3. ALGORITMO DE SANTA CLAUS APLICANDO SEMÁFOROS 3.1. El presente algoritmo da solución al problema de Santa Claus. 1. INICIO 2. Declarar constante TotalRenos=7 3. Declarar constante NumDuendesGrupo=3 4. Declarar variables renos y duendes como entero 5. Declarar variables SantaSem, DuendesSem, RenosSem y mutex como semáforos 6. Crear proceso SantaClaus 6.1. Inicio proceso 6.1.1. Repetir 6.1.1.1. Esperar(SantaSem) 6.1.1.2. Esperar(mutex) 6.1.1.3. Si renos es igual a TotalRenos entonces 6.1.1.4. Inicio de condición si 6.1.1.4.1. Señal(RenosSem) 6.1.1.4.2. Mostrar Santa salio a repartir regalos 6.1.1.4.3. Señal(mutex) 6.1.1.5. Fin de condición si 6.1.1.6. Caso contrario hacer 11
6.1.1.7. Inicio de caso contrario 6.1.1.7.1. Si Duendes es igual a NumDuendesGrupo entonces 6.1.1.7.2. Inicio de condición si 6.1.1.7.2.1. Mostrar Santa ayuda a los Duendes... 6.1.1.7.2.2. señal(duendessem) 6.1.1.7.2.3. Señal(mutex) 6.1.1.7.3. Fin de condición si 6.1.1.8. Fin de caso contrario 6.1.2. Por siempre 6.2. Fin de proceso 7. Crear proceso Reno 7.1. Inicio proceso 7.1.1. Repetir 7.1.1.1. Esperar(mutex) 7.1.1.2. Si renos es igual a TotalRenos-1 entonces 7.1.1.3. Inicio de condición si 7.1.1.3.1. Aumentar el valor de renos en 1 7.1.1.3.2. señal(santasem); 7.1.1.3.3. Mostrar reno 7 llegó de vacaciones y despertó a Santa 7.1.1.3.4. Señal(mutex) 7.1.1.3.5. esperar(renossem) 7.1.1.3.6. asignar a renos el valor de 0 7.1.1.4. Fin de condición si 7.1.1.5. Caso contrario hacer 7.1.1.6. Inicio de caso contrario 7.1.1.6.1. Aumentar el valor de renos en 1 7.1.1.6.2. Mostrar mensaje: Reno llego de vacaciones 7.1.1.6.3. Señal(mutex) 7.1.1.7. Fin de caso contrario 7.1.2. Por siempre 12
7.2. Fin de proceso 8. Crear proceso Duende 8.1. Inicio proceso 8.1.1. Repetir 8.1.1.1. Esperar(mutex) 8.1.1.2. Si duendes es igual a NumDuendesGrupo- 1 entonces 8.1.1.3. Inicio de condición si 8.1.1.3.1. Aumentar el valor de duendes en 1 8.1.1.3.2. Mostrar el mensaje: tres duendes despiertan a santa solo a pedir ayuda 8.1.1.3.3. Señal (SantaSem) 8.1.1.3.4. Señal(mutex) 8.1.1.3.5. Esperar(DuendesSem) 8.1.1.3.6. asignar a duendes el valor de 0 8.1.1.4. Fin de condición si 8.1.1.5. Caso contrario hacer 8.1.1.6. Inicio de caso contrario 8.1.1.6.1. Aumentar el valor de duendes en 1 8.1.1.6.2. Señal(mutex) 8.1.1.7. Fin de caso contrario 8.1.2. Por siempre 9. Fin de proceso 10. INICIO DE PROGRAMA PRINCIPAL 10.1.Asignar a duendes el valor de 0 10.2.Asignar a renos el valor de 0 10.3.Inicializar semáforo mutex en 1 10.4.Inicializar semáforo SantaSem en 0 10.5.Inicializar semáforo RenosSem en 0 10.6.Inicializar semáforo DuendesSem en 0 10.7.INICIO DE PROCESOS CONCURRENTES 10.7.1. Inicializar proceso SantaClaus 10.7.2. Inicializar proceso Reno 10.7.3. Inicializar proceso Duende 13
10.8.FIN DE PROCESOS CONCURRENTES 11. FIN PROGRAMA PRINCIPAL 12. FIN. 14
DIAGRAMA DE FLUJO 3.2. Para un mejor entendimiento y seguimiento al problema de Santa Claus se desarrolló un diagrama de Flujo. Figura 3. Diagrama de flujo del programa principal. 15
Figura 4. Diagrama de flujo del proceso SantaClaus. 16
Figura 5. Diagrama de flujo del proceso Reno. 17
Figura 6. Diagrama de flujo del proceso Duende. 18
4. SEUDOCÓDIGO DEL PROBLEMA DE SANTA CLAUS APLICANDO SEMAFOROS 4.1. Especificacion de los procesos del problema de Santa Claus en pseudocódigo: Proceso SantaClaus repetir 1. wait(santasem) 2. wait(mutex) 3. si (renos=totalrenos) entonces signal(renossem) santa salio a repartir regalos signal(mutex) end 4. Caso Contrario si duendes = NumDuendesGrupo) entonces Santa ayuda a los Duendes signal(duendessem) signal(mutex) end end Por siempre end 19
Proceso Reno; repetir 1. wait(mutex) 2. si (renos=totalrenos-1) entonces renos:=renos+1 signal(santasem) Último reno llegó de vacaciones y despertó a santa... signal(mutex) wait(renossem) renos:=0 end 3. else renos:=renos+1 un reno llegó de vacaciones signal(mutex) end por siempre Proceso Duende; repetir 1. wait(mutex) 2. si duendes = (NumDuendesGrupo-1) entonces duendes:=duendes+1 tres duendes despiertan a santa solo a pedir ayuda signal(santasem) signal(mutex) wait(duendessem) duendes:=0 end 20
3.caso contrario duendes:=duendes+1 signal(mutex) por siempre Las variables duendes y renos comienzan en 0. El semaforo mutex inicializa en uno. los semaforos SantaSem, DuendesSem y RenosSem inicializan en 0. 5. CÓDIGO FUENTE 5.1. Código Fuente con semáforos: program SantaClaussem; const TotalRenos=7;NumDuendesGrupo=3; var SantaSem,DuendesSem,RenosSem,mutex:semaphore; renos,duendes:integer; process SantaClaus; repeat wait(santasem); wait(mutex); if (renos=totalrenos) then signal(renossem); writeln('santa salio a repartir regalos'); writeln(' '); signal(mutex); end else 21
forever if (duendes = NumDuendesGrupo) then writeln(' Santa ayuda a los Duendes...'); signal(duendessem); signal(mutex); end process Reno; repeat wait(mutex); if (renos=totalrenos-1) then renos:=renos+1; signal(santasem); writeln('reno ',renos,' llegó de vacaciones y despertó a santa...'); signal(mutex); wait(renossem); renos:=0; end else renos:=renos+1; writeln('reno ',renos,' llegó de vacaciones'); signal(mutex); forever 22
process Duende; repeat wait(mutex); if ((duendes = NumDuendesGrupo-1)) then duendes:=duendes+1; writeln(' tres duendes despiertan a santa solo a pedir ayuda'); signal(santasem); signal(mutex); wait(duendessem); duendes:=0; end else duendes:=duendes+1; signal(mutex); forever duendes:=0; renos:=0; initial(mutex,1); initial(santasem,0); initial(renossem,0); initial(duendessem,0); co SantaClaus; Reno; Duende; co end. 23
5.2. RESULTADOS AL EJECUTAR EL CÓDIGO FUENTE. Figura 3. Resultados obtenidos al ejecutar el código del problema de Santa Claus con semáforos. El resultado muestra que a inicializar la ejecución santa se encuentra dormido y no realiza ninguna acción. Al mismo tiempo que santa duerme los renos van llegando de uno en uno 24
hasta que llega el séptimo reno y despierta a santa para que salga a repartir los regalos, también los duendes trabajan concurrentemente y cuando tres duendes se les presenta problemas, solo en ese caso despiertan a santa un instante para que los ayude a solucionar su problema y santa sigue durmiendo hasta que otro evento lo despierte. Esta iteraccion se repite muchas veces para ver que no hay interbloqueos entre procesos lo cual se comprueba en la ejecución del código fuente. 6. ALGORITMO DEL PROBLEMA DE SANTA CLAUS APLICANDO MONITORES 1. INICIO 2. Crear monitor santaclaus 2.1. Exportar procedimiento santaclaus, renos, duendes 2.2. Declarar constante TotalRenos igual a 7 2.3. Declarar constante NumDuendesGrupo igual a 3 2.4. Declarar variables numduende y numrenos como enteros 2.5. Declarar variables santa, renos y duendes como condición 2.6. Crear procedimiento santaclaus 2.7. Inicio procedimiento 2.7.1.1. Si numrenos es igual a TotalRenos entonces 2.7.1.2. Inicio de condición si 2.7.1.2.1. Retrasar(santa) 2.7.1.2.2. Santa Claus salió a repartir regalos 2.7.1.2.3. Retardar(santa) 2.7.1.2.4. Asignar a numduende el valor de 0 2.7.1.2.5. Asignar a numrenos el valor de 0 2.7.1.2.6. Reanudar(renos) 2.7.1.3. Fin de condición si 2.7.1.4. Caso contrario hacer 2.7.1.5. Inicio de caso contrario 25
2.7.1.5.1. Si numduendes es igual a NumDuendesGrupo entonces 2.7.1.5.2. Inicio de condición si 2.7.1.5.2.1. Duendes despiertan a Santa para pedir ayuda... 2.7.1.5.2.2. Asignar a numduende el valor de 0 2.7.1.5.2.3. Reanudar(duendes) 2.7.1.5.3. Fin de condición si 2.7.1.6. Fin de caso contrario 2.7.2. Fin de condición 2.8. Fin de proceso 2.9. Crear procedimiento Reno 2.10.Inicio procedimiento 2.10.1. Aumentar el valor de numrenos en 1 2.10.2. Si numrenos dividido entre TotalRenos da un residuo 0 entonces 2.10.3. Inicio de condición si 2.10.3.1. Último reno llega de vacaciones y despierta a Santa 2.10.3.2. Retardar(renos) 2.10.3.3. Reanudar(santa) 2.10.4. Fin de condición si 2.10.5. Caso contrario hacer 2.10.6. Inicio caso contrario 2.10.6.1. Un reno llega de vacaciones 2.10.7. Fin caso contrario 2.11.Fin de procedimiento 2.12.Crear procedimiento duende 2.13.Inicio procedimiento 2.13.1. Aumentar el valor de numduende en 1 2.13.2. Si numduende dividido entre NumDuendesGrupo da un residuo 0 entonces 2.13.3. Inicio de condición si 2.13.3.1. Reanudar(santa) 2.13.4. Fin de condición si 2.14.Fin de procedimiento 2.15.INICIO DE VARIABLES DE MONITOR 2.15.1. Asignar a numrenos el valor de 0 26
2.15.2. Asignar a numduendes el valor de 0 2.16.FIN DE INICIALIZACION DE VARIABLES DE MONITOR 3. Crear proceso COsanta 4. Inicio de proceso 4.1. Repetir 4.1.1. Invocar el procedimiento santaclaus del monitor santaclausm 4.2. Por siempre 5. Fin de proceso 6. Crear proceso COreno 7. Inicio de proceso 7.1. Repetir 7.1.1. Invocar el procedimiento reno del monitor santaclausm 7.2. Por siempre 8. Fin de proceso 9. Crear proceso COduende 10. Inicio de proceso 10.1.Repetir 10.1.1. Invocar el procedimiento duende del monitor santaclausm 10.2.Por siempre 11. INICIO DE PROGRAMA PRINCIPAL 11.1.INICIO DE PROCESOS CONCURRENTES 11.1.1. Inicializar proceso COsanta 11.1.2. Inicializar proceso COreno 11.1.3. Inicializar proceso COduende 11.2.FIN DE PROCESOS CONCURRENTES 12. FIN DE PROGRAMA PRINCIPAL 13. FIN 27
7. SEUDOCÓDIGO DEL PROBLEMA DE SANTA CLAUS CON MONITORES Monitor santaclausm; const TotalRenos=7; const NumDuendesGrupo=3; var numduende,numrenos,i:integer; santa,renos,duendes:condition; export santaclaus,reno,duende; procedimiento santaclaus; si (numrenos=totalrenos) entonces delay(santa); Santa va a repartir regalos numduende:=0; numrenos:=0; resume(renos); end caso contrario si (numduende=numduendesgrupo) entonces Duendes despiertan a santa para que les ayude con los regalos numduende:=0; resume(duendes); end procedimiento reno; 28
numrenos:=numrenos+1; {todos los renos listos?} Si ((numrenos mod TotalRenos)=0) entonces llega el ultimo reno y despierta a Santa delay(renos); resume(santa); end caso contrario renos llegando de vacaciones procedimiento duende; numduende:=numduende+1; si ((numduende mod NumDuendesGrupo)=0) entonces resume(santa); numrenos:=0; numduende:=0; Para utilizar este monitor, los 3 procesos activos deberán invocar a los procedimientos exportados de la siguiente forma: santaclausm.santaclaus; santaclausm.reno; santaclausm.duende; 29
8. DIAGRAMA DE FLUJO DEL PROBLEMA DE SANTA CLAUS CON MONITORES 30
31
32
9. CÓDIGO FUENTE CON MONITORES: program santaclauss; monitor santaclausm; export santaclaus,reno,duende; const TotalRenos=7; const NumDuendesGrupo=3; var numduende,numrenos,i:integer; santa,renos,duendes:condition; procedure santaclaus; if (numrenos=totalrenos) then end else delay(santa); {notificar a los renos} writeln('santa salio a repartir regalos'); writeln(' '); {delay(santa);} numduende:=0; numrenos:=0; resume(renos); if (numduende=numduendesgrupo) then {notificar a los duendes} 33
ayuda...'); end writeln('duendes despiertan a Santa para pedir numduende:=0; resume(duendes); procedure reno; numrenos:=numrenos+1; {todos los renos listos?} if ((numrenos mod TotalRenos)=0) then writeln('reno ',numrenos,' llega de vacaciones y despierta a Santa Claus...'); {numrenos:=0;} delay(renos); resume(santa); end else writeln('reno ',numrenos,' llega de vacaciones...'); {esperar las notificaciones de Santa} procedure duende; numduende:=numduende+1; 34
{esta completo el grupo de duendes?} if ((numduende mod NumDuendesGrupo)=0) then {delay(duendes); numduende:=0;} resume(santa); numrenos:=0; numduende:=0; process COsanta; repeat santaclausm.santaclaus; forever process COreno; repeat santaclausm.reno; forever process COduende; repeat santaclausm.duende; forever 35
end. co COsanta; COreno; COduende; co 10. APLICACIÓN REAL En una fábrica de automotriz de gran escala, se produce autos y cada uno de ellos tiene que pasar por 7 procesos, una vez culminado el séptimo proceso el vehículo está listo para salir de la fábrica y ser exportador. Pero algunos de los proceso, los inspectores pueden encontrar algunos defectos que tienen que ser solucionados, como no se puede solucionar un defecto cada vez que aparece, la empresa toma una política de que en cada 3 defectos encontrados se realizaran las correcciones así no afectaran el tiempo de producción. Para encontrar solución a este problema se utilizara la solución aplicada al problema de Santa Claus con las siguientes consideraciones a tomar en cuenta. El procesos auto solo culminara si se han pasado por los siete procesos, las reparaciones en el proceso de producción se solucionaran en cualquier instancia del proceso en que se encuentre el auto. 36
El código fuente en Pascal FC es: program ProduccionAutos; monitor santaclausm; export santaclaus,reno,duende; const TotalRenos=7; const NumDuendesGrupo=3; var numduende,numrenos,i:integer; santa,renos,duendes:condition; procedure santaclaus; if (numrenos=totalrenos) then delay(santa); writeln('auto sale para ser exportado'); writeln(' '); numduende:=0; numrenos:=0; resume(renos); end else if (numduende=numduendesgrupo) then writeln('solucionar errores encontrados por inspectores...'); numduende:=0; resume(duendes); end procedure reno; 37
numrenos:=numrenos+1; if ((numrenos mod TotalRenos)=0) then writeln('termina proceso ',numrenos,' y esta listo para salir de fábrica...'); delay(renos); resume(santa); end else writeln('termina proceso ',numrenos ); procedure duende; numduende:=numduende+1; if ((numduende mod NumDuendesGrupo)=0) then resume(santa); numrenos:=0; numduende:=0; process COautomovil; repeat santaclausm.santaclaus; forever process COproceso; repeat santaclausm.reno; forever 38
process COinspector; repeat santaclausm.duende; forever co COautomovil; COproceso; COinspector; co end. 10.1. Análisis de resultados Captura de pantalla de resultados obtenidos. 39
Figura 5. Resultados obtenidos al ejecutar el código fuente. Como se muestra, el auto pasa necesariamente por 7 procesos antes de salir de la fábrica y ser exportado. Y también al momento de hacer las correcciones de los tres errores encontrados por los inspectores se da el cualquier proceso en que se encuentre el vehículo, estos resultados se deben gracias a la sincronización entre los procesos. También se comprueba que estos proceso se pueden ejecutar indeterminadas veces sin dar lugar a un problema de interbloqueo. 40
11. CONCLUSIONES Se solucionaron los problemas de exclusión mutua y condición de sincronización correctamente en el problema de Santa Claus con monitores y con semáforos. Un proceso sólo puede acceder a las variables del monitor usando los procedimientos exportados por el monitor. La exclusión mutua en el acceso a los procedimientos del monitor está garantizada por el hecho de que el monitor se construye de tal forma que la ejecución de los procedimientos del mismo monitor no se solapa. Los monitores nos permiten desarrollar de forma casi independiente los distintos procesos 12. BIBLIOGRAFÍA THOMSON; Programación Concurrente/José Tomas Palma Méndez/Mª del Carmen Garrido Carrera/Fernando Sánchez Figueroa/Alexis Quesada Arencibia/ 1ª edición. OPENLIBRA; Programación Concurrente/Josep Jorba Estebe & Roma Suppi Boldrito. http://www.esi.uclm.es/www/dvallejo/pctr/libro/pctr2012.pdf 41
42