UNIVERSIDAD NACIONAL TECNOLOGICA DE LIMA SUR

CARRERA PROFESIONAL DE INGENIERIA DE SISTEMAS

Universidad
nacional tecnológica

de lima sur

ALGORITMO DE PLANIFICAION SJF

Por

Xiomi Allcca Rios

Wendy Maritza Rodriguez Rodriguez

Giovana Roque Huaman

Zomeli Villanueva Brandan

Lima, mayo de 2017

 DEDICATORIA

Este trabajo está dedicado a Dios, al

docente del curso, por guiarnos
adecuadamente, y a todas las
personas que nos han apoyado y que
hicieron posible que se realice y así
poder cumplir recopilando

ii
información fundamental para
llevarlo a cabo.

ii
 TABLA DE CONTENIDO

DEDICATORIA
ii
LISTA DE FIGURAS...................................................................................................................v
LISTA DE TABLAS.....................................................................................................................vi
INTRODUCCIÓN......................................................................................................................vii
CAPITULO I..................................................................................................................................1
PROCESO......................................................................................................................................1
1.1 Definición...........................................................................................................................1
1.2 Recursos.............................................................................................................................1
1.3 Estados de procesos......................................................................................................2
1.3.1 Modelo de procesos de dos estados.................................................................2
1.3.2 Modelo de proceso de cinco estados...............................................................3
CAPITULO II................................................................................................................................6
ALGORITMO DE PLANIFICACIÓN.....................................................................................6
2.1 Definición...........................................................................................................................6
2.2 Categorías.........................................................................................................................6
2.2.1. Apropiativas (preemtive)...................................................................................6
2.2.2. No apropiativas (Non.preemtive).................................................................7
2.3 Objetivos del planificador............................................................................................7
2.3.1. Entorno de proceso por lotes (Batch).........................................................7
2.3.2. Entorno interactivos..........................................................................................8
2.3.3. Entorno de tiempo real....................................................................................8
CAPITULO III...............................................................................................................................9
ALGORITMO DE PLANIFICACIÓN SJF.............................................................................9
3.1 Definición...........................................................................................................................9
3.2 Características...............................................................................................................10
3.3 Comportamiento...........................................................................................................10
3.3.1 Con desalojo............................................................................................................11
3.3.2 Sin desalojo.............................................................................................................13
3.3 Esquemas.........................................................................................................................14
 3.3.1 No apropiativo.......................................................................................................14
3.3.2 Apropiativo..............................................................................................................15
3.4 Ventajas y desventajas................................................................................................17
3.4.1 Ventajas....................................................................................................................17
3.4.2 Desventajas.............................................................................................................18
3.5 Aplicación del Algoritmo SJF en Borland C++..................................................18
CAPITULO IV.............................................................................................................................21
CONCLUSIONES.....................................................................................................................21
Referencias Bibliográficas....................................................................................................22

v
 LISTA DE FIGURAS

Figura 1. Descripción grafica de la entidad pasiva y entidad activa.................1

Figura 2. Modelo de procesos de dos estados...................................................3
Figura 3. Modelo de cinco estados....................................................................4
Figura 4. Ejemplo no apropiativoo..................................................................15
Figura 5. Ejemplo apropiativo.........................................................................16

v
 LISTA DE TABLAS

Tabla 1............................................................................................................... 9
Tabla 2............................................................................................................. 11
Tabla 3............................................................................................................. 13
Tabla 4............................................................................................................. 14
Tabla 5............................................................................................................. 16
Tabla 6............................................................................................................... 1

vi
 INTRODUCCIÓN

El planificador es un componente funcional muy importante de los

sistemas operativos multitarea y multiproceso, y es esencial en los
sistemas operativos de tiempo real. Su función consiste en repartir el
tiempo disponible de un microprocesador entre todos los procesos que
están disponibles para su ejecución. Este algoritmo selecciona al
proceso con el próximo tiempo de ejecución más corto. Un proceso
corto saltará a la cabeza de la cola. La ejecución de un proceso consiste
en ciclos de ejecución de CPU y ciclos de espera por E/S. El algoritmo
selecciona aquel proceso cuyo próximo ciclo de ejecución de CPU sea
menor. El problema está en conocer dichos valores, pero podemos
predecirlos usando la información de los ciclos anteriores ejecutado.

