ndice.

Soluciones por software

Seminario de Solucin
Algoritmo de Problemas de Uso, Adaptacin, Explotacin
1 ..2 de Sist
Algoritmo 2 ..3

Algoritmo 3 ..4

Algoritmo 4 ..5

Algoritmo 5 ..6

Algoritmo de Peterson.7

Conclusiones y bibliografa...8.

Datos del alumno

Juan Pablo Mercado Mora
215862637

Introduccin Ingeniera informtica

Las maneras para eficientar los sistemas operativos es con la exclusin mutua
esto ayuda a evitar las interrupciones durante el ejecucin de las instrucciones las
operaciones deben de asegurarse que nunca van a colisionar haciendo un
ejecutando un cdigo y hacer que el sistema operativo funcione correctamente. La
mayora de los mtodos de exclusin mutua clsicos intentan reducir la latencia y
espera activa mediante las colas.
 UNIVERSIDAD DE GUADALAJARA
Centro Universitario de Ciencias Exactas e Ingenieras
Divisin de Electrnica y Computacin
Departamento de Ciencias Computacionales

El algoritmo de Dekker 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 de turno. Si el otro proceso est
ejecutando en su seccin crtica, deber esperar su finalizacin.

Primer algoritmo

Cuando un proceso es ejecutado verifica si es su turno, si no es su turno se

queda en espera por medio de un ciclo while. De lo contrario si es su turno
avanza a la seccin critica. Cuando el proceso sale de la seccin critica cambia
de turno.

ROGRAMA UNO;
Variables
turno: Entero;
Inicializacin Repeat
turno = 1; Hace_Cosas();
While turno = 1 Do;
Repeat REGION_CRITICA();
Hace_Cosas(); turno = 1;
While turno =2 Do; Hace_mas_cosas();
REGION_CRITICA(); Until Fin
turno = 2;
Hace_mas_cosas();
Until Fin
Segundo algoritmo
El proceso que es ejecutado despus de realizar sus tareas iniciales, a este proceso
se le permite entrar, Cuando ya puede entrar verifica si otro proceso tiene la opcin de
poder entrar, si otro proceso tambin tiene la opcin de poder entrar se da un
interbloqueo. De lo contrario el proceso avanza a la seccin crtica Al salir de la
seccin critica el proceso cambia su opcin. Y permite al otro proceso avanzar a la
seccin crtica.

PROGRAMA DOS;
Variables
P1QE, P2QE: Bool;
Inicializacin Repeat
P1QE = false; Hace_Cosas();
P2QE = false; P2QE = true;
Repeat While P1QE Do;
Hace_Cosas(); REGION_CRITICA();
P1QE = true; P2QE = False;
While P2QE Do; Hace_mas_cosas();
REGION_CRITICA(); Until Fin
P1QE = False;
Hace_mas_cosas();
Until Fin
Tercer algoritmo

Colisin regin crtica no garantiza la exclusin mutua. Al ejecutarse el proceso y

despus de realizar sus tareas iniciales, verifica si otro proceso esta dentro de
la seccin critica Si el otro proceso esta dentro entonces espera a que salga de
la seccin critica. De lo contrario pasa la fase de comprobacin y cambia su
estado a que esta dentro Luego de pasar la seccin critica cambia su estado
termina sus tareas finales.

PROGRAMA TRES;
Variables
P1A, P2A: Bool;
Inicializacin Repeat
P1A = false; Hace_Cosas();
P2A = false; While P1A Do;
Repeat P2A = true;
Hace_Cosas(); REGION_CRITICA ();
While P2A Do; P2A = False;
P1A = true; Hace_mas_cosas();
REGION_CRITICA(); Until Fin
P1A = False;
Hace_mas_cosas();
Until Fin

Cuarto algoritmo
Luego de realizar sus tareas iniciales el procesos solicita poder entrar en la
seccin critica, si el otro proceso no puede entrar ya que su estado es falso
entonces el proceso entra si problema a la seccin critica.

