Nicolás Aguirre Espinosa

C.C 1010124299
Actividad 8:
Deshabilitar interrupciones:
Ejercicio 1: Escriba como queda el protocolo de entrada y salida para esta
solución y sus inconvenientes.
En un sistema con un solo procesador, la solución más simple es hacer que cada
proceso deshabilite todas las interrupciones justo después de entrar a su región
crítica y las rehabilite justo después de salir. Con las interrupciones deshabilitadas,
no pueden ocurrir interrupciones de reloj. Después de todo, la CPU sólo se
conmuta de un proceso a otro como resultado de una interrupción del reloj o de
otro tipo, y con las interrupciones desactivadas la CPU no se conmutará a otro
proceso. Por ende, una vez que un proceso ha deshabilitado las interrupciones,
puede examinar y actualizar la memoria compartida sin temor de que algún otro
proceso intervenga.
Por lo general este método es poco atractivo, ya que no es conveniente dar a los
procesos de usuario el poder para desactivar las interrupciones. Suponga que uno
de ellos lo hiciera y nunca las volviera a activar. Ése podría ser el fin del sistema;
aún más: si el sistema es un multiprocesador (con dos o posiblemente más
CPUs), al deshabilitar las interrupciones sólo se ve afectada la CPU que ejecutó la
instrucción deseable. Las demás continuarán ejecutándose y pueden acceder a la
memoria compartida.
Por otro lado, con frecuencia es conveniente para el mismo kernel deshabilitar las
interrupciones por unas cuantas instrucciones mientras actualiza variables o listas.
Por ejemplo, si ocurriera una interrupción mientras la lista de procesos se
encuentra en un estado inconsistente, podrían producirse condiciones de carrera.
La conclusión es que a menudo deshabilitar interrupciones es una técnica útil
dentro del mismo sistema operativo, pero no es apropiada como mecanismo de
exclusión mutua general para los procesos de usuario.
La posibilidad de lograr la exclusión mutua al deshabilitar las interrupciones
(incluso dentro del kernel) está disminuyendo día con día debido al creciente
número de chips multinúcleo que se encuentran hasta en las PCs de bajo
rendimiento. Ya es común que haya dos núcleos, las máquinas actuales de alto
rendimiento tienen cuatro y dentro de poco habrá ocho o 16. En un multinúcleo (es
decir, sistema con multiprocesadores) al deshabilitar las interrupciones de una
CPU no se evita que las demás CPUs interfieran con las operaciones que la
primera CPU está realizando. En consecuencia, se requieren esquemas más
sofisticados
While (TRUE)
{
Deshabilitar interrupciones
SECCIÓN CRÍTICA
Habilitar interrupciones
SECCIÓN NO CRÍTICA
}
En este intento de solución el protocolo de entrada es deshabilitar interrupciones y
el protocolo de salida es habilitar interrupciones, es una solución muy poca factible
dado que estas operaciones son de modo núcleo, es decir, son operaciones del
sistema operativo.
Con este algoritmo se preserva la exclusión mutua, pero se degrada la latencia del
sistema: mientras está en la sección critica no se atenderán interrupciones.
 No habrá tiempo compartido.
 El retraso en la atención de las interrupciones podría afectar al sistema
completo.
 Las aplicaciones podrían abusar o contener fallos, podría desembocar en
un cuelgue del sistema.

Compartir una variable turno que indique quién puede entrar a la selección
crítica.
Ejercicio 2: Escriba como queda el protocolo de entrada y salida para esta
solución y sus inconvenientes.
Variables de candado
Considerando tener una sola variable compartida (de candado), que al principio es
0. Cuando un proceso desea entrar a su región crítica primero evalúa el candado.
Si este candado es 0, el proceso lo fija en 1 y entra a la región crítica. Si el
candado ya es 1 sólo espera hasta que el candado se haga 0. Por ende, un 0
significa que ningún proceso está en su región crítica y un 1 significa que algún
proceso está en su región crítica.
Por desgracia, esta idea contiene exactamente el mismo error fatal que vimos en
el directorio de spooler. Suponga que un proceso lee el candado y ve que es 0.
Antes de que pueda fijar el candado a 1, otro proceso se planifica para ejecutarse
y fija el candado a 1. Cuando el primer proceso se ejecuta de nuevo, también fija
el candado a 1 y por lo tanto dos procesos se encontrarán en sus regiones críticas
al mismo tiempo.
 Variable compartida:

while(TRUE)
{
while(turno != 0);
SECCIÓN CRÍTICA
turno= 1;
SECCIÓN NO CRÍTICA
}