vii
 CAPITULO I

PROCESO

1.1 Definición

Programa en ejecución.

Figura 1. Descripción grafica de la entidad pasiva y entidad activa

Figura 1. Descripción grafica de la entidad pasiva y entidad activa

1.2 Recursos

El programa necesita una serie de recursos para su ejecución:

Tiempo de la CPU.

Memoria.

 Con el contenido del programa.

  Pila para datos temporales.

 Sección de datos con variables globales.

Acceso a archivos y dispositivos E/S.

1.3 Estados de procesos

1.3.1 Modelo de procesos de dos estados

La responsabilidad principal del sistema operativo es controlar la

ejecución de los procesos. Esto incluye determinar el patrón de
entrelazado para la ejecución y asignar recursos a los procesos. El
primer paso en el diseño de un sistema operativo para el control de
procesos es describir el comportamiento que se desea que tengan los
procesos.

Se puede construir el modelo más simple posible, observando que en

un instante dado, un proceso está siendo ejecutado por el procesador o
no. En este modelo, un proceso puede estar en dos estados: Ejecutando
o No Ejecutando. Cuando el sistema operativo crea un nuevo proceso,
crea el bloque de control de proceso para el nuevo proceso e inserta
dicho proceso en el sistema en estado No Ejecutando. El proceso
existe, y es conocido por el sistema operativo, y está esperando su
oportunidad de ejecutar. Cada poco tiempo, el proceso que está
actualmente en ejecución se interrumpirá y una parte del sistema
operativo, el activador, seleccionará otro proceso a ejecutar. El proceso
saliente pasará del estado Ejecutando a No Ejecutando y pasará a
Ejecutando un nuevo proceso.[ CITATION EVA \l 10250 ]

En este modelo simple se puede apreciar algo del diseño de los

elementos del sistema operativo. Cada proceso debe representarse de
tal manera que el sistema operativo pueda seguirle la pista. Es decir,
debe haber información correspondiente a cada proceso, incluyendo el
estado actual y su localización en memoria. Esto es el bloque de control
de programa. Los procesos que no están ejecutando deben estar en una
cola, esperando su turno de ejecución. Existe una sola cola cuyas
entradas son puntes al BCP de un proceso en particular.
Alternativamente, la cola debe consistir en una lista enlazada de
bloques de datos, en la cual cada bloque representa un proceso.
[CITATION EVA \l 10250 ]

Un proceso que se interrumpe se transfiere a la cola de procesos en

espera. En el caso de que el proceso finalice su ejecución o haya sido
abortado, se descarta, sale del sistema y el activador elige un proceso
de la cola para ejecutar. (Figura 2)

Figura 2. Modelo de procesos de dos estados

1.3.2 Modelo de proceso de cinco estados

Si todos los procesos estuviesen siempre preparados para ejecutar, las

gestión de las colas sería más fácil de manejar. La cola es una lista de
tipo FIFO y el procesador opera siguiendo una estrategia cíclica
(round-robin) sobre todos los procesos disponibles. Sin embargo, esta
implementación es inadecuada: algunos procesos que están en el
estado de No Ejecutando están listos para ejecutar, mientras que otros
están bloqueados, esperando a que se complete una operación de E/S.
Por tanto, utilizando una única cola, el activador no puede seleccionar
únicamente los procesos que lleven más tiempo en la cola. En su lugar,
debería recorrer la lista buscando los procesos que no estén
bloqueados y que lleven en la cola más tiempo. [CITATION EVA \l 10250 ]

Una forma más óptima para manejar esta situación es dividir el estado
en No Ejecutando en dos estados: Listo y Bloqueado. Para gestionarlo
correctamente, se han añadido dos estados adicionales que serán
bastante útiles(Figura 3). Estos cinco estados son:

 Ejecutando: El proceso está actualmente en ejecución.

 Listo: Un proceso que se prepara para ejecutar cuando tenga

oportunidad.

 Bloqueado: Un proceso que no puede ejecutar hasta que se

cumpla un evento determinado o se complete una operación E/S.

 Nuevo: Un proceso que se acaba de crear y que aún no ha sido

