El Problema de Santa Claus

(1)

UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN | FACULTAD DE INGENIERÍA ESCUELA ACADÉMICO PROFESIONAL DE INGENIERÍA EN INFORMÁTICA Y SISTEMAS CURSO: ALGORITMOS PARALELOS

AÑO DE ESTUDIOS: SEGUNDO

1

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

(2)

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

(3)

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

(4)

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

(5)

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

(6)

6 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

(7)

7 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 Figura 2: Santa se va a a Santa para que los ayude. 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.

(8)

8 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, notiﬁcar 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

(9)

9 ● SantaSem: Semáforo binario utilizado para despertar a Santa

Claus.

● RenosSem: Semáforo contador utilizado para notiﬁcar a los renos que van a emprender el viaje en trineo.

● DuendesSem: Semáforo contador utilizado para notiﬁcar 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.

(10)

10 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 notiﬁcació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 notiﬁcación de Santa.

(11)

11

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

(12)

12 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

(13)

13 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

(14)

14 10.8.FIN DE PROCESOS CONCURRENTES

11. FIN PROGRAMA PRINCIPAL 12. FIN.

(15)

15 DIAGRAMA DE FLUJO

3.2. Para un mejor entendimiento y seguimiento al problema de Santa Claus se desarrolló un diagrama de Flujo.

(16)

16 Figura 4. Diagrama de flujo del proceso SantaClaus.

(17)

17 Figura 5. Diagrama de flujo del proceso Reno.

(18)

18 Figura 6. Diagrama de flujo del proceso Duende.

(19)

19

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 begin repetir 1. wait(SantaSem) 2. wait(mutex) 3. si (renos=TotalRenos) entonces begin signal(RenosSem)

santa salio a repartir regalos signal(mutex)

end

4. Caso Contrario begin

si duendes = NumDuendesGrupo) entonces begin

Santa ayuda a los Duendes signal(DuendesSem) signal(mutex) end end Por siempre end

(20)

20 Proceso Reno; begin repetir 1. wait(mutex) 2. si (renos=TotalRenos-1) entonces begin renos:=renos+1 signal(SantaSem)

Último reno llegó de vacaciones y despertó a santa... signal(mutex) wait(RenosSem) renos:=0 end 3. else begin renos:=renos+1

un reno llegó de vacaciones signal(mutex) end por siempre end; Proceso Duende; begin repetir 1. wait(mutex)

2. si duendes = (NumDuendesGrupo-1) entonces begin

duendes:=duendes+1

tres duendes despiertan a santa solo a pedir ayuda signal(SantaSem)

signal(mutex) wait(DuendesSem) duendes:=0

(21)

21 3.caso contrario begin duendes:=duendes+1 signal(mutex) end; por siempre end;

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; begin repeat wait(SantaSem); wait(mutex); if (renos=TotalRenos) then begin signal(RenosSem);

writeln('santa salio a repartir regalos'); writeln(' ');

signal(mutex); end

(22)

22 begin

if (duendes = NumDuendesGrupo) then begin

writeln(' Santa ayuda a los Duendes...'); signal(DuendesSem); signal(mutex); end end; forever end; process Reno; begin repeat wait(mutex); if (renos=TotalRenos-1) then begin renos:=renos+1; signal(SantaSem);

writeln('reno ',renos,' llegó de vacaciones y despertó a santa...'); signal(mutex); wait(RenosSem); renos:=0; end else begin renos:=renos+1;

writeln('reno ',renos,' llegó de vacaciones'); signal(mutex);

end; forever end;

(23)

23 process Duende;

begin

repeat wait(mutex);

if ((duendes = NumDuendesGrupo-1)) then begin

duendes:=duendes+1;

writeln(' tres duendes despiertan a santa solo a pedir ayuda'); signal(SantaSem); signal(mutex); wait(DuendesSem); duendes:=0; end else begin duendes:=duendes+1; signal(mutex); end; forever end; begin duendes:=0; renos:=0; initial(mutex,1); initial(SantaSem,0); initial(RenosSem,0); initial(DuendesSem,0); cobegin SantaClaus; Reno; Duende; coend; end.