while(TRUE)
{
while(turno != 1;
SECCIÓN CRÍTICA
turno= 0;
SECCIÓN NO CRÍTICA
}
Este algoritmo consiste en usar una variable compartida (variable turno)
que indica quien puede entrar en la sección crítica, el que tiene el turno es
el que tiene la sección crítica; en el primer while se tiene el proceso 0 y el
segundo while el proceso 1 todo esto en paralelo.
En el primer while, su while interno lo que representa el truco que se hace
para que solo un proceso esté en sección crítica, es decir, pone la CPU
ocupada, mientras el turno no sea 0, podría entrar el segundo proceso de la
sección crítica. Al final el que pone el turno al otro proceso es el proceso
que este en sección crítica.

Ejercicio 3: Escriba el algoritmo para cada proceso y haga un análisis.

Interesado:
Proceso i ( i = 0,1 ):
While(TRUE)
{
Interesado[i] = TRUE;
While(interesado[i-1]);
SECCIÓN CRÍTICA
Interesado[i] =FALSE;
 SECCIÓN NO CRÍTICA
}

Esta solución requiere que los dos procesos se alternen de manera estricta
al entrar en sus regiones críticas (por ejemplo, al poner archivos en la cola
de impresión). Ninguno podría poner dos archivos en la cola al mismo
tiempo. Aunque este algoritmo evita todas las condiciones de carrera, en
realidad no es un candidato serio como solución.
Se simboliza los dos procesos con un solo algoritmo, entra el interesado y hasta
que no termine no se ejecuta el segundo interesado, estoy tiene un problema es
que si los dos procesos ponen interesado[i] en 0 o True.
Ejercicio 4: Haga un seguimiento (Prueba de escritorio) al algoritmo de Peterson.
Trate de asociar este algoritmo a un caso en la vida real.
Const otro=1-i;
While (TRUE)
{
Interesado[i] = TRUE;
Turno = otro;
While (interesado[otro] && turno==otro);
Sección critica
Interesado[i]=FALSE;
Sección no critica
}

Inicialmente interesado[0]=interesado[1]=FALSE y turno puede ser 1 o 0.

Prueba de escritorio
I=0
HILO 1
Const otro=1; //otro=1
While (TRUE)
{
Interesado[0] = TRUE; //interesado[0]
Turno = otro; //turno=1
While (interesado[otro] && turno==otro); //while(interesado[1] &&
turno==1)
Sección critica
Interesado[0]=FALSE; //interesado[0]
Sección no critica
}
 I=1
HILO 2
Const otro=0; //otro=0
While (TRUE)
{
Interesado[1] = TRUE; //interesado[1]
Turno = otro; //turno=0
While (interesado[otro] && turno==otro); //while(interesado[0] &&
turno==0)
Sección critica
Interesado[1]=FALSE; //interesado[1]
Sección no critica
}

Exclusión mutua: Supongamos que ambos procesos quieren entrar. Claramente,

no pueden entrar al mismo tiempo, porque la condición de espera en el
(interesado[otro] && turno==otro) no puede ser negativa para ambos procesos a la
vez. Entonces supongamos que P i entra primero. En este caso, turno=i, y para que
el otro entre, turno debe cambiar a 1-i, o bien interesado[i] a FALSE. El único que
hace esos cambios es el propio proceso i, y lo hace cuando esta fuera de su
sección critica.
Ausencia de postergación innecesaria: Si proceso i quiere entrar y el otro está
ejecutando su sección no crítica, entonces interesado[otro]== FALSE y P i no tiene
impedimento para entrar.
Entrada garantizada: Si un proceso quiere entrar, a lo más debe esperar que el
otro salga de la sección crítica. Hay que tener cuidado cuando se demuestra esta
propiedad. En este caso, una vez que se cumple la condición que permite a un
proceso entrar, la condición permanece al menos hasta que le toca la CPU al
proceso que quiere entrar. Si la condición fuera intermitente, hay que considerar
que el scheduler puede ser nuestro enemigo y tomar decisiones de planificación
caprichosas, de manera de darle CPU al proceso que quiere entrar justo cuando la
condición se apaga.
Caso de la vida real
Fila del galpón para el almuerzo, donde a cada individuo se le da un turno para ser
atendido y si otro individuo quiere colarse en la fila, solo puede entrar atrás de la
línea donde se recoge el almuerzo, y debe esperar a que le den una ficha para ser
atendido. Aquí se ven reflejados los 3 problemas del algoritmo de Peterson ya
que, por un lado, solo pueden recibir, atender al que sigue cuando el que se esté
ejecutando (estudiante) salga de la línea de almuerzos. Cumple ausencia de
postergación innecesaria ya que el estudiante puede entrar a la fila siempre y
cuando no sea en la línea de despacho de almuerzo y entrada garantizada ya que
las fichas de atención se dan cada cierto tiempo y no tienen un orden.

Ejercicio 5: Investigue en internet una solución intermedia a la exclusión mutua

que se dio con apoyo del hardware la instrucción TSL (TEST AND SET LOCK).
En configuraciones multiprocesador, varios procesadores comparten el acceso a
una memoria principal común. En este caso, no hay relación maestro/esclavo, sino
que los procesadores funcionan independientemente en una relación de igualdad.
No hay un mecanismo de interrupciones entre los procesadores en el que se
pueda basar la exclusión mutua.
A nivel de hardware, como se ha mencionado, los accesos a posiciones de
memoria excluyen cualquier otro acceso a la misma posición. Con esta base, los
diseñadores han propuesto varias instrucciones de máquina que realizan dos
acciones atómicamente, tales como leer y escribir o leer y examinar, sobre una
misma posición de memoria en un único ciclo de lectura de instrucción.
Puesto que estas acciones se realizan en un único ciclo de instrucción, no están
sujetas a injerencias por parte de otras instrucciones.

-La instrucción COMPARAR Y FIJAR (TS, Test and Set) puede definirse de la
siguiente forma:
booleano TS(int i)
{
if (I==0)
{
I=1;
return cierto;
}
else
{
return falso;
}
}
La instrucción examina el valor de su argumento i. Si el valor es 0 , lo cambia por 1
y devuelve cierto. En otro caso, el valor no se modifica y se devuelve falso. La
función Comparar y Fijar se ejecuta automáticamente en su totalidad, es decir, no
está sujeta a interrupciones.