admitido en el grupo de procesos ejecutables por el sistema
operativo. Suele ser un proceso que aún no se ha cargado en
memoria principal aunque su BCP sí ha sido creado.

 Terminado: Un proceso que ha sido liberado del grupo de

procesos ejecutables por el sistema operativo, debido a que ha
sido detenido o que ha sido abortado por alguna razón. [CITATION
EVA \l 10250 ]

Figura 3. Modelo de cinco estados

 Figura 3. Modelo de cinco estados

Estos son los tipos de eventos que llevan a cada transición de estado
para cada proceso:

 Null -> Nuevo: Se crea un proceso nuevo para ejecutar un

programa.

 Nuevo -> Listo: El sistema operativo mueve a un proceso del

estado Nuevo al estado Listo cuando éste se encuentre preparado
para ejecutar un nuevo proceso. La mayoría de sistemas fijan un
límite basado en el número de procesos existentes o en la
cantidad de memoria virtual que se podrá utilizar por parte de los
procesos existentes. Este límite garantiza que no haya
demasiados procesos activos y que se degrade el rendimiento del
sistema.

 Listo -> Ejecutando: Cuando llega el momento de seleccionar un

nuevo proceso para ejecutar, el sistema operativo selecciona uno
de los procesos que se encuentren en estado Listo. Esta tarea la
realiza el planificador.

 Ejecutando -> Saliente: El proceso que actualmente está en

ejecución se finaliza por parte del sistema operativo, tanto si ha
finalizado su ejecución o si ha sido abortado por algún motivo.
 Ejecutando -> Listo: Esta transición se suele producir cuando el
proceso que está en ejecución ha alcanzado el máximo tiempo
posible de ejecución de forma ininterrumpida. Prácticamente
todos los sistemas multiprogramados imponen este tipo de
restricción de tiempo.

 Ejecutando -> Bloqueado: Un proceso se pone en estado

Bloqueado si solicita algo por lo que debe esperar. Pueden ser
muchos los motivos de esta transición: solicitar una operación de
E/S, solicitar una sección de memoria compartida que no está
inmediatamente disponible, comunicarse con otro proceso y
bloquearse hasta que el otro proceso le proporcione los datos
solicitados, etc.

 Bloqueado -> Listo: Un proceso en estado Bloqueado se mueve a

Listo cuando sucede el evento por el cual esperaba.

 Listo -> Saliente: Para simplificar, esta transición no se muestra

en la imagen del modelo de cinco estados. Un padre puede
terminar la ejecución de un proceso hijo en cualquier momento.
 CAPITULO II

ALGORITMO DE PLANIFICACIÓN

2.1 Definición

Un algoritmo de planificación se utiliza para calcular los recursos que

consumen otro algoritmo o conjunto de algoritmos (programa) al
realizar una determinada tarea. [CITATION Gen11 \l 10250 ]

Objetivos

 Maximizar eficiencia y rendimiento.

 Minimizar tiempo de retorno, espera y respuesta.

2.2 Categorías
2.2.1. Apropiativas (preemtive)

Generalmente conocida como política de planificación por torneo. El

proceso que se está ejecutando actualmente puede ser interrumpido y
pasado al estado de listos por el sistema operativo. La decisión de
sustituirlos por otro proceso puede llevarse a cabo cuando llega un
nuevo proceso, cuando se produce una interrupción que lleva a un
proceso bloqueado al estado listo o periódicamente, en función de una
interrupción del reloj.

Características:
  Es útil cuando los procesos de alta prioridad requieren atención
rápida.

 Es importante para garantizar buenos tiempos de respuesta en

sistemas interactivos de tiempo compartido.

 Tiene su costo en recursos, ya que el intercambio de contexto

implica sobrecarga y además requiere mantener muchos
procesos en el almacenamiento principal, en espera de la cpu, lo
que también implica sobrecarga

2.2.2. No apropiativas (Non.preemtive)

También conocido como cooperative multitasking. Una vez que el

proceso pasa al estado de ejecución, continúa ejecutando hasta que
termina, se bloquea en espera de una E/S o al solicitar algún servicio
del sistema. Esta política de ejecución para terminación fue
implementada en los primeros sistemas de lote (batch).

Características:

 Significa que los trabajos “largos” hacen esperar a los trabajos

“cortos”.

 Logra más equidad en el tratamiento de los procesos.

 Logra hacer más predecibles los tiempos de respuesta puesto que

