Receta general para resolver problemas de sincronización con semáforos

Transcripción

1 Receta general para resolver problemas de sincronización con semáforos La primera vez que te enfrentas a la tarea de implementar una solución a un problema de sincronización entre procesos, es normal que te parezca algo inabordable y que no sepas por dónde empezar. Tal vez ya conoces y entiendes las soluciones a algunos problemas tipo, como el búfer cinito o los cilósofos, pero no sabes cómo aplicar estos algoritmos a nuevos problemas que aparentemente no tienen nada que ver con lo que has aprendido hasta ahora. Te invaden el desconcierto y la parálisis. Afortunadamente, existen técnicas sistemáticas (y simples) para construir algoritmos de sincronización entre procesos y que son útiles en una gran variedad de casos. En este artículo explicaremos una técnica que para resolver problemas de sincronización entre procesos utilizando semáforos. La técnica puede servir como receta general para abordar situaciones en las que hay necesidad de sincronizar procesos y no se tiene muy claro por dónde empezar. La técnica descrita también tiene sus limitaciones. Hay problemas socisticados que son dicíciles de modelar con ella. Por otro lado, no siempre da lugar a una solución eciciente. Pero al menos decine un camino seguro para elaborar soluciones sin necesidad de recurrir a la inspiración. Contenido 1 La receta: descripción teórica... 2 Patrones de código: bloqueo condicional y desbloqueo... 2 Los pasos de la receta La técnica en acción... 5 Paso 1. Esquema básico del algoritmo... 5 Paso 2. Localizar los puntos de bloqueo y las condiciones... 5 Paso 3. Escribir las condiciones de bloqueo de manera formal... 6 Paso 4. Localizar los puntos de desbloqueo... 6 Paso 5. Aplicar los patrones de código... 7 Paso 6. Optimizar el código Cerrojos y variables condición Versión simplicicada: cola de espera única Conclusión J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 1

2 1 La receta: descripción teórica La receta se basa en reducir todos los problemas de sincronización a dos clases: accesos a datos compartidos y esperas condicionales. Los primeros los resolveremos con un semáforo de tipo mutex, que es un semáforo inicializado a uno. Las esperas condicionales las trataremos mediante semáforos de tipo cola de espera, que son semáforos inicializados a cero y se usarán para bloquear a los procesos que deben esperar a que se cumpla una condición lógica. Para solucionar un problema genérico de sincronización, nos bastará con decinir un solo semáforo de tipo mutex. Por cada situación de bloqueo que identiciquemos, normalmente declararemos un semáforo de tipo cola de espera, aunque si no nos queremos complicar, podemos utilizar una sola cola de espera para todo el sistema: es menos eciciente, pero funciona. Nuestra receta consiste en analizar el algoritmo que queremos sincronizar y localizar en él todos los puntos donde se pueden producir bloqueos. Cada uno de los bloqueos estará condicionado a que se cumpla una expresión lógica (booleana), que tendremos que averiguar. Una vez decinidas esas condiciones, se aplicarán unas plantillas de código universales que resuelven los bloqueos y desbloqueos. Patrones de código: bloqueo condicional y desbloqueo Para implementar un bloqueo, se utilizarán siempre los mismos patrones de código, que están basados en operar con una cola de espera de procesos. El punto de partida es que hemos identicicado puntos de bloqueo dentro del código, vinculados al cumplimiento de condiciones lógicas. El código alrededor de esos puntos de bloqueo tiene que tener esta estructura:... bloquearse mientras se cumpla COND... código que sólo se puede ejecutar si no se cumple COND Un ejemplo puede ser lo que le ocurre a un cilósofo en el problema la cena de los cilósofos:... bloquearse mientras el palillo(i) y el palillo(i+1) estén ocupados... tomar el palillo(i) y el palillo(i+1)... comer O al productor en el problema del búfer cinito:... bloquearse mientras el búfer está lleno... insertar un elemento en el búfer Cada situación de bloqueo (en los ejemplos, el código que empieza por «bloquearse mientras...») estará asociada con una cola de espera, que a su vez se implementará mediante dos objetos: un semáforo inicializado a cero y una variable entera. El semáforo se usará para bloquear a los procesos que deban mantenerse en espera, y la variable entera llevará la cuenta de cuántos procesos esperan en cada momento. En todos los problemas de sincronización que resolveremos con esta receta, existirán datos compartidos: como mínimo, los contadores enteros relacionados con las colas de espera. Para regular el acceso a los datos compartidos siempre habrá que declarar un semáforo de tipo mutex. Hay que utilizar el mutex para envolver TODOS los usos de variables compartidas en el código J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 2

