Facultad de Ingeniería de Sistemas

Sistemas
Operativos

1
 Facultad de Ingeniería de Sistemas

“AÑO DEL BUEN SERVICIO AL CIUDADANO “

Universidad Nacional “San Luis Gonzaga de Ica”

Facultad de ingeniería de Sistemas

Curso:
Sistemas Operativo.
Docente:
Ing. Luis Loo Parian.
Tema:
Ejemplos de Algoritmos de
Exclusión mutua y Planificación
con discos PePs.

Alumno:
Tomairo Paniagua, Roger.

Ciclo:
VI

Sección:
B

2017

2
 Facultad de Ingeniería de Sistemas

Dedicatoria:
Dedico el trabajo a mis padres, por el apoyo incondicional
Que nos brindan, los consejos que nos proporcionan para
Ser una mejor persona y también a los docentes que
Nos proporcionan conocimiento.

3
 Facultad de Ingeniería de Sistemas

Índice

Exclusión mutua ……………………………………………………………………………………………… 5

Algoritmo 1 …………………………………………………………………………………………………….. 6
Algoritmo 2 …………………………………………………………………………………………………….. 7
Algoritmo 3 …………………………………………………………………………………………………….. 8
Algoritmo 4 …………………………………………………………………………………………………….. 9
Algoritmo 5 …………………………………………………………………………………………………….. 10
Planificación de Disco PEPS …………………………………………………………………………….. 11
Algoritmo 1 …………………………………………………………………………………………………….. 12
Algoritmo 2 …………………………………………………………………………………………………….. 13
Algoritmo 3 …………………………………………………………………………………………………….. 14
Algoritmo 4 …………………………………………………………………………………………………….. 15
Algoritmo 5 …………………………………………………………………………………………………….. 16
Bibliografía ……………………………………………………………………………………………………… 17

4
 Facultad de Ingeniería de Sistemas

Exclusión Mutua

Consiste en que un solo proceso excluye temporalmente a todos los demás para
usar un recurso compartido de forma que garantice la integridad del sistema.

REQUISITOS PARA LA EXCLUSIÓN MUTUA

1. Sólo un proceso, de todos los que poseen secciones críticas por el mismo
recurso compartido, debe tener permiso para entrar en ella en un momento
dado.
2. Un proceso que se interrumpe en una sección no crítica debe hacerlo sin
interferir con los otros procesos.
3. Un proceso no debe poder solicitar acceso a una sección crítica para
después ser demorado indefinidamente, no puede permitirse el interbloqueo
o la inanición.
4. Si ningún proceso está en su sección crítica, cualquier proceso que solicite
entrar en la suya debe poder hacerlo sin demora.
5. No se debe suponer sobre la velocidad relativa de los procesos o el número
de procesadores.

Algunos ejemplos de algoritmos clásicos de exclusión mutua son:

• El algoritmo de Dekker.
• El algoritmo de Peterson.

5
 Facultad de Ingeniería de Sistemas

Ejemplos de algoritmo de Exclusión Mutua

1. algoritmo por Dekker

shared int cierto = 1;

''/* Definición de variables compartidas */ ''

shared int bandera[2] = {0,0};
shared int turno = 0;

while (cierto)
{
bandera[proc_id] = cierto;
while (bandera[1-proc_id] == cierto)
{
if (turno == 1-proc_id)
{
bandera[proc_id] = 0;
while (turno == (1-proc_id)) /* espera a que sea su turno de
intentar */;
bandera[proc_id] = 1;
}
}
/* ''Sección crítica'' */
turno = 1-proc_id; /* es el turno del otro proceso */
bandera[proc_id] = 0;
/* ''Sección no crítica'' */
}

6
 Facultad de Ingeniería de Sistemas

2. Algoritmo por Dekker

import time
import thred

flag=[True,True]
turno = 1 #Inicio del prodemiento_0

def prodemiento_0():
global flag
global turno
flag[0]=True
while flag[1]:
if turno==1:
flag[0]=False #se tapa el paso del procedimiento 1
while turno==1:
print("Soy el procedimiento 0! Espero 6 Segundos\n")
time.sleep(6)
flag[0]=True
print("Soy el procedimiento 0! Esta es la ruta critica\n")
time.sleep(4)
print("Soy el procedimiento 0! Este es el fin de la ruta critica\n")
turno=1
flag[0]=False
def procedimiento_1():
global flag
global turno
flag[1]=True
while flag[0]:
if turno==1:
flag[1]=False #se tapa el paso del procedimiento 0
while turno==0:
print("Soy el procedimiento 0! Espero 5 Segundos\n")
time.sleep(5)
flag[1]=True
print("Soy el procedimiento 1! Esta es la ruta critica\n")
time.sleep(4)
print("Soy el procedimiento 0! Este es el fin de la ruta critica\n")
turno=0
flag[1]=False