los trabajos nuevos de prioridad alta no pueden desplazar a los
trabajos en espera.
 2.3 Objetivos del planificador

Los objetivos de un planificador varían dependiendo del entorno de

aplicación.

2.3.1. Entorno de proceso por lotes (Batch)

En estos sistemas, no existen usuarios que estén esperando

impacientemente por una rápida respuesta ante sus terminales. En
consecuencia, son aceptables los algoritmos sin desalojo, o los
algoritmos con desalojo con largos periodos de tiempo para cada
proceso. Con este enfoque se reduce la cantidad de cambios de
proceso, mejorando por tanto el rendimiento. Ejemplo, inventarios,
cálculo de nóminas, etc. Entre otras palabras planificación no
apropiativa

2.3.2.Entorno interactivos

Con usuarios interactivos es indispensable que haya expulsiones para

impedir que un proceso acapare la CPU, negando cualquier servicio de
la CPU a los demás. Incluso aunque ningún proceso tenga intención de
ejecutarse eternamente, es posible que debido a un error en el
programa un proceso mantenga parados a todos los demás
indefinidamente.

2.3.3. Entorno de tiempo real

Menos dependencia de apropiación de CPU. Los procesos no ejecutan

por largos períodos de tiempo. El sistema y sus procesos suelen ser
más limitados y controlados
 CAPITULO III

ALGORITMO DE PLANIFICACIÓN SJF

3.1 Definición

Este algoritmo asocia con cada proceso la duración de la siguiente

ráfaga de CPU del proceso. Cuando la CPU está disponible, se asigna al
proceso que tiene la siguiente ráfaga de CPU más corta.

Si las siguientes ráfagas de CPU de dos procesos son iguales, se usa la

planificación FCFS para romper el empate. Observe que un término
más apropiado para este método de planificación sería el de algoritmo
de la siguiente ráfaga de CPU más corta, ya que la planificación
depende de la duración de la siguiente ráfaga de CPU de un proceso,
en lugar de depender de su duración de la siguiente ráfaga de CPU de
un proceso, un lugar de depender de su duración total. Usamos el
término SJF porque casi todo el mundo y gran parte de los libros de
texto emplean este término para referirse a este tipo de planificación.
(Silberschatz, Galvin, & Gagne)

Ejemplo

Como ejemplo de planificación SJF, se considera el siguiente conjunto

de procesos, estando especificada la duración de la ráfaga de CPU en
milisegundos:

Tabla 1

Proceso Tiempo de ráfaga

P1 6

P2 8
 P3 7

P4 3

Usando la planificación SJF, planificaríamos estos procesos de acuerdo

con el siguiente diagrama de Gantt:

P1 P2 P3 P4

0
3 9 16 24

El tiempo de espera es de 3 milisegundos para el proceso P1, de 16

milisegundos para el proceso P2 , de 9 milisegundos para P3 y de 0
milisegundos para P4. Por tanto, el tiempo medio de espera es de (3
+16 +9+0) /4 = 7 milisegundos.

El algoritmo de planificación SJF es probablemente óptimo, en el

sentido de que proporciona el tiempo medio de espera mínimo para un
conjunto de procesos lado. Anteponer un proceso corto a uno largo
disminuye el tiempo de espera del proceso corto en mayor medida de lo
que incremente el tiempo de espera del proceso largo.
Consecuentemente, el tiempo medio de espera disminuya.

3.2 Características

 Entra en la CPU el proceso con la ráfaga de CPU más corta.

 Minimiza el tiempo de espera medio

 Este algoritmo da prioridad al proceso que va a necesitar menos

 tiempo de CPU (mejora el tiempo medio de espera).

 Este algoritmo puede ser preemptive (apropiativo) y non-

preemptive(no apropiativo). En el caso de preemptive, cuando un
proceso llega a la cola de procesos listos, su prioridad es
comparada con la prioridad del proceso que está corriendo. Si la
prioridad del nuevo proceso es mayor, entonces se atiende al
nuevo proceso.

3.3 Comportamiento

El SJF se puede comportar de dos formas:

3.3.1 Con desalojo

Si se incorpora un nuevo proceso a la cola de listos y este tiene un ciclo