3 Los patrones de código que resuelven los bloqueos y desbloqueos son exactamente tres: bloqueo de un proceso desbloqueo de un proceso desbloqueo de todos los procesos que están en cola En los siguientes apartados describimos esos tres patrones. Variables compar=das Esta receta se basa en dos semáforos y una variable entera. Semáforo mutex = 1; Semáforo colacond = 0; int contadorcond = 0; La variable contadorcond contendrá en todo momento el número de procesos que están bloqueados en el semáforo colacond. Código de bloqueo Este código se debe escribir en cada punto donde detectemos que debe existir un bloqueo condicional. El código debe insertarse justo antes del código original que sólo puede ejecutarse cuando se cumpla la condición lógica del bloqueo. // esperar hasta que se cumpla una condición lógica «COND» while ( COND ) { contadorcond++; // registra que hay alguien en espera V (mutex); // libera el mutex para no provocar interbloqueos P (colacond); // bloquea al proceso P (mutex); // vuelve a adquirir el mutex para reevaluar COND // Colocar aquí el código que toque variables de estado. // Este código se ejecuta en exclusión mutua (mutex está adquirido). Código para desbloquear a un solo proceso Este código se escribirá cuando en nuestro programa debe desbloquearse a uno solo de los procesos que están en espera. // desbloquear UN SOLO proceso if ( contadorcond > 0 ) { // hay alguien esperando? contadorcond- - ; // entonces, anota que hay uno menos V ( colacond ); // y desbloquéalo Justo después de la operación P(mutex) podría haber otras instrucciones, por ejemplo para J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 3

4 actualizar variables de estado. Esto dependerá de cada sistema que estemos desarrollando. Código para desbloquear a todos los procesos A veces nos interesará desbloquear a todos los procesos que se encuentran en la cola. El único cambio sobre el algoritmo anterior es sustituir el if del desbloqueo por un bucle while. El número de iteraciones viene determinado por la variable contadorcond, que contiene el número de procesos que actualmente están en cola. // desbloquear a todos los procesos while ( contadorcond > 0 ) { contadorcond- - ; V ( colacond ); Los pasos de la receta Estos son los pasos que hay que seguir para resolver el problema de sincronización. 1. Escribir el esquema básico del algoritmo, sin instrucciones de sincronización. 2. Localizar los puntos de bloqueo: marcar las zonas del algoritmo donde los procesos se pueden bloquear y escribir las condiciones de bloqueo en lenguaje natural. 3. Formalizar las condiciones de bloqueo: reescribirlas usando variables, expresiones booleanas, etc. «variables de estado» 4. Localizar los puntos de desbloqueo: marcarlos en el código y distinguir si se desbloquea a un solo proceso o a todos los procesos que esperan. 5. Sustituir los bloqueos y desbloqueos por plantillas de código universales, siguiendo estas reglas: a) Cada situación de bloqueo y desbloqueo se resuelve con operaciones P y V de un semáforo «cola de espera», inicializado a cero. b) Usamos las variables contadoras para saber cuántos procesos hay esperando en cada cola. c) Usamos un mutex (un semáforo inicializado a uno) para proteger las zonas de código donde están las sincronizaciones y los accesos a variables compartidas, incluyendo las variables de estado. 6. Optimizar el código resultante, si se desea J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 4

