Semaforos

UNIVERSIDAD AUTÓNOMA DE CHIAPAS

FACULTAD DE CONTADURÍA PÚBLICA

CAMPUS IV

DOCENTE: MTRA: VANESSA BENAVIDES GARCIA

ASIGNATURA: SISTEMAS OPERATIVOS

PRESENTA: GISELLE ENEDINA AVENDAÑO BARRERA

LIC. SISTEMAS COMPUTACIONALES

6° SEMESTRE GRUPO: “D”

FECHA: 02 DE ABRIL DEL 2014

Introducción

Nunca dos procesos pueden encontrarse simultáneamente dentro de sus secciones críticas. No se hacen suposiciones acerca de las velocidades relativas de los procesos o del número de CPU. Ningún proceso suspendido fuera de su sección crítica debe bloquear a otros procesos. Nunca un proceso debe querer entrar en forma arbitraria en su sección crítica. En estos casos es donde la investigación que se realizo es para aportar conocimientos y verificar que hacer en estos casos.

Desactivación de Interrupciones

La solución más para lograr exclusión mutua, consiste en hacer que cada proceso desactive todas las interrupciones justo después de entrar en su sección crítica y las vuelva a activar antes de salir de ella. Con las interrupciones imposibilitadas, no pueden ocurrir interrupciones al reloj. (La CPU sólo cambia de un proceso a otro como resultado de interrupción de reloj u otras y con las interrupciones desactivadas la CPU no se cambiará a otro proceso).

Solución de Peterson

Al combinar la idea de los turnos, con la de las variables de cierre y de advertencia, T. Dekker (Matemático Alemán) fue el primero en crear una solución por medio del software al problema de la exclusión mutua que no requiere alternación estricta. Esta solución fue muy complicada por lo que Peterson descubrió una manera mucho más simple de lograr exclusión mutua.

Código de la Solución de Peterson para lograr exclusión mutua.

#define FALSE 0

#define TRUE 1

#define N 2 /* Número de proceso */

int turno; /* A Quién le toca ? */

int interes[N]; /* Todos los valores son inicialmente FALSE*/

ingresar_region(proceso)

int proceso; /* Número del proceso */

{

int otro; /* Número de otro proceso */

otro = 1 – proceso; /* El opuesto del proceso */

interes[proceso] = TRUE; /* interés por ingresar a la sección crítica */

turno = proceso; /* Colocar señal */

while ((turno == proceso) && (interes[otro] == TRUE)); /* Posición nula */

}

salir_region(proceso)

int proceso; /* Proceso que sale de la sección crítica */

{

interested[proceso] = FALSE; /* Indica la Salida de la sección crítica */

}

Variables de cierre

Otra forma de crear exclusión mutua es a través de las variables de cierre. Considérese que se tiene una sola variable de cierre compartida que inicialmente vale 0. Cuando un proceso desea entrar en su sección critica, éste primero prueba el cerrojo. Si el cerrojo es 0, el proceso lo hace igual a 1 y entra en su región crítica. Si el cerrojo ya vale 1, el proceso simplemente espera hasta que se vuelva 0. Por lo tanto 0 significa que no hay ningún proceso en su sección crítica y 1 quiere decir que hay algún proceso en su sección critica.

Sleep (Bloque) y Wakeup (Desbloqueo)

Algunas primitivas de comunicación entre procesos se bloquean en vez de gastar tiempo de CPU cuando no tienen permisos de entrar en sus secciones críticas. Una de las más simple es la pareja Sleep y Wakeup. Sleep es una llamada al sistema que hace que bloquee el solicitante, es decir, que se suspenda hasta que otro proceso lo desbloquee. La llamada Wakeup tiene un parámetro, una dirección de memoria que se usa para comparar llamadas Sleep con llamadas Wakeup.

Alternación Estricta

Un tercer método para el problema de la exclusión mutua se presenta en la siguiente rutina:

while (TRUE) { while (TRUE) {

while (turno!=0) while(turno!=1) /*esperar*/

seccion_critica(); seccion_critica();

turno=0; turno=1;

seccion_no_critica(); seccion_no_critica();

} }

(a) (b)

En esta solución propuesta, la variable entera turno, que inicialmente vale 0, lleva el control de los turnos de entrada en la sección crítica y examina o actualiza la memoria compartida. Inicialmente, el proceso (a) inspecciona el turno, y descubre que es 1 y entrar a su sección crítica el proceso (b) también determina que es 1 y por lo tanto se coloca en un ciclo cerrado donde prueba continuamente la variable turno para observar si se convierte a 0. A la continua comprobación de una variable que espera que aparezca algún valor se le denomina “espera ocupada”. Por lo general se debe evitar, ya que desperdiciará

...