de CPU menor que el ciclo de CPU del proceso que se esté ejecutando,
entonces dicho proceso es desalojado y el nuevo proceso toma la CPU.

3.2.1.1 Ejemplo del algoritmo SJF (con desalojo)

Para el siguiente ejemplo se tienen 4 procesos (P1, P2,P3 y P4). A

medida que estos se van incorporando a la cola de listos, se les calcula
su próximo ciclo de CPU.

Para calcular el próximo ciclo de CPU se pueden emplear: métodos

estadísticos, cálculos probabilísticos, entre otros. [CITATION Gen11 \l
10250 ]
Tabla 2

Tiempo de
Proceso
llegada

P1 0

P2 2

P3 4

P4 5

En el ejemplo se toma
como criterio que la cola
de procesos listos esta
inicialmente vacia.

En la figura se
representa la llegada de
P1 a la cola de listos con
un tiempo de llegada
(0,0). Luego a P1 se le
calcula su CCPU (CCPU
= 7) y en ese instante se
comienza a ejecutar.

Estando en ejecución el
proceso P1, se incorpora a
la cola de listos P2, al cual
se le calcula su CCPU
(CCPU = 4).

Pero como el CCPU de P2

es menor que el CCPU de
P1, entonces P1 es
desalojado y P2 toma la
CPU. En este caso P1 se
reincorpora a la cola de
listos porque no ha
terminado su ejecución, y
en ese instante se le
 Luego llega el proceso
P3 a la cola de listos y se
le calcula el CCPU
(CCPU = 1).

Por lo que sucede igual

que el caso anterior, el
CCPU de P3 es menor
que el CCPU de P2, por
lo que se desaloja P2
para cederle la CPU a
P3.

P2 es reincorporado a la
cola de listos porque no
ha terminado su
El proceso P4 se incorpora
a la cola de listos y se le
calcula su CCPU (CCPU =
4).

Luego P3 termina su
ejecución para cederle la
CPU al proximo proceso que
le corresponda según el
criterio que establece el
algoritmo.

Para el ejemplo le
corresponde el turno a P2,

3.3.2 Sin desalojo

Cuando un proceso toma la CPU, ningún otro proceso podrá apropiarse

de ella hasta que que el proceso que la posee termine de ejecutarse.

3.2.2.1Ejemplo del algoritmo SJF (sin desalojo)

Tabla 3

Proceso Tiempo de Ráfaga CPU

 llegada (ms)

P1 0 7

P2 2 4

P3 4 1

P4 5 4

Tiempo de espera medio = (0 + 6 + 3 + 7)/4 = 4

3.3 Esquemas

3.3.1 No apropiativo

Un proceso ejecutándose en el CPU no puede ser retirado hasta que el

mismo lo decida.

1. Ejemplo:

Tabla 4

Proceso Tiempo de Ciclo de CPU

llegada (ms)
P1 0 7

P2 2 4

P3 4 1

P4 5 4
Para SJF no apropiativo

P1 está en el el momento 0, no hay otros procesos en la cola, es

seleccionado P1 y se ejecuta por 7 unidades de tiempo hasta que
finaliza.

Al finalizar P1 en el momento 7, se encuentran en la cola P2, P3 y P4.

Es seleccionado P3 con el menor ciclo de CPU.

Al finalizar P3 en el momento 8, quedan en la cola P2 y P4 con el

mismo ciclo de CPU. Se aplica la estrategia FCFS y es seleccionado P2.

Al finalizar P2 su ejecución, queda P4 para ser despachado al CPU.

El proceso no puede ser retirado del CPU por el sistema operativo.

[CITATION Pab \l 10250 ]

Figura 4. Ejemplo no apropiativoo

Tiempo de espera:

P1 llegó en 0 y entró en 0 esperó 0, P3 llegó en 4 y entró en 7 esperó 3,

P2 llegó en 2 y entró en 8 esperó 6, P4 llegó en 5 y entró en 12 esperó
7.

Tiempo de espera promedio = (0 + (8 -2 ) + ( 7 – 4 ) + ( 12 – 5 ))/4 =

( )/4 = 4

Tiempo de entrega:

P1 llegó en 0 y finalizó en 7 tiempo de entrega 7, P2 llegó en 2 y