5 2 La técnica en acción Ahora que se ha presentado la receta, la aplicaremos a un ejemplo simple y conocido: el primer problema de los lectores y escritores. Recordemos que en este problema hay dos tipos de procesos que acceden a una base de datos: lectores y escritores. Se debe permitir el acceso concurrente de los lectores; y mientras un proceso escritor está accediendo a la base de datos, no puede haber ningún otro proceso (ni escritor ni lector). En el llamado «primer problema», los lectores tienen preferencia sobre los escritores. Vamos a aplicar los pasos de la receta a este problema y ver cómo evoluciona el programa que vamos escribiendo. Paso 1. Esquema básico del algoritmo Este paso es el más importante: si no modelamos correctamente el sistema, el resto del trabajo será inútil. En nuestro ejemplo, tenemos dos algoritmos: el del proceso lector, y el del escritor. // Proceso lector Lector() {... leer de la base de datos... // Proceso escritor Escritor() {... escribir en la base de datos... No ha sido muy complicado... Paso 2. Localizar los puntos de bloqueo y las condiciones Ahora tenemos que ubicar las zonas del código donde los lectores y escritores deberían bloquearse y escribir las condiciones de bloqueo, en lenguaje natural: // Proceso lector Lector() { bloquearse si hay algún escritor trabajando... leer de la base de datos... // Proceso escritor Escritor() { bloquearse si hay otro proceso trabajando (lector o escritor)... escribir en la base de datos J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 5

6 Paso 3. Escribir las condiciones de bloqueo de manera formal Escribir las condiciones de bloqueo ha sido fácil, porque lo hemos hecho en lenguaje natural. El siguiente paso es delicado, porque hay que reescribir estas condiciones de manera que lo pueda entender un compilador. Por tanto, tendremos que crear variables de estado que nos permitan conocer si hay lectores o escritores trabajando. No sólo se trata de reescribir las condiciones, sino también de escribir el código necesario para que las variables de estado se mantengan siempre con un valor correcto. En nuestro ejemplo, crearemos dos variables nlectores y nescritores que mantendrán la cantidad de procesos lectores y escritores que están operando con la base de datos. // Variables de estado int nlectores = 0; int nescritores = 0; // Proceso lector Lector() { // bloquearse si hay algún escritor trabajando bloquearse si: nescritores > 0 nlectores++;... leer de la base de datos nlectores- - ; // Proceso escritor Escritor() { // bloquearse si hay otro proceso trabajando (lector o escritor) bloquearse si: nlectores>0 or nescritores>0 nescritores++;... escribir en la base de datos nescritores- - ; Paso 4. Localizar los puntos de desbloqueo Ahora ya podemos identicicar los puntos en el código en los que deberían ir los desbloqueos. Cómo localizamos estos puntos? Tenemos que ver dónde cambian las variables de estado y en qué puntos podrían cambiar de manera que varíen las condiciones de bloqueo que mantienen detenidos a otros procesos. Es importante marcar si el desbloqueo se hace sobre un solo proceso en espera, o bien hay que desbloquear a todos los procesos. Si no tenemos claro cuál es el caso, optaremos por desbloquearlos a todos: la solución será menos eciciente, pero por lo menos será correcta. En nuestro caso, podemos observar que hay dos puntos de desbloqueo: cuando un lector cinaliza (podría desbloquearse un escritor) y cuando un escritor cinaliza (podrían desbloquearse todos los lectores en espera, o bien un escritor) J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 6