(24)

24 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

(25)

25 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

(26)

26 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

(27)

27 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

(28)

28

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; begin si (numRenos=TotalRenos) entonces begin delay(santa);

Santa va a repartir regalos… numDuende:=0; numRenos:=0; resume(renos); end caso contrario begin si (numDuende=NumDuendesGrupo) entonces begin

Duendes despiertan a santa para que les ayude con los regalos … numDuende:=0; resume(duendes); end end; end; procedimiento reno;

(29)

29 begin

numRenos:=numRenos+1; {todos los renos listos?}

Si ((numRenos mod TotalRenos)=0) entonces begin

llega el ultimo reno y despierta a Santa … delay(renos);

resume(santa); end

caso contrario

renos llegando de vacaciones …

end;

procedimiento duende; begin

numDuende:=numDuende+1;

si ((numDuende mod NumDuendesGrupo)=0) entonces begin resume(santa); end; end; begin numRenos:=0; numDuende:=0; end;

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;

(30)

30

8. DIAGRAMA DE FLUJO DEL PROBLEMA DE SANTA CLAUS CON

(31)

(32)

(33)

33

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; begin if (numRenos=TotalRenos) then begin delay(santa);

{notificar a los renos}

writeln('Santa salio a repartir regalos'); writeln(' '); {delay(santa);} numDuende:=0; numRenos:=0; resume(renos); end else begin if (numDuende=NumDuendesGrupo) then begin

(34)

34 writeln('Duendes despiertan a Santa para pedir

ayuda...'); numDuende:=0; resume(duendes); end end; end; procedure reno; begin numRenos:=numRenos+1; {todos los renos listos?}

if ((numRenos mod TotalRenos)=0) then begin

writeln('Reno ',numRenos,' llega de vacaciones y despierta a Santa Claus...'); {numRenos:=0;} delay(renos); resume(santa); end else begin

writeln('Reno ',numRenos,' llega de vacaciones...'); end;

{esperar las notificaciones de Santa} end;

procedure duende; begin

(35)

35 {esta completo el grupo de duendes?}

if ((numDuende mod NumDuendesGrupo)=0) then begin {delay(duendes); numDuende:=0;} resume(santa); end; end; begin numRenos:=0; numDuende:=0; end; process COsanta; begin repeat santaclausm.santaclaus; forever end; process COreno; begin repeat santaclausm.reno; forever end; process COduende; begin repeat santaclausm.duende; forever end;

(36)

36 begin cobegin COsanta; COreno; COduende; coend; end. 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.

(37)

37 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; begin if (numRenos=TotalRenos) then begin delay(santa);

writeln('AUTO sale para ser exportado'); writeln(' '); numDuende:=0; numRenos:=0; resume(renos); end else begin if (numDuende=NumDuendesGrupo) then begin

writeln('Solucionar errores encontrados por inspectores...'); numDuende:=0; resume(duendes); end end; end; procedure reno; begin

(38)

38 numRenos:=numRenos+1;

if ((numRenos mod TotalRenos)=0) then begin

writeln('Termina proceso ',numRenos,' y esta listo para salir de fábrica...');

delay(renos); resume(santa); end

else begin

writeln('Termina proceso ',numRenos ); end;

end;

procedure duende; begin

numDuende:=numDuende+1;

if ((numDuende mod NumDuendesGrupo)=0) then begin resume(santa); end; end; begin numRenos:=0; numDuende:=0; end; process COautomovil; begin repeat santaclausm.santaclaus; forever end; process COproceso; begin repeat santaclausm.reno; forever

(39)

39 end; process COinspector; begin repeat santaclausm.duende; forever end; begin cobegin COautomovil; COproceso; COinspector; coend; end. 10.1. Análisis de resultados

(40)

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

(41)

41

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.

(42)