finalizó en 12 tiempo de entrega 10, P3 llegó en 4 y finalizó en 8 tiempo
de entrega 4, P4 llegó en 5 y finalizó en 16 tiempo de entrega 11.

Tiempo de entrega promedio = (( 7 – 0 ) + (12 – 2) + ( 8 – 4 ) + ( 16 –

5 ))/4 = ( )/4 = 8

3.3.2 Apropiativo

Si un nuevo proceso llega a la cola de listos con un ciclo de CPU menor

a los demás procesos incluyendo al que se está ejecutando en el CPU,
este nuevo proceso reemplaza al proceso en el CPU. Este algoritmo se
llama también primero el que tenga el tiempo de ejecución remanente
más corto Shortest-Remaining-Time-First (SRTF).

3.3.2.1 Ejemplo:

Tabla 5

Proceso Tiempo de Ciclo de CPU

llegada (ms)

P1 0 7
 P2 2 4

P3 4 1

P4 5 4

El proceso puede ser retirado del CPU por el sistema operativo.

P1 llega en el momento 0 siendo el único proceso en la cola es

despachado al CPU. P2 llega en el momento 2, tiene un ciclo de CPU 4
menor que los 5 restantes ( 7 – 2 ) de P1. Por lo tanto P1 es retirado del
CPU y entra P2. En el momento 4 llega P3 que tiene el ciclo de CPU 1
menor que los 2 restantes de P2.

Por lo tanto P2 es retirado del CPU y entra P3. En el momento 5 P3

finaliza su ejecución y el planificador debe decidir a quién seleccionar
en la cola. P1 le quedan 5 ciclos de CPU, a P2 le quedan 2 ciclos de
CPU y P4 tiene 4 ciclos de CPU. Por lo tanto, P2 es despachado al CPU.
En el momento 7, P2 finaliza y es seleccionado P4 que tiene 4 ciclos de
CPU menor a los 5 que tiene P1. P4 finaliza su ejecución en el momento
11 y entra P1 que finaliza en el momento 16.

Figura 5. Ejemplo apropiativo

Tiempo de espera para P1 como ejemplo: P1 entra de inmediato al CPU

con espera 0, pero luego sale en el momento 2 y espera hasta el
momento 11 para volver al CPU, por lo tanto P1 espera ( 11 – 2 ) = 9
unidades de tiempo.
Tiempo de espera promedio = ((0 + ( 11 – 2 )) + ( 0 + (5 – 4 )) + ( 0 ) +
( 7 – 5 ))/4 = ( )/4 = 3

Tiempo de entrega para P2 como ejemplo: P2 sale del sistema en el

momento 7, llegó en 2 por lo tanto el tiempo de entrega es 7 – 2 = 5.

Tiempo de entrega promedio = (16 + ( 7 – 2 )+ ( 5 – 4 ) + ( 11 – 5 ))/4 =

( )/4 = 7

3.4 Ventajas y desventajas

Es probablemente óptimo ya que reduce el tiempo de espera porque

sirve primero los hilos cortos antes que los largos. Sin embargo, incluso
aunque minimice el tiempo de espera, penalizará aquellos hilos que
tienen peticiones de tiempo de servicio grandes. Si la lista de
preparados está saturada, los hilos con mayores tiempos de servicio
tienen a estar al final de la lista de preparados mientras son servidos
los hilos cortos. En el caso extremo, donde el sistema tiene muy poco
tiempo sobrante los hilos con grandes necesidades de tiempo nunca
serán servidos. Esta inanición de hilos grandes plantea grandes
reservas sobre el algoritmo
de planificación.[CITATION Gen11 \l 10250 ]

3.4.1 Ventajas

Minimiza el tiempo de finalización promedio

SJF da el mínimo tiempo de espera promedio para un conjunto de

procesos.

Entra en CPU el proceso con ráfaga de CPU más breve.

 Minimiza el tiempo de espera medio.

3.4.2 Desventajas

Riesgo de inanición de los procesos de larga duración.

El SJF no es implementable se pueden estimar las duraciones de los

procesos, según su historia reciente.

La dificultad en el algoritmo SJF es conocer la longitud de la próxima

ráfaga de CPU de un proceso.

3.5 Aplicación del Algoritmo SJF en Borland C++

