Algoritmo de Dekker
ALGORITMO DE DEKKER
El algoritmo de Dekker (alternancia estricta): es un algoritmo de programacin concurrente para exclusin mutua, que permite a dos procesos o hilos de ejecucin compartir un recurso sin conflictos. Fue uno de los primeros algoritmos de exclusin mutua inventados, implementado por Edsger Dijkstra. Si ambos procesos intentan acceder a la seccin crtica simultneamente, el algoritmo elige un proceso segn una variable turno. Si el otro proceso est ejecutando en su seccin crtica, deber esperar su finalizacin. Idea de partida: No se puede acceder simultneamente (desde varios procesadores) a ninguna localidad de memoria.
Espera activa: Se utiliza una variable global turno para controlar la entrada en la seccin crtica. Cualquier proceso que desee entrar en su seccin crtica comprobar primero el valor de la variable turno: Mientras sea distinto al de su identificador de proceso debe esperar. Cuando coincida entrar en la seccin crtica. Cuando un proceso sale de la seccin crtica, actualiza turno con el cdigo de otro proceso en espera.
Diseados para poder pasar el control de ejecucin entre ellos, no es una tcnica apropiada para dar soporte al procesamiento concurrente. Cuando hay diferencias grandes de velocidad es el proceso ms lento el que marca el ritmo.
Proceso 0 ...... /*esperar*/ while(seal[1]); seal[0] = cierto; /*seccin crtica*/ ... seal[0] = falso;
Proceso 1
Se solucionan los problemas anteriores, sin embargo, ahora surgen otros nuevos: Si uno de los procesos falla dentro de su seccin crtica el otro quedar bloqueado permanentemente.
No se garantiza la Exclusin Mutua como vemos en la secuencia: 1. P0 ejecuta el while y encuentra seal[1] a falso. 2. P1 ejecuta el whiley encuentra seal[0] a falso. 3. P0 pone seal[0] a cierto y entra en su seccin crtica. 4. P1 pone seal[1] a cierto y entra en su seccin crtica.
Ambos procesos estn en su seccin crtica, esto se debe a que esta solucin no es independiente de la velocidad de ejecucin relativa de los procesos.
Proceso 0 ... seal[0] = cierto; /*esperar*/ while(seal[1]); /*seccin crtica*/ ...... seal[0] = falso; ......
seal[1] = falso;
Una vez que un proceso ha puesto su seal en cierto, el otro no puede entrar a su seccin crtica hasta que el primero salga de ella. Se garantiza la EM, sin embargo, se generar interbloqueo si ambos procesos ponen su seal a cierto antes de ambos hayan ejecutado el while. Adems, si un proceso falla en su seccin crtica, el otro queda bloqueado permanentemente.
Proceso 0 ... seal[0] = cierto; /*esperar*/ while(seal[1]){ seal[0]=falso; /*retardo*/ seal[0]=cierto; } /*seccin crtica*/ ... seal[0] = falso; ...
Proceso 1 ... seal[1]=cierto; /*esperar*/ while(seal[0]){ seal[1]=falso; /*retardo*/ seal[1]=cierto; } /*seccin crtica*/ ... seal[1] = falso; ...
Esta solucin garantiza la EM y practicamente evita el IB, aunque podra darse la secuencia:
P0 pone seal[0] a cierto. P1 pone seal[1] a cierto. P0 comprueba seal[1]. P1 comprueba seal[0]. P0 pone seal[0] a falso. P1 pone seal[1] a falso. P0 pone seal[0] a cierto. P1 pone seal[1] a cierto.
Combinacin entre: Primer intento, donde se usa la variable turno (ahora usamos turno para indicar quien tiene prioridad para entrar a su seccin crtica). Cuarto intento.
Algoritmo de Dekker (Solucin Final): Proceso 0 ...... seal[0] = cierto; while(seal[1]) if(turno==1){ seal[0]=falso; while(turno==1); /*esperar*/ seal[0]=cierto; } /*seccin crtica*/ turno=1; seal[0] = falso; ... seal[1]=cierto; while(seal[0]) if(turno==0){ seal[1]=falso; while(turno==0); /*esperar*/ seal[1]=cierto; } /*seccin crtica*/ turno=0; seal[1] = falso; ... Proceso 1
El algoritmo de Peterson es un algoritmo de programacin concurrente para exclusin mutua, que permite a dos o ms procesos o hilos de ejecucin compartir un recurso sin conflictos, utilizando slo memoria compartida para la comunicacin. Peterson desarroll el primer algoritmo (1981) para dos procesos que fue una simplificacin del algoritmo de Dekker para dos procesos. Posteriormente este algoritmo fue generalizado para N procesos.
Ms simple que el de Dekker, garantiza la exclusin mutua: Cada proceso tiene un turno para entrar en la seccin crtica. Si un proceso desea entrar en la seccin crtica, debe activar su seal 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 seal y el turno del otro proceso estn activadas. El proceso que est esperando entrar en su seccin crtica cuando la seal o el turno del otro se desactiven. Una solucin posible es la proporcionada por Peterson (1981). En esta solucin se introduce una variable adicional, que denominaremos turno, que solamente resultar til cuando se produzca un problema de peticin simultnea de acceso a la regin crtica. Si slo uno de los procesos intenta acceder a la seccin crtica lo podr hacer sin ningn problema. Sin embargo, si ambos intentan entrar a la vez el valor de turno se pondr a 1 y 2 pero slo un valor de ellos permanecer al escribirse sobre el otro, permitiendo el acceso de un proceso a su regin crtica. El algoritmo permite resolver el problema de la exclusin mutua y garantiza que ambos procesos usarn de forma consecutiva el recurso en el caso de que lo soliciten a la vez y se impedir el cierre del otro proceso.
Exclusin mutua
Los algoritmos de exclusin mutua se usan en programacin concurrente para evitar el uso simultneo de recursos comunes, como variables globales, por fragmentos de cdigo conocidos como secciones crticas. La mayor parte de estos recursos son las seales, contadores, colas y otros datos que se emplean en la comunicacin entre el cdigo que se ejecuta cuando se da servicio a una interrupcin y el cdigo que se ejecuta el resto del tiempo. Se trata de un problema de vital importancia porque, si no se toman las precauciones debidas, una interrupcin puede ocurrir entre dos instrucciones cualesquiera del cdigo normal y esto puede provocar graves fallos. La tcnica que se emplea por lo comn para conseguir la exclusin mutua es inhabilitar las interrupciones durante el conjunto de instrucciones ms pequeo que impedir la corrupcin de la estructura compartida (la seccin crtica). Esto impide que el cdigo de la interrupcin se ejecute en mitad de la seccin crtica. En un sistema multiprocesador de memoria compartida, se usa la operacin indivisible test-and-set sobre una bandera, para esperar hasta que el otro procesador la despeje. La operacin test-and-set realiza ambas operaciones sin liberar el bus de memoria a otro procesador. As, cuando el cdigo deja la seccin crtica, se despeja la bandera. Esto se conoce como spin lock o espera activa. Algunos sistemas tienen instrucciones multioperacin 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 comnmente. La mayora de los mtodos de exclusin mutua clsicos 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 ms tiempo del que ahorran. A pesar de todo lo dicho, muchas tcnicas de exclusin mutua tienen efectos colaterales. Por ejemplo, los semforos permiten interbloqueos (deadlocks) en los que un proceso obtiene un semforo, otro proceso obtiene el semforo y ambos