Curso: Sistemas Operativos

Algoritmo de Dekker

ALGORITMO DE DEKKER

El algoritmo de Dekker (alternancia estricta): es un algoritmo de programación concurrente para exclusión mutua, que permite a dos procesos o hilos de ejecución compartir un recurso sin conflictos. Fue uno de los primeros algoritmos de exclusión mutua inventados, implementado por Edsger Dijkstra.

Si ambos procesos intentan acceder a la sección crítica simultáneamente, el algoritmo elige un proceso según una variable turno. Si el otro proceso está ejecutando en su sección crítica, deberá esperar su finalización.

Idea de partida: No se puede acceder simultáneamente (desde varios procesadores) a ninguna localidad de memoria.

Espera activa:

•Se utiliza una variable global “turno” para controlar la entrada en la sección crítica.

•Cualquier proceso que desee entrar en su sección crítica comprobará primero el valor de la variable “turno”:

•Mientras sea distinto al de su identificador de proceso debe esperar.

•Cuando coincida entrará en la sección crítica.

•Cuando un proceso sale de la sección crítica, actualiza “turno “con el código de otro proceso en espera.

Curso: Sistemas Operativos

Algoritmo de Dekker (1er intento):

Proceso 0 Proceso 1

... ...

/*esperar*/ /*esperar*/

while(turno!=0); while (turno!=1);

/*sección crítica*/ /*sección crítica*/

... ...

turno=1; turno=0;

... ...

Diseñados para poder pasar el control de ejecución entre ellos, no es una técnica apropiada para dar soporte al procesamiento concurrente.

Cuando hay diferencias grandes de velocidad es el proceso más lento el que marca el ritmo.

Algoritmo de Dekker (2º intento):

Verifico la sección crítica del otro proceso y coloco una señal al entrar y salir en su sección crítica:

Proceso 0 Proceso 1

......

/*esperar*/ /*esperar*/

while(señal[1]); while(señal[0]);

señal[0] = cierto; señal[1]=cierto;

/*sección crítica*/ /*sección crítica*/

... ...

señal[0] = falso; señal[1] = falso;

Curso: Sistemas Operativos

... ...

Se solucionan los problemas anteriores, sin embargo, ahora surgen otros nuevos:

•Si uno de los procesos falla dentro de su sección crítica el otro quedará bloqueado permanentemente.

•No se garantiza la Exclusión Mutua como vemos en la secuencia:

•1. P0 ejecuta el while y encuentra señal[1] a falso.

•2. P1 ejecuta el whiley encuentra señal[0] a falso.

•3. P0 pone señal[0] a cierto y entra en su sección crítica.

•4. P1 pone señal[1] a cierto y entra en su sección crítica.

•Ambos procesos están en su sección crítica, esto se debe a que esta solución no es independiente de la velocidad de ejecución relativa de los procesos.

Algoritmo de Dekker (3° intento):

Proceso 0 Proceso 1

... ...

señal[0] = cierto; señal[1]=cierto;

/*esperar*/ /*esperar*/

while(señal[1]); while(señal[0]);

/*sección crítica*/ /*sección crítica*/

......

señal[0] = falso; señal[1] = falso;

......

Curso: Sistemas Operativos

Una vez que un proceso ha puesto su señal en cierto, el otro no puede entrar a su sección crítica hasta que el primero salga de ella.

Se garantiza la EM, sin embargo, se generará interbloqueo si ambos procesos ponen su señal a cierto antes de ambos hayan ejecutado el while. Además, si un proceso falla en su sección crítica, el otro queda bloqueado permanentemente.

Algoritmo de Dekker (4º intento):

El interbloqueo se había originado porque cada proceso establecía su señal sin conocer el estado del otro proceso. Para solucionarlo haremos que los procesos activen y desactiven su señal:

Proceso 0 Proceso 1

... ...

señal[0] = cierto; señal[1]=cierto;

/*esperar*/ /*esperar*/

while(señal[1]){ while(señal[0]){

señal[0]=falso; señal[1]=falso;

/*retardo*/ /*retardo*/

señal[0]=cierto; señal[1]=cierto;

} }

/*sección crítica*/ /*sección crítica*/

... ...

señal[0] = falso; señal[1] = falso;

... ...

Curso: Sistemas Operativos

Algoritmo de Dekker (4º intento):

Esta solución garantiza la EM y practicamente evita el IB, aunque podría darse la secuencia:

•P0 pone señal[0] a cierto.

•P1 pone señal[1] a cierto.

•P0 comprueba señal[1].

•P1 comprueba señal[0].

•P0 pone señal[0] a falso.

•P1 pone señal[1] a falso.

•P0 pone señal[0] a cierto.

•P1 pone señal[1] a cierto.

Esta situación de bloqueo puede prolongarse mucho tiempo.

Algoritmo de Dekker (solución final):

Combinación entre:

•Primer intento, donde se usa la variable turno (ahora usamos turno para indicar quien tiene prioridad para entrar a su sección crítica).

•Cuarto intento.

Curso: Sistemas Operativos

Funcionamiento:

•Cuando P0 quiere entrar en su sección crítica pone señal [0]=cierto; y comprueba la señal de P1.