#include<conio.h>
#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int np, sre, ses, i, b, c;
float a, pre, pes, s, nM;
float Tll[50], TS[50], TScop[50], TCo[50], TFi[50], TRe[50], TEs[50];
void main () {
cout<<"Ingrese el numero de procesos a planificar: ";
cin>>np; cout<<endl;
a=0; sre=0; ses=0;
for (i=0;i<np;i++){
cout<<"Ingrese el Tiempo de Llegada del proceso P"<<i+1<<": ";
cin>>Tll[i]; cout<<endl;
cout<<"Ingrese el Tiempo de Servicio del proceso P"<<i+1<<": ";
cin>>TS[i]; cout<<endl;
}
nM=TS[0];
for (i=1;i<np;i++){
if (TS[i]>nM) nM=TS[i];
}
TCo[0]=0;
TFi[0]=TS[0];
for (i=0;i<np;i++){
TScop[i]=TS[i];
}
s=0; c=0;
do{
b=1;
for (i=1;i<np;i++){
if (TScop[b]>TScop[i]){
a=TScop[i];
b=i;
}}

TCo[b]=TFi[c];
TFi[b]=TCo[b]+TS[b];
TScop[b]=nM+1;
c=b;
s=s+1;
}
while(s<(np-1));
for (i=0;i<np;i++){
TRe[i]=TFi[i]-Tll[i];
sre=sre+TRe[i];
TEs[i]=TCo[i]-Tll[i];
ses=ses+TEs[i];
}
pre=sre/np;
pes=ses/np;
cout<<endl;
cout<<"Proceso T.Llegada T.Servicio T.Finalizacion T.Retorno T.Espera"<<endl;
for (i=0;i<np;i++){
cout<<" "<<i<<" "<<Tll[i]<<" "<<TS[i]<<" "<<TFi[i]<<" "<<TRe[i]<<" "<<TEs[i]<<endl;
}
cout<<"Promedio de Tiempo de Retorno: "<<pre<<endl;
cout<<"Promedio de Tiempo de Espera: "<<pes<<endl;
getch();
}
Utilizando como ejemplo el ejercicio anterior

Tabla 6

Proceso Tiempo de Ráfaga CPU

llegada (ms)

P1 0 7

P2 2 4

P3 4 1

P4 5 4
 CAPITULO IV

CONCLUSIONES

Debemos tomar en consideración que este algoritmo SJF no se puede

implementar en cualquier Sistema Operativo, sólo en aquellos que
funcionan por lotes. En la actualidad no son muy utilizados ya que
existen algoritmos mucho más eficientes y fáciles de implementar en
cualquier sistema operativo para un mejor rendimiento del CPU

Es importante tomar en cuenta que, por defecto, se realiza el primer

proceso en entrar, y a continuación los siguientes aplicando los
criterios del algoritmo SJF. Además cuanto existe un empate en las
ráfagas de dos procesos, se necesita de otro algoritmo, normalmente
FIFO, para desempatarlos.

El algoritmo SJF se puede comportar de dos maneras, en la una cuando

ingresas procesos más cortos al que se está ejecutando, lo suspende y
realiza el que entró, este es un problema, ya que puede provocar
inanición.

El algoritmo SJF nos da el mínimo tiempo de espera, por lo que en un

sistema por lotes es muy óptimo. Pero los procesos sufren riesgo de
inanición ya que los procesos lagos se mantienen mucho tiempo en
tiempos muertos, además si se maneja el comportamiento con desalojo,
los procesos largos no se ejecutarán.
 Referencias Bibliográficas

1. FING, E. (2010). inco/cursos/sistoper/recursosTeoricos. Obtenido de 5-

SO-Teo- Procesos.pdf: www.fing.edu.uy

2. Nutt, G. (2004). Sistemas Operativos . Addison-Wesley.

3. Rojas, G. (2011). FSO-Algoritmos-de-Planificacion-Algoritmo-SJF-

Shortest-Job-First. Recuperado el 19 de mayo de 2017, de
es.scribd.com

4. Silberschatz, a., Galvin, P. B., & Gagne, G. (s.f.). Fundamento de

Sistemas Operativos. Cofas S.A.

5. Tumero, P. (s.f.). trabajos105. Obtenido de Planificación de procesos:

www.monografias.com