De lo contrario si el otro proceso tambin puede entrar entonces se entra al ciclo

donde el proceso actual se niega el paso as mismo y con un retardo de x tiempo
siendo este aleatorio se pausa el proceso, para darle va libre a los otros
procesos.

Luego de terminar su pausa entonces el proceso actual nuevamente puede entrar

y nuevamente si el otro proceso puede entrar se repite el ciclo y si no hay otro
proceso, entonces el proceso puede entrar en la seccin critica.

Cambia su estado y luego realiza sus tareas finales.

PROGRAMA CUATRO;
Variables
P1QE, P2QE: Bool;
Inicializacin Repeat
P1QE = false; Hace_Cosas ();
P2QE = false; P1QE = true;
Repeat While P2QE Do
Hace_Cosas(); Begin
P1QE = true; P2QE = false;
While P2QE Do Delay (random());
Begin P2QE = true;
P1QE = false; end;
Delay (random()); REGION_CRITICA();
P1QE = true; P2QE = False;
end; Hace_mas_cosas();
REGION_CRITICA(); Until Fin
P1QE = False;
Hace_mas_cosas();
Until Fin

Quinto Algoritmo
Se realiza las tareas iniciales, luego se verifica si hay otro procesos que puede
entrar, si lo hay se entra al ciclo y si es el turno de algn otro proceso cambia su
estado a ya no poder entrar a la seccin critica y nuevamente verifica si es el turno
de algn otro proceso si lo es se queda enciclado hasta que se da un cambio de
turno, luego nuevamente retoma su estado de poder entrar a la seccin critica,
regresa al ciclo y verifica si hay otro proceso que puede entrar entonces
nuevamente se encicla, de lo contrario entra a la seccin critica.

Al salir de la seccin critica el proceso cambia su turno, cambia su estado y realiza

sus tareas finales.

PROGRAMA CINCO;
Variables
P1QE, P2QE: Bool;
turno: Entero;
Inicializacin Repeat
P1QE = false; Hace_Cosas();
P2QE = false; P2QE = true;
turno = 1; While P1QE Do
Repeat Begin
Hace_Cosas(); if(turno = 1)
P1QE = true; Begin
While P2QE Do P2QE = false;
Begin Delay (random());
if(turno = 2) P2QE = true;
Begin end;
P1QE = false; end;
Delay (random()); REGION_CRITICA();
P1QE = true; turno = 1;
end; P2QE = False;
end; Hace_mas_cosas();
REGION_CRITICA(); Until Fin
turno = 2;
P1QE = False;
Hace_mas_cosas();
Until Fin

El algoritmo de Peterson
El algoritmo de Peterson, tambin conocido como solucin de Peterson,1 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.

bandera[0] = false
bandera[1] = false
turno // No es necesario asignar
un turno
p0: bandera[0] = true
p1: bandera[1] = true
turno = 1
turno = 0
while( bandera[1] && turno ==
1 ); while( bandera[0] && turno
== 0 );
{ //no hace nada; espera. }
{ //no hace nada; espera. }
// seccin crtica //
seccin crtica

// fin de la seccin
crtica // fin de la seccin
crtica
bandera[0] = false
bandera[1] = false
Conclusin.
Con la exclusin mutua los procesos tienen asegurado, en mayor medida, que
podrn entrar en algn momento a su seccin critica, debido a inhabilitacin de
interrupciones En un multincleo al deshabilitar las interrupciones de una CPU no
se evita que las dems CPUs interfieran con las operaciones que la primera CPU
est realizando.

Bibliografa.

BIBLIOGRAFA

Sistemas operativos aspectos internos y principios de diseo

stallings-beymar
Edicion 5

Sistemaoperativo.wikispaces.com. (2017). SistemaOperativo - Exclusion Mutua.

[online] Available at: http://sistemaoperativo.wikispaces.com/Exclusion+Mutua
[Accessed 27 Mar. 2017].