7
 Facultad de Ingeniería de Sistemas

3. Algoritmo por Peterson

// Solucion de Peterson al problema de la sección crítica

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int mem_id_flags,mem_id_turn;
int *p_flags,*p_turn;
int id;
int main() {
int hijo;
// Crea el área de memoria compartida para las banderas y el turno
if((mem_id_flags=shmget(IPC_PRIVATE,sizeof(int)*2,0774|IPC_CREAT))==-1)
return -1;
if(!(p_flags=(int *)shmat(mem_id_flags,(char *)0,0))) return -1;
if((mem_id_turn=shmget(IPC_PRIVATE,sizeof(int),0774|IPC_CREAT))==-1)
return -1;
if(!(p_turn=(int *)shmat(mem_id_flags,(char *)0,0))) return -1;
*p_turn=0;
p_flags[0]=p_flags[1]=0;
if(hijo=fork())
id=0;
else
id=1;
while(1) {
int other;
printf("Proceso %d desea entrar a la SC\n",id);
other=1-id;
p_flags[id]=1;
*p_turn=other;
while(p_flags[other]==1 && *p_turn==other); // Se usa espera activa
printf("Proceso %d entró a la SC\n",id);
sleep(1);
printf("Proceso %d salió de la SC\n",id);
p_flags[other]=0;
sleep(1);
}
if(hijo) kill(hijo,9);
shmdt((char *)p_flags);
shmctl(mem_id_flags,IPC_RMID,(struct shmid_ds *)NULL);
shmdt((char *)p_turn);
shmctl(mem_id_turn,IPC_RMID,(struct shmid_ds *)NULL);
return 0;
}

8
 Facultad de Ingeniería de Sistemas

4. Algoritmo por Peterson

import threading
import thread
import logging
import time

bandera=[False, False]
turno=0
contador=0

