El juego del laberinto concurrente se juega en un tablero rectangular de n filas y m columnas. En cada casilla puede haber una pared, un espacio vacío o un coco. El objetivo de cada coco es salir del laberinto. Cada casilla tiene como máximo ocho posiciones adyacentes (incluyo las diagonales). Un coco se va movio dentro del tablero, siempre que tenga alguna casilla adyacente libre, hasta que consigue llegar a una de las casillas del rectángulo más externo, que se consideran la salida del laberinto. El desplazamiento sólo es posible a una casilla vacía. Cada coco mantiene una lista de las casillas por las que ha pasado. La siguiente casilla para un coco se calcula de la siguiente manera: Se analizan las direcciones de desplazamiento en el orden de las agujas del reloj, empezando por la dirección arriba y a la izquierda. Si la posición actual es (x,y), entonces la primera dirección es la que lleva a (x-1, y-1), después, la de (x,y-1), a continuación la de (x+1,y-1) y así sucesivamente. La primera dirección que proporcione una casilla libre y que no haya sido visitada se utiliza para moverse. Si todas las casillas vecinas han sido visitadas, entonces se levanta esta restricción y el coco se mueve en la primera dirección, según el orden explicado, en la que haya una casilla libre. Si no se encuentra ninguna casilla libre adyacente, el proceso de evaluación de casillas vuelve a empezar. Las casillas adyacentes no pueden cambiar mientras dura el proceso de evaluación de la situación, pero otros cocos pueden examinar el contenido de esas mismas casillas. Evidentemente, dos cocos distintos no pueden moverse al mismo tiempo hacia la misma casilla. Se pide simular el juego del laberinto concurrente mediante un programa concurrente escrito en pseudocódigo utilizando semáforos. Utilizar un único tipo de proceso: coco. Para seguir la simulación, los cocos deben emitir unos mensajes por pantalla. Cada mensaje debe incluir el número de coco, la posición que ocupa y las posiciones de las casillas que ha visitado. Cada coco debe emitir un mensaje indicando en qué posición del tablero empieza. Esta posición inicial se debe elegir aleatoriamente entre las casillas vacías, o bien al iniciarse el proceso, o bien en el programa principal. También deben emitirse mensajes cada vez que un coco decida moverse, especificando de dónde a dónde se produce el movimiento. Los cocos también deben emitir un mensaje antes de salir del laberinto. La simulación debe contar con unas estructuras de datos que permitan resolver razonablemente el problema. Además, se prestará atención para evitar las situaciones de interbloqueo, inanición y espera activa. Se debe procurar el máximo nivel de concurrencia entre los procesos. Si se identifica un problema-tipo (productores/consumidores o lectores/escritores) debe mencionarse explícitamente (incluyo, en su caso, la prioridad más adecuada) antes de proceder con el pseudocódigo. Es muy importante que el comportamiento de los cocos se ajuste al enunciado, tanto en los aspectos específicamente concurrentes como en los demás. Es muy importante leer con atención el enunciado para responder adecuadamente a lo que se nos pide. En principio, la forma óptima de simular el comportamiento que nos piden depería principalmente de la proporción de paredes frente a casillas vacías y a la 1
proporción de número de cocos frente a número de casillas vacías. Un programa que fuera muy eficiente en un tablero con muchos cocos y pocas casillas libres, donde podría haber varios cocos mirando la misma casilla, no lo sería en otro contexto donde hubiera pocos cocos, y por tanto, pocas posibilidades de que dos cocos quisieran leer la misma casilla al mismo tiempo. Afortunadamente, no tenemos que darle muchas vueltas a esta cuestión: el enunciado nos dice que debe ser posible que varios cocos evalúen la misma casilla. Esto encaja a la perfección con uno de los dos problemas-tipo de la asignatura: lectores y escritores. El esquema de los lectores y escritores es, en la práctica, la única manera en la que varios procesos pueden leer un recurso concurrentemente. Siempre que no se trate de un recurso de sólo lectura, es decir, de un constante. Si es posible que los procesos puedan leer y puedan escribir en un recurso, entonces o bien se bloquea el recurso antes de acceder a el, o bien tenemos un esquema de lectores y escritores, en el que existen unos protocolos de entrada a la lectura y de entrada a la escritura que preparan el acceso al recurso. Un problema bastante frecuente es el de leer variables compartidas sin pedir exclusión mutua. Esto es un error porque como hemos señalado en el párrafo anterior, si hay un proceso que puede modificar la variable, no podremos saber que el valor que hemos leído es correcto, tampoco podremos saber si ha cambiado desde el momento de la lectura. Otra cuestión interesante es la de la granularidad. Una posibilidad, un tanto simplista, es considerar el tablero como un único recurso. Otra posibilidad que aumenta considerablemente la concurrencia es considerar que cada casilla es un recurso distinto. Lo bueno de este enfoque es que no es mucho más complicado. Se trata de aplicar el esquema lectores y escritores a cada casilla. En este caso, hemos elegido la prioridad para la escritura, con el fin de evitar la inanición, aunque también hay argumentos a favor de la prioridad para la lectura. program laberinto de cocos; const N = 10; M = 15; Ncocos = 10; // Arrays para calcular facilmente las casillas adyacentes vecinas_x = {-1,0,1,1,1,0,-1,-1}; vecinas_y = {-1, -1, -1, 0, 1, 1, 1, 0}; var mutex_mensaje : semaphore; // Las variables del modelo de lectores y escritores mutex, lector, escritor : array [1..N, 1..M] of semaphore; nl, nle, nee : array [1..N, 1..M] of integer; escribio : array[1..n, 1..M] of boolean; // Variables para indices de bucles; i,j : integer; // Para guardar las posiciones iniciales de los cocos, // no se usan fueran del programa principal coordenada_x, coordenada_y : array[1..ncocos] of integer; tablero : array[1..n][1..m] of { vacia, pared, uncoco } 2
procedure entrada_lectura(x,y : integer); // Si se está escribio o existen escritores en espera // el lector debe ser bloqueado if (escribio[x,y] or nee[x,y] > 0) then nle[x,y] := nle[x,y] + 1; wait(lector[x,y]) nle[x,y] := nle[x,y] - 1; nl[x,y] := nl[x,y] + 1; if (nle[x,y] > 0) then // Desbloqueo encadenado signal(lector[x,y]) signal(mutex[x,y]) ; // entrada_lectura procedure entrada_escritura(x,y : integer); // Si se está escribio o existen lectores el escritor // debe ser bloqueado if (nl[x,y] > 0 or escribio[x,y]) then nee[x,y] := nee[x,y]+ 1; wait(escritor[x,y]); nee[x,y] := nee[x,y]- 1; escribio[x,y] = true; signal(mutex[x,y]) ; // entrada_escritura procedure salida_lectura(x,y : integer); nl[x,y] := nl[x,y] - 1; // Desbloquear un escritor si es posible if (nl[x,y] = 0 and nee[x,y] > 0) then signal(escritor[x,y]); ;// salida_lectura procedure cierra_escritura(x,y : integer); escribio[x,y] = false; // Desbloquear un escritor que esté a la espera. // Si no, desbloquear un lector en espera if (nee[x,y] > 0) then signal(escritor[x,y]); if (nle[x,y] > 0) then signal(lector[x,y]); // cierra_escritura process type coco(id : integer, coor_x, coor_y : integer); var l,k : integer; // Variables para bucles // La tabla es para uso interno del proceso, //la lista es para imprimir las casillas por las que paso tabla_visitadas : array[1..n][1..m] of boolean; lista_visitadas : array[1..maxlon] of record x,y : integer ; lon_visitadas : integer; // Longitud de la lista de visitadas // En la primera vuelta de inspección de las casillas adyacentes importa // si las hemos visitado ya o no, en la segunda vuelta no importa_visitadas : boolean; salir_de_bucle : boolean; // Nos dice si ya nos hemos movido de casilla o no estoy_mirando_casilla_adyacente_numero : integer; coordenada_x, coordenada_y, candidata_x, candidata_y : integer; 3
procedure escribir_lista_visitadas; var k : integer; for k := 1 to lon_visitadas do write('(', lista_visitadas.x[k], ','. lista_visitadas.y[k], ') '); writeln; ; // escribir_lista_visitadas coordenada_x := coor_x; coordenada_y := coor_y; for l:= 1 to N do for k:= 1 to M do tabla_visitadas = false; lon_visitadas = 1; // Primer mensaje wait(mutex_mensaje); writeln( Hola, soy el coco número ',id, y he comenzado en la posición (',coordenada_x,,,coordenada_y, ) ); signal(mutex_mensaje); tabla_visitadas[coordenada_x, coordenada_y] := true; lista_visitadas[lon_visitadas].x := coordenada_x; lista_visitadas[lon_visitadas].y := coordenada_y; // Mientras no estemos en el rectángulo del borde, es decir, en posición de terminar... while coordenada_x > 1 and coordenada_x < N and coordenada_y > 1 and coordenada_y < M) importa_visitadas := true; salir_del_bucle := false; while not salir_del_bucle estoy_mirando_casilla_adyacente_numero := 1; while estoy_mirando_casilla_adyacente_numero < 9 and not salir_de_bucle candidata_x := coordenada_x + vecinas_x[estoy_mirando_casilla_adyacente_numero]; candidata_y := coordenada_y + vecinas_y[estoy_mirando_casilla_adyacente_numero]; if (importa_visitadas and tabla_visitadas[candidata_x][candidata_y] = false) or not importa_visitadas then // Miramos si la casilla candidata esta vacia entrada_lectura(candidata_x, candidata_y); if (tablero[candidata_x, candidata_y] = vacia) then salida_lectura(candidata_x, candidata_y); // Pedimos bloqueo de escritura sobre la candidata // y sobre la casilla actual entrada_escritura(candidata_x,candidata_y); 4
entrada_escritura(coordenada_x,coordenada_y); // Hay que darse cuenta de que despues de soltar el bloqueo // de lectura, otro coco puede haberse movido a la casilla, // por lo que nos toca comprobar si sigue vacía despues de // obtener el bloqueo de escritura. // Si la casilla candidata sigue vacia... if (tablero[candidata_x, candidata_y] = vacia) then tablero[candidata_x, candidata_y] := uncoco; tablero[coordenada_x, coordenada_y] := vacia; salida_escritura(coordenada_x, coordenada_y); salida_escritura(candidata_x, candidata_y); wait(mutex_mensaje); write( Soy el coco,id, y me muevo de la casilla (,coordenada_x,,, coordenada_y, ) hasta la (, candidata_x,,, candidata_y, ) y he pasado ya por: ); escribir_lista_visitadas; signal(mutex_mensaje); coordenada_x := candidata_x; coordenada_y := candidata_y; tablas_visitadas[coordenada_x, coordenada_y] := true; lon_visitadas := lon_visitadas + 1; lista_visitadas[lon_visitadas].x := coordenada_x; lista_visitadas[lon_visitadas].y := coordenada_y; salir_del_bucle := true; salida_escritura(coordenada_x, coordenada_y); salida_escritura(candidata_x, candidata_y); ; // if tablero[...] = vacia salida_lectura(candidata_x, candidata_y); // if (importa_visitadas...) estoy_mirando_casilla_adyacente_numero := estoy_mirando_casilla_adyacente_numero + 1; // while estoy_mirando_casilla_adyacente_numero if importa_visitadas = true then // Hemos terminado la primera vuelta de inspeccion // y seguimos sin casilla para mover importa_visitadas := false; // Hemos hecho las dos vueltas y no hemos encontrado nada salir_del_bucle := true; // while not salir_de_bucle; // while coordenada_x... wait(mutex_mensaje); writeln ( Soy el coco,id, como ya he llegado al borde del tablero me voy ); signal(mutex_mensaje); // process coco 5
var cocos : array[1..ncocos] of coco; // Programa principal for i:=1 to N do for j:=1 to M do tablero[i][j] := vacia; // Codigo para poner las paredes en su sitio... // Paredes colocadas init(mutex_mensaje, 1); // Ahora elegimos unas coordenadas iniciales para los cocos for i := 1 to Ncocos do repeat // Elegimos al azar dos numeros. La coordenada x entre 2 y N-1 y la y entre 2 y M - 1, // no queremos que la posición inicial esté en la zona de salida del tablero coordenada_x[i] = random (2..N-1); coordenada_y[i] = random(2..m-1); until tablero[coordenada_x[i]][coordenada_y[i]] = vacia; tablero[coordenada_x[i]][coordenada_y[i]] = uncoco; ; // Inicializamos las estructuras para los lectores y escritores for i:= 1 to N do for j:= 1 to M do init(mutex[i,j],1); init(escritor[i,j], 0); init(lector[i,j], 0); nl[i,j] = 0; nle[i,j] = 0; nee[i,j] = 0; escribio[i,j] = false; co for i := 1 to Ncocos do cocos[i] = coco(i, coordenada_x[i], coordenada_y[j]); co. 6