•Si está a falso, entra inmediatamente.

•Si está a cierto, consulta turno:

•Si turno==0; sigue verificando la señal de P1.

•Si turno==1; desactiva su señal y espera hasta que turno==0;

Algoritmo de Dekker (Solución Final):

Proceso 0 Proceso 1

......

señal[0] = cierto; señal[1]=cierto;

while(señal[1]) while(señal[0])

if(turno==1){ if(turno==0){

señal[0]=falso; señal[1]=falso;

while(turno==1); while(turno==0);

/*esperar*/ /*esperar*/

señal[0]=cierto; señal[1]=cierto;

} }

/*sección crítica*/ /*sección crítica*/

turno=1; turno=0;

señal[0] = falso; señal[1] = falso;

... ...

ALGORITMO DE PETERSON

Curso: Sistemas Operativos

El algoritmo de Peterson es un algoritmo de programación concurrente para exclusión mutua, que permite a dos o más procesos o hilos de ejecución compartir un recurso sin conflictos, utilizando sólo memoria compartida para la comunicación.

Peterson desarrolló el primer algoritmo (1981) para dos procesos que fue una simplificación del algoritmo de Dekker para dos procesos. Posteriormente este algoritmo fue generalizado para N procesos.

Más simple que el de Dekker, garantiza la exclusión mutua:

•Cada proceso tiene un turno para entrar en la sección crítica.

•Si un proceso desea entrar en la sección crítica, debe activar su señal y puede que tenga que esperar a que llegue su turno.

Impide el interbloqueo ya que si un proceso se encuentra esperando en el “while”, entonces la señal y el turno del otro proceso están activadas. El proceso que está esperando entrará en su sección crítica cuando la señal o el turno del otro se desactiven.

Una solución posible es la proporcionada por Peterson (1981). En esta solución se introduce una variable adicional, que denominaremos turno, que solamente resultará útil cuando se produzca un problema de petición simultánea de acceso a la región crítica.

Si sólo uno de los procesos intenta acceder a la sección crítica lo podrá hacer sin ningún problema. Sin embargo, si ambos intentan entrar a la vez el valor de turno se pondrá a 1 y 2 pero sólo un valor de ellos permanecerá al escribirse sobre el otro, permitiendo el acceso de un proceso a su región crítica.

El algoritmo permite resolver el problema de la exclusión mutua y garantiza que ambos procesos usarán de forma consecutiva el recurso en el caso de que lo soliciten a la vez y se impedirá el cierre del otro proceso.

CONCLUSION:

Curso: Sistemas Operativos

En el algoritmo de Peterson se agrega una variable adicional la cual se le denomina turno, donde este tipo de variable solamente fuera útil cuando surgiera un problema en un determinado tipo de procesos, esto es cuando accede a la región crítica.

Exclusión mutua

Los algoritmos de exclusión mutua se usan en programación concurrente para evitar el uso simultáneo de recursos comunes, como variables globales, por fragmentos de código conocidos como secciones críticas.

La mayor parte de estos recursos son las señales, contadores, colas y otros datos que se emplean en la comunicación entre el código que se ejecuta cuando se da servicio a una interrupción y el código que se ejecuta el resto del tiempo. Se trata de un problema de vital importancia porque, si no se toman las precauciones debidas, una interrupción puede ocurrir entre dos instrucciones cualesquiera del código normal y esto puede provocar graves fallos.

La técnica que se emplea por lo común para conseguir la exclusión mutua es inhabilitar las interrupciones durante el conjunto de instrucciones más pequeño que impedirá la corrupción de la estructura compartida (la sección crítica). Esto impide que el código de la interrupción se ejecute en mitad de la sección crítica.

En un sistema multiprocesador de memoria compartida, se usa la operación indivisible test-and-set sobre una bandera, para esperar hasta que el otro procesador la despeje. La operación test-and-set realiza ambas operaciones sin liberar el bus de memoria a otro procesador. Así, cuando el código deja la sección crítica, se despeja la bandera. Esto se conoce como spin lock o espera activa.

Algunos sistemas tienen instrucciones multioperación indivisibles similares a las anteriormente descritas para manipular las listas enlazadas que se utilizan para las colas de eventos y otras estructuras de datos que los sistemas operativos usan comúnmente.

La mayoría de los métodos de exclusión mutua clásicos intentan reducir la latencia y espera activa mediante las colas y cambios de contexto. Algunos investigadores afirman que las pruebas indican que estos algoritmos especiales pierden más tiempo del que ahorran.

A pesar de todo lo dicho, muchas técnicas de exclusión mutua tienen efectos colaterales. Por ejemplo, los semáforos permiten interbloqueos (deadlocks) en los que un proceso obtiene un semáforo, otro proceso obtiene el semáforo y ambos se quedan a la espera de que el otro proceso libere el semáforo. Otros efectos

Curso: Sistemas Operativos

comunes incluyen la Inanición, en el cual un proceso esencial no se ejecuta durante el tiempo deseado, y la inversión de prioridades, en el que una tarea de prioridad elevada espera por otra tarea de menor prioridad, así como la latencia alta en la que la respuesta a las interrupciones no es inmediata.