7 El segundo punto de desbloqueo es interesante, porque puede dar lugar a dos clases de desbloqueos (a los lectores o al escritor). Hay que anotar esos dos posibles desbloqueos, porque cada uno generará código diferente. Marcaremos los puntos de desbloqueo en el código de esta forma: // Variables de estado int nlectores = 0; int nescritores = 0; // Proceso lector Lector() { // bloquearse si hay algún escritor trabajando bloquearse si: nescritores > 0 nlectores++;... leer de la base de datos nlectores- - ; si nlectores == 0 desbloquear a un escritor // Proceso escritor Escritor() { // bloquearse si hay otro proceso trabajando (lector o escritor) bloquearse si: nlectores>0 or nescritores>0 nescritores++;... escribir en la base de datos nescritores- - ; si hay lectores esperando desbloquear a todos los lectores si no hay lectores y hay escritores esperando desbloquear a un escritor No hay que preocuparse mucho por decinir las condiciones que preceden a los desbloqueos. Si no se tiene muy claro cuáles pueden ser esas condiciones, se puede indicar que el desbloqueo ocurra siempre. En ese caso el algoritmo seguirá siendo correcto, aunque algo menos eciciente, ya que se harán desbloqueos de más. En caso de duda, mejor forzar al desbloqueo siempre. Paso 5. Aplicar los patrones de código En este punto se acabó la parte creativa de la receta. Todo lo que viene a continuación es pura rutina. De hecho, el código que vamos a escribir se podría generar automáticamente. Hay que transformar las acciones de bloqueo en operaciones P de semáforos utilizados como colas de espera. Por cada condición de bloqueo, crearemos un semáforo inicializado a cero y un contador. En cada situación de bloqueo insertaremos la plantilla genérica de código de bloqueo. Las acciones de desbloqueo se transformarán en operaciones V en esas colas de espera. Todo ello, siguiendo los patrones de código presentados anteriormente J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 7

8 Siguiendo las reglas generales, para nuestro ejemplo tenemos que crear estos objetos: Un mutex, que siempre es necesario. Dos colas de espera, una para gestionar el bloqueo de los lectores ( colalectores) y otra para gestionar el bloqueo de los escritores (colaescritores). Dos contadores enteros, uno para cada cola. También es importante colocar el código que actualiza las variables de estado dentro de la protección del mutex. En nuestro caso, se trata de la manipulación de las variables nlectores y nescritores. Código de inicialización // Variables de estado int nlectores = 0; int nescritores = 0; // Control de la exclusión mutua Semáforo mutex = 1; // Cola de espera de los lectores Semáforo colalectores = 0; int contadorlectores = 0; // Cola de espera de los escritores Semáforo colaescritores = 0; int contadorescritores = 0; Proceso lector Lector() { // bloquearse si hay algún escritor trabajando // bloquearse si: nescritores > 0 while ( nescritores > 0 ) { contadorlectores++; P ( colalectores ); nlectores++;... leer de la base de datos... // actualización de variables de estado y desbloqueo J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 8