def get_first_part () :
global bandera, turno, contador
bandera[0] =True
turno=1
while(bandera[1]==True and turno==1):
print “Proceso#1 esperando ”+ “\n”
#time.sleep(1)
print “Proceso#1 ini sección critica ”+”\n”
for i in range(3):
contador=contador+1
time.sleep(2)
print “Proceso#1 fin sección critica”+”\n”
print (“Proceso#1 contador: ”+ str(contador)+”\n”)
bandera[0]=False

def get_second_part () :
global bandera, turno, contador
bandera[i]=True
turno=0
while (bandera[0] == True and turno=0)
print “Proceso#2 esperando ”+”\n”
#time.sleep(1)
print (“Proceso#2 ini sección critica ”+”\n”)
for i in range (3):
contador=contador+1
time.sleep(2)
print “Proceso#2 fin sección critica”+”\n”
print (“Proceso#2 contador: ”+ str(contador))
bandera[1]=False

def main():
global contador
contador=0
thread.start_new_thread(get_first_part, () )
thread.start_new_thread(get_second_part, () )
#print contador
main()

9
 Facultad de Ingeniería de Sistemas

5. Algoritmo por Dekker

public class Dekker extends Thread

{
public static volatile long turno;
public static volatile long[] turnos;
public static volatile int indice = 0;
public static volatile boolean[] permisos;
public void run() {
for(int i = 0; i < 10; ++i) {
//Antes del pre-protocolo
System.out.println(this.getName() + ": Antes del pre-protocolo.");
//Pre-protocolo
System.out.println(this.getName() + ": Pre-protocolo");
String name = this.getName();
name = name.replace("Thread-", "");
int numThread = Integer.parseInt(name);
int otroThread;
if (numThread == 0) otroThread = 1; else otroThread = 0;
permisos[numThread] = false;
while(permisos[otroThread] == false) {
if(turno != this.getId()) {
permisos[numThread] = true;
while(turno != this.getId()) {}
permisos[numThread] = false;}
}
//Secci´on cr´ıtica
System.out.println(this.getName() + ": Secci´on cr´ıtica. Vuelta " + i);
//Post-protocolo
System.out.println(this.getName() + ": Post-protocolo");
permisos[numThread] = true;
if(indice == 1) indice = 0; else ++indice; turno = turnos[indice]; } }
public static void main(String[] args) throws InterruptedException
{
Dekker t1 = new Dekker();
Dekker t2 = new Dekker();
turnos = new long[2];
turnos[0] = t1.getId();
turnos[1] = t2.getId();
turno = turnos[indice];
permisos = new boolean[2];
for (int i = 0; i < 2; ++i)
permisos[i] = true;
t1.start();
t2.start();
t1.join();
t2.join();
}
}

10
 Facultad de Ingeniería de Sistemas

ALGORITMOS DE PLANIFICACIÓN De Disco PEPS

En un sistema donde se generan múltiples solicitudes de entrada - salida a discos, estas

pueden planificarse. En general se intenta mejorar los tiempos de búsqueda. Cuando éste
tiene varias solicitudes de transferencia pendientes, resulta importante encontrar un
mecanismo óptimo para realizar la transferencia, minimizando el tiempo de demora.

ALGORITMO PEPS

Este algoritmo también llamado FIFO (First Input, First Output) o FCFS (Primero en llegar,
primero en ser servido). Este algoritmo puede verse como muy justo, aunque sea muy
poco eficiente.

Los procesos se despachan de acuerdo con su tiempo de llegada a la cola de procesos

listos. Cuando un proceso tiene la CPU, se ejecuta hasta terminar. Es junto en el sentido
formal, pero algo injusta en cuanto a que los trabajos largos hacen esperar a los cortos y
los trabajos sin importancia hacen esperar a los importantes. FIFO ofrece variaciones
relativamente pequeñas en los tiempos de respuesta y por lo tanto es mas predecible que
los otros esquemas.

11
 Facultad de Ingeniería de Sistemas

Ejemplos de algoritmos de planificación en discos PEPS.

1. Algoritmo Peps (fifo)

package fifo;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Iterator;
import java.util.*;
import java.io.*;

public class FIFO {

public static void main(String args[]) {
Queue<String> fifo = new LinkedList<String>();
int i;
int procesos=0;
int conta;
Scanner sc = new Scanner(System.in);
System.out.print("Ingrese el numero los procesos a iniciar: ");
procesos = sc.nextInt();
conta=0;
for(i=1;i<=procesos;i++)
{ conta++;
System.out.println("Creando nuevo proceso en..."+" ms"+"
Numero: P_"+conta);
fifo.offer("P_"+Integer.toString(i));
}
System.out.println("Numero procesos: " + fifo.size()+" Activos");
conta=0;
Object data;
while ((data = fifo.poll()) != null) {
conta++;
try {
Thread.sleep(1500);
} catch(InterruptedException ex) {
Thread.currentThread().interrupt();
}
System.out.println("Proceso terminado "+data);
}
System.out.println("Numero procesos: " + fifo.size()+" Activos");
}
}

12
 Facultad de Ingeniería de Sistemas

2. Algoritmo Peps (fifo)

import java.io.*;
public class FIFO {
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int frames, pointer = 0, hit = 0, fault = 0,ref_len;
int buffer[], reference[], mem_layout[][];
System.out.println("Por favor ingrese la cantidad de cuadros: ");
frames = Integer.parseInt(br.readLine());
System.out.println("Ingrese la longitud de la cadena de referencia: ");
ref_len = Integer.parseInt(br.readLine());
reference = new int[ref_len];
mem_layout = new int[ref_len][frames];
buffer = new int[frames];
for(int j = 0; j < frames; j++)
buffer[j] = -1;
System.out.println("Por favor ingrese la cadena de referencia: ");
for(int i = 0; i < ref_len; i++)
{
reference[i] = Integer.parseInt(br.readLine());
}
System.out.println();
for(int i = 0; i < ref_len; i++)
{
int search = -1;
for(int j = 0; j < frames; j++)
{
if(buffer[j] == reference[i]) { search = j;
hit++;
break;}}
if(search == -1)
{ buffer[pointer] = reference[i];
fault++;
pointer++;
if(pointer == frames) pointer = 0;
} for(int j = 0; j < frames; j++)
mem_layout[i][j] = buffer[j];
}
for(int i = 0; i < frames; i++)
{
for(int j = 0; j < ref_len; j++)
System.out.printf("%3d ",mem_layout[j][i]);
System.out.println();
}
System.out.println("El número de visitas: " + hit);
System.out.println("Proporción de aciertos: " + (float)((float)hit/ref_len));
System.out.println("El número de fallas: " + fault);
} }

13
 Facultad de Ingeniería de Sistemas

3. Algoritmo Peps (fifo)

int[] tiempoLlegada = new int[]{ 16 , 4 , 18 ,12 ,1,6};

int[] rafagaCpu = new int[]{ 6 , 14 , 8 ,2,11 ,66};
int tmp = 0 ;
for (int j = 1; j < tiempoLlegada.length; j++) {
for (int i = 0; i < tiempoLlegada.length-1; i++) {
if(tiempoLlegada[i]>tiempoLlegada[i+1]){
tmp = tiempoLlegada[i];
tiempoLlegada[i] = tiempoLlegada[i+1];
tiempoLlegada[i+1]= tmp;
tmp = rafagaCpu[i];
rafagaCpu[i] = rafagaCpu[i+1];
rafagaCpu[i+1]= tmp;
}
}
}
System.out.println(Arrays.toString(tiempoLlegada));
System.out.println(Arrays.toString(rafagaCpu));

14
 Facultad de Ingeniería de Sistemas

4. Algoritmo Peps (fifo)

import java.io.*;
class FIFO
{
public static void main(String args[]) throws IOException
{
int fifo[]=new int[3];
int n;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Ingrese los números de Entrada :");
n=Integer.parseInt(br.readLine());
int inp[]=new int[n];
System.out.println("Ingrese la Entrada");
for(int i=0;i<n;i++)
inp[i]=Integer.parseInt(br.readLine());
System.out.println("—————");
for(int i=0;i<3;i++)
fifo[i]=-1;
int Hit=0;
int Fault=0;
int j=0;
boolean check;
for(int i=0;i<n;i++)
{
check=false;
for(int k=0;k<3;k++)
if(fifo[k]==inp[i])
{
check=true;
Hit=Hit+1;}
if(check==false)
{
fifo[j]=inp[i];
j++;
if(j>=3)
j=0;
Fault=Fault+1;}
}
System.out.println("Visitas:"+Hit+" Fallas;"+Fault);}
}

15
 Facultad de Ingeniería de Sistemas

5. Algoritmo Peps (fifo)

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
class Test
{ static int pageFaults(int pages[], int n, int capacity)
{ // Para representar un conjunto de páginas actuales. Usamos un conjunto desordenado para que
verifiquemos rápidamente // si una página está presente en el conjunto o no
HashSet<Integer> s = new HashSet<>(capacity);
// Para almacenar las páginas en forma FIFO
Queue<Integer> indexes = new LinkedList<>() ;
// Comience desde la página inicial
int page_faults = 0;
for (int i=0; i<n; i++)
{// Compruebe si el conjunto puede contener más páginas
if (s.size() < capacity)
{ // Insértelo en el conjunto si no está presente, lo que representa un error de página
if (!s.contains(pages[i]))
{s.add(pages[i]);// incrementar fallas de pagina
page_faults++;// Empuje la página actual en la cola
indexes.add(pages[i]);
}
}
// Si el conjunto está lleno, entonces debe realizar FIFO, es decir, eliminar la primera página de la cola
else
{
if (!s.contains(pages[i]))
{ // Pop la primera página de la cola
int val = indexes.peek();
indexes.poll();
// Eliminar la página de índices
s.remove(val);
// insertar la página actual
s.add(pages[i]);
// empujar la página actual hacia

indexes.add(pages[i]);
// Incrementar fallas de página
page_faults++;
}
} }
return page_faults;}
public static void main(String args[])
{
int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
int capacity = 4;
System.out.println(pageFaults(pages, pages.length, capacity));
}}

16
 Facultad de Ingeniería de Sistemas

Bibliografía

1. https://www.youtube.com/watch?v=cZTs-ChvVoo
2. https://www.youtube.com/watch?v=ox9Zwxx-lLM
3. http://sistemas-operativos2012.blogspot.pe/2012/08/algoritmos-de-
dekker-y-peterson.html
4. http://tecdis-eu.es/web/sites/default/files/documentos/Practicas/PCTR-
guion_pract5.pdf
5. https://prezi.com/hqa5h-lyr0dn/algoritmo-de-planificacion-fifo/
6. http://campuscoke.blogspot.pe/2015/01/fifo-page-replacement-
algorithm-in-java.html
7. http://www.javaengineeringprograms.com/first-in-first-out-page-
replacement-algorithm-fifo-program-in-java/
8. https://es.stackoverflow.com/questions/67883/algoritmo-de-
planificacion-fifo
9. http://mynorrene.choccac.com/tag/algoritmo-planificacion-procesos-
fifo-first-in-first-out/

17