9 nlectores- - ; if ( nlectores == 0 ) { if ( contadorescritores > 0 ) { contadorescritores- - ; V ( colaescritores ); Proceso escritor Escritor() { // bloquearse si hay otro proceso trabajando (lector o escritor) // bloquearse si: nlectores>0 or nescritores>0 while ( nlectores>0 or nescritores > 0 ) { contadorescritores++; P ( colaescritores ); nescritores++;... escribir en la base de datos... // actualización de variables de estado y desbloqueo nescritores- - ; if ( contadorlectores > 0 ) { // desbloqueamos a todos los lectores while ( contadorlectores > 0 ) { contadorlectores- - ; V ( colalectores ); else { // desbloqueamos a un escritor if ( contadorescritores > 0 ) { contadorescritores- - ; V ( colaescritores ); J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 9

10 Paso 6. Op:mizar el código El algoritmo anterior ya es una solución correcta al problema de los lectores y escritores. No obstante, se puede mejorar de muchas formas. Por ejemplo, la variable nescritores podría ser un booleano. 3 Cerrojos y variables condición Los patrones de código aquí presentados son tan rutinarios que se pueden encapsular en un tipo abstracto de datos que ofrezca unas operaciones de alto nivel de «bloquear» y «desbloquear». De hecho, muchos lenguajes y frameworks de programación concurrente ofrecen estos servicios. Por ejemplo, la biblioteca pthreads ofrece los llamados cerrojos (mutex) y variables condición. Los cerrojos tienen sendas operaciones de bloqueo y desbloqueo (lock/unlock) y equivalen al semáforo mutex de nuestra receta. Una variable condición equivale al conjunto de semáforo+contador utilizado en la receta para mantener una cola de espera. Normalmente ofrece tres operaciones: bloqueo, desbloqueo a un proceso y desbloqueo a toda la cola (wait/signal/broadcast). En el caso del lenguaje Java, los objetos pueden invocar a varias operaciones similares: una operación de bloqueo en cola (wait), una operación de desbloqueo individual (notify) y una operación de desbloqueo general a todos los hilos en espera (notifyall). Cada objeto en Java tiene su propio cerrojo o mutex, que se adquiere y libera cuando se invoca a un método de forma exclusiva (los métodos se pueden declarar como de acceso exclusivo utilizando la palabra reservada synchronized). 4 Versión simplificada: cola de espera única La receta aquí descrita utiliza una cola por cada bloqueo encontrado en el código. En realidad, el problema se puede resolver con una sola cola para todos los procesos. En algunos algoritmos esto podría llegar a ser bastante ineciciente, pero por lo menos funciona. La receta para la cola única es más sencilla: todos los bloqueos van al mismo semáforo cola y en todos los puntos de desbloqueo se deben reactivar todos los procesos de la cola. A continuación mostramos el código de los lectores y escritores que hace uso de una cola única. Como el código de bloqueo y desbloqueo ahora es único para todas las situaciones, se ha empaquetado en sendas funciones bloqueo() y desbloqueogeneral(). Estas funciones serían los equivalentes de las operaciones wait() y broadcast() de las variables condición, o las operaciones wait() y notifyall() de Java. Puede apreciarse que el código queda mucho más compacto que el que obtuvimos en el apartado anterior, aunque se paga el precio de más desbloqueos innecesarios. Por ejemplo, cuando un escritor termina, se desbloquea a todos los procesos, tanto lectores como escritores, a pesar de que sólo un tipo de procesos puede proseguir. Código de inicialización // Variables de estado int nlectores = 0; int nescritores = 0; J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 10

11 Control de bloqueos y desbloqueos (cola única) // Variables globales Semáforo mutex = 1; Semáforo cola = 0; int procesosencola = 0; // Rutinas de bloqueo y desbloqueo void bloqueo() { procesosencola++; V(mutex); P(cola); P(mutex); void desbloqueogeneral() { while ( procesosencola > 0 ) { procesosencola- - ; V (cola); Proceso lector Lector() { // bloquearse si hay algún escritor trabajando while ( nescritores > 0 ) { bloqueo(); nlectores++;... leer de la base de datos... // actualización de variables de estado y desbloqueo general nlectores- - ; desbloqueogeneral(); J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 11

12 Proceso escritor Escritor() { // bloquearse si hay otro proceso trabajando (lector o escritor) while ( nlectores>0 or nescritores > 0 ) { bloqueo(); nescritores++;... escribir en la base de datos... // actualización de variables de estado y desbloqueo general nescritores- - ; desbloqueogeneral(); 5 Conclusión Hemos presentado una técnica general para resolver problemas de sincronización a través de semáforos. La técnica no garantiza una solución óptima, pero sí da la seguridad de que el código es correcto y que el procedimiento de resolución siempre es el mismo, sin necesidad de requerir ingenio, creatividad o inspiración. La estrategia más simple requiere sólo tres variables globales: un mutex, una cola y un contador de esperas. Es la recomendable cuando lo que se quiere es obtener una solución correcta sin que preocupe la eciciencia. Esta técnica general es la que ha dado lugar a la creación de herramientas de programación concurrente presentes en los actuales entornos de programación. La técnica nos puede servir para aplicarla en cualquiera de esos entornos (pthreads, Java, etc.) J.M. Santos Espino, A. Quesada, E. Rodríguez, F. Santana 12