Algoritmo de planificación SRT (Es un SJF apropiativo)

Este algoritmo siempre ejecuta primero aquellos procesos a los que les queda menos tiempo
para terminar Este algoritmo también es conocido como ‘optimo’, pues con el se obtienen
los mejores resultados.

¿Hasta dónde puedo llegar?

En la simulación del algoritmo, aparecerán una serie de procesos hasta llegar a un número
de cuatro.

Los procesos pueden aparecer en la simulación siempre y cuando el tiempo este pasando
por esta, es decir, cuando un proceso está consumiendo CPU y cuando el sistema operativo
está detenido (consecuencia de que todos los procesos existentes estén Dormidos). Todos
los procesos creados competirán por el procesador según el algoritmo Prioridad al Tiempo
Restante Mas Corto.

El algoritmo simulado es Apropiativo, es decir, si se crea un nuevo proceso al que le resta

para concluir menos tiempo que el que se encuentra en ejecución, el proceso que se
encuentra en el procesador concluirá su ejecución y el nuevo creado pasara a tomar
posesión del procesador.
Los procesos ya creados del sistema competirán, por el procesador según el algoritmo
FIFO.

Los Procesos, para concluir su ejecución, tendrán que consumir un número de unidades de
tiempo con el que parten desde el momento en el que se crean.

Irán pasando desde una cola de procesos listos hasta la figura que representa el núcleo del
sistema operativo y una vez allí podrán consumir todas las unidades de tiempo que
necesiten para su ejecución o bien dormirse como consecuencia de una operación de
entrada/salida o un bloqueo.

Los procesos que se duermen lo harán durante una serie de unidades de tiempo, dato que
mostrarán mientras dure este estado.
Una vez que pasen por la simulación las unidades de tiempo por las que se durmieron, se
despertarán y pasaran de nuevo a formar parte de la cola de procesos listos.

Los procesos irán pasando por los distintos estados de su ciclo de vida reflejando en cada
estado unas características externas que los identificarán.

En la ilustración 1 podemos apreciar una instantánea del aspecto de la simulación en el que

se pueden apreciar unos procesos diferentes estado estados.
 ¿Qué nos muestra la Simulación?
El aspecto de la herramienta lo podemos observar en la ilustración 1, en ella se distinguen
tres figuras principales en las que se van a ir situando los procesos:

1. Una caja con cuatro apartados, uno por cada proceso, a los que irán pasando los
procesos cuando estén dormidos o terminados, de forma que podamos observar su
evolución.
Cada uno de los cuatro procesos tienen reservado su sitio en ella. El primer hueco
será para el proceso 0, el segundo para el 1, .... La caja viene etiquetada con el
rotulo "PROCESOS DORMIDOS/TERMINADOS".
2. El núcleo del sistema operativo, que está representado por un rectángulo en el que
se ha inscrito otro menor en el que se insertara el proceso que en un determinado
momento este en posesión del procesador.
3. La cola de procesos listos, en la que se encontrarán los procesos que estén
esperando a que les corresponda el procesador. La apariencia externa de la "COLA
DE PROCESOS LISTOS" es la misma que la parte de procesos
dormidos/terminados, una caja rectangular con cuatro cavidades en las que irán
entrando los procesos. La diferencia está en que aquí, cada proceso no tiene
reservado un apartado, sino que irán ocupando el que les corresponda según vaya el
algoritmo.

Los procesos, cuando vayan apareciendo en la simulación, anunciarán su aparición

mediante un cartel del color de los procesos listos. Este cartel aparece en la parte superior
derecha de la cola de procesos listos.

Los procesos, dependiendo del estado en que se encuentren, se situarán en una de estas tres
estructuras. Una casilla de una de las tres estructuras estará ocupada por un proceso cuando
no aparezca en su color original.
Según el estado, necesitaremos saber del proceso una determinada información. Como se
ve en la Ilustración 1, cada proceso se pone de un color distinto y muestra unos datos
representativos del estado actual.
 Ilustración 1 Distintos estados de los procesos

.- El proceso 0 se encuentra en el estado TERMINADO. Los procesos terminados tienen

color "arena". Aparece indicando su numero de proceso y su estado. Ya no nos hace falta
tener otra información sobre el.

.- El proceso 3 se encuentra en el estado DORMIDO. Los procesos dormidos tienen color

"cyan". Aparece indicando su numero de proceso (el 3) , las unidades de tiempo que le
restan para terminar (4 unidades de tiempo) , las unidades de tiempo que le restan para
volver a la cola de procesos listos (45 unidades de tiempo) y su estado.
 .- El proceso 1 se encuentra en el estado EN EJECUCION. Los procesos en ejecución
tienen color "azul oscuro". Aparece indicando su número de proceso, las unidades de
tiempo que le restan para terminar (1 unidad de tiempo) y su estado.

.- El proceso 2 se encuentra en el estado LISTO. Los procesos listos tienen color "verde".
Aparece indicando su numero de proceso, las unidades de tiempo que le restan para
terminar (18 unidades de tiempo) y su estado.

Los procesos, al ir cambiando de estado, se situarán en las distintas estructuras que forman
la simulación. El cambio de estado de los procesos, lo simulamos desplazando un
rectángulo que se moverá, desde la estructura que ocupa el proceso en el estado actual hasta
la nueva posición que ocupará.

¿Cómo la hago funcionar?

La segunda parte de la interfaz gráfica, es la destinada a la interacción con el usuario, la que
se encargara de obtener los parámetros según los cuales se ejecutara la simulación.

Esta zona se sitúa en la parte inferior de la pantalla mostrada de forma global en la

Ilustración 1

El botón Reiniciar, cuando comenzamos a utilizar la simulación tiene la leyenda Empezar,

sirve para arrancar la simulación con los datos que tengan los demás paramentos. Cuando
se pulsa, su leyenda cambia, pasará de Empezar a Reiniciar. Esto permitirá que cuando la
simulación comenzada haya terminado (todos los procesos consuman su tiempo), podamos
volver a ejecutarla, modificando, si así lo deseamos el resto de parámetros.

El siguiente parámetro que podemos pasar a la simulación es el de "Prob. I/O:". Indica la

probabilidad de que el proceso realice una operación de entrada salida, lo que provocaría
que el proceso se durmiese. Está representado en tanto por cien.

Por defecto tiene un 25%. Puede tomar valores desde 1 a 98. Y esto porque va en
combinación del siguiente dato. La probabilidad total de que un proceso se duerma, es la
suma de la probabilidad de que realice una operación de Entrada Salida y la de que surja un
Bloqueo, con lo que un valor que haga que las dos sumen mas de 99 hará que este se
modifique a otro más próximo.
Mediante él, podemos hacer que los procesos sean más o menos interactivos.

El siguiente parámetro es el de "Prob. Bloqueo". Este indica la probabilidad de que el

proceso que se está ejecutando tenga una operación por la cual se bloqueé.
El rango de valores que soporta es de 1 a 98, dependiendo del valor que tenga la entrada
"Prob. I/O". Debido a lo explicado anteriormente.

En la segunda fila de controles nos encontramos con "T. CPU". Este dato indica las
necesidades máximas que van a tener los procesos de unidades de tiempo. Al crearse los
procesos, estos tendrán unas necesidades de CPU que irán de 1 a la cantidad introducida en
este apartado.
Mediante él, podemos hacer que los procesos sean más o menos largos. La introducción de
un valor incorrecto provocará que este dato tome un valor por defecto.

El parámetro "T. Max. Dormido", indica el máximo número unidades de tiempo que un
proceso va a permanecer dormido. Cuando un proceso realice una operación de Entrada o
Salida , o se bloqueé, permanecerá dormido un número de ciclos que estará entre 1 y la
cantidad aquí introducida.
Puede tomar valores de 1 a 999. Mediante él, podemos hacer que los procesos permanezcan
más o menos tiempo dormidos. La introducción de un valor incorrecto provocará que este
dato tome un valor por defecto.

El ultimo dato que se le puede pasar a la simulación es el de "P Llegada PCS". Indica la
probabilidad de llegada, en tanto por ciento, de nuevos procesos al algoritmo.

El Banco de Pruebas
En esta simulación, debido a la amplia gama de controles de que dispone, vamos a poder
experimentar con bastantes combinaciones.

Una de las primeras pruebas que podemos realizar es, para poder observar como funciona
el algoritmo, dar una probabilidad de aparición a los procesos baja, con esto, no aparecerán
todos los procesos de una vez y algunos aparecerán cuando otros se estén ejecutando. Si el
tiempo de CPU de los proceso es alto (200 - 400 unidades), el rango de valores que podrán
tomar los procesos, será más dispar y tendremos mas posibilidad de que los procesos que
llegan a la simulación tengan un número de unidades de tiempo menor que el que en este
momento está en ejecución. Si esto ocurre veremos como el proceso en ejecución abandona
el procesador en beneficio del recién creado.

Planificación del Tiempo Restante Más Corto (SRT)

Es la contraparte apropiativa del SJF.

Es útil en sistemas de tiempo compartido.

El proceso con el tiempo estimado de ejecución menor para …nalizar es el siguiente en ser
ejecutado.

Un proceso en ejecución puede ser apropiado por un nuevo proceso con un tiempo
estimado de ejecución menor.

Tiene mayor sobrecarga que la planificación SJF.

Debe mantener un registro del tiempo de servicio transcurrido del proceso en ejecución, lo
que aumenta la sobrecarga.

Los trabajos largos tienen un promedio y una varianza de los tiempos de espera aún mayor
que en SJF.

La apropiación de un proceso a punto de terminar por otro de menor duración recién

llegado podría significar un mayor tiempo de cambio de contexto (administración del
procesador) que el tiempo de finalización del primero.

Al diseñarse los Sistemas Operativos se debe considerar cuidadosamente la sobrecarga de

los mecanismos de administración de recursos comparándola con los beneficios esperados.

Podemos hacer también diversas pruebas con el tiempo que los procesos van a permanecer
dormidos. Si este lo hacemos muy alto, cuando un proceso se duerma, se estará en la cola
de dormidos mucho rato. Así, si la probabilidad de que se duerma es baja (esta probabilidad
se obtiene como suma de probabilidades de bloqueo y de entrada/salida) el proceso que se
duerma asistirá a la ejecución continua de los demás procesos sin llegar el a tomar parte del
procesador. El proceso que se duerma, tendrá un gran retraso en la consecución de su
objetivo.

Si por el contrario, el tiempo que los procesos permanecen dormidos lo hacemos bajo, estos
abandonarán rápidamente el estado dormido y no sufrirán muchos retrasos en la
consecución de su objetivo.

Manejando las probabilidades de Entrada/Salida y las de Bloqueo, vamos a controlar la

interactividad de los procesos. Si hacemos que la probabilidad total de bloqueo (suma de
las dos anteriores) sea alta, los procesos serán muy interactivos, realizarán muchas
operaciones que les lleven a un bloqueo, con los que estarán casi cada vez que lleguen al
procesador durmiéndose.
Si por el contrario esta probabilidad es baja, los procesos estarán en la CPU el tiempo
necesario para concluir su trabajo. Esto, debido al funcionamiento de este algoritmo les
hará apoderarse del procesador por mucho tiempo y terminarán su trabajo casi en la primera
ejecución (en la primera si no realizar operaciones de Entrada/salida o Bloqueos).

Esta situación también haría que los procesos cortos se vean retrasados por los procesos
largos, pues tendrían que esperar a que un proceso largo consumiese todo su tiempo antes
de poder tomar el procesador.

Manejando el tiempo de CPU, vamos a poder hacer que los procesos sean cortos, y por lo
tanto, su vida en la simulación sea también corta. O bien si hacemos que este tiempo sea
alto(700 - 900), los proceso que se duerman en algunas ocasiones, estarán bastante tiempo
haciendo recorridos por la simulación.

Con respecto al parámetro de probabilidad de llegada, vamos a poder controlar la velocidad

de aparición de los procesos en la simulación. El dar valores muy altos, hace que los cuatro
procesos se creén casi a la vez. Si el valor es por el contrario, muy pequeño, los procesos
pueden tardar un rato en aparecer, con lo que la simulación estaría funcionando solo con
uno o dos procesos, ...

formulas simples:
tiempo de retorno:
tiempo de ejecucion + tiempo de espera
tiempo de termino - tiempo de llegada

tiempo de espera:
tiempo de retorno - tiempo de ejecucion

indice de servicio (indicador):

tiempo de ejecucion / tiempo de retorno

SRT (Shortest Remaining Time):

Definición:
Algoritmo apropiativo (que en cualquier momento se le puede quitar la CPU para
asignarsela otro proceso) consistente en elegir de la cola de listos el proceso con menos
necesidad de tiempo restante de CPU para cada instante de tiempo.
Características:
• Ofrece un buen tiempo de respuesta.
• La productividad es alta a cambio de la sobrecarga del sistema (a cada paso debe
decidir a que proceso asignarle la CPU).
• Penaliza los procesos largos.
• Se puede producir inanición.

Dirección http://jckuri2005.vndv.com/pages/sp-projects.html
http://todojava.awardspace.com/ejemplos-java.html

http://translate.google.com.ec/translate?hl=es&langpair=en|es&u=http://www.seas.gwu.edu/~si
mhaweb/cs173/classwork/module2/module2.html

Sintaxis de Python ( Texto sin formato Activar )

1. import datetime fecha y hora de importación

2. import time importación tiempo
3.
4. "" " Results Should Be The Following: "" "Los resultados deberían
ser los siguientes:
5. arrive=[0,3,6,7,7,10,15,16] llegan = [0,3,6,7,7,10,15,16]
6. exe=[12,3,11,1,4,5,20,7] exe = [12,3,11,1,4,5,20,7]
7.
8. Num Process Time Time Proceso Num. Tiempo Tiempo
9. Time Remaining Now Tiempo restante Ahora
10. 0 12 0 added 0 12 0 agregó
11. 0 3 9 3 0 3 9 3
12. 1 3 added 1 3 agregó
13. 1 3 0 6 #1 Finished 1 3 0 6 # 1 final
14. 2 11 added 2 11 agregó
15. 0 1 8 7 0 1 8 7
16. 3 1 added 3 1 agregó
17. 4 4 added 4 4 añadido
18. 3 1 0 8 #3 Finished 3 1 0 8 # 3 final
19. 4 2 2 10 4 2 2 10
20. 5 5 added 5 5 añadido
21. 4 2 0 12 #4 Finished 4 2 0 12 # 4 final
22. 5 5 5 5
23. 5 3 2 15 5 3 2 15
24. 6 20 added 6 20 agregó
25. 5 1 1 5 1 1
26. " "" "" "
27.
28. class ProcessUnit: clase ProcessUnit:
29. def __init__ ( self , arrive, exe ) : def __init__ (, llegar, exe
self):
30. unit_to_process = { } unit_to_process = {}
31. ctr = 0 CTR = 0
32. unit_number = 0 unit_number = 0
33. time_now = 0 time_now = 0
34. next_start_time = 0 next_start_time = 0
35. add_ctr = 0 add_ctr = 0
36. stop = len ( arrive ) - 2 Parada = len (llegar) - 2
37.
38. ## add first unit to start the process # # Añadir la primera
unidad para iniciar el proceso
39. unit_to_process [ add_ctr ] = [ arrive [ add_ctr ] , exe [
add_ctr ] ] unit_to_process [add_ctr] = [llegar] [add_ctr, [add_ctr
exe]]
40. while add_ctr < stop: mientras que <add_ctr parada:
41. ctr += 1 Ctr + = 1
42. if ctr > 500 : ## limit to 500 cycles Si Ctr> 500: # # límite a
500 ciclos
43. add_ctr = stop +1 add_ctr = parar un
44.
45. print " \n " , "-" * 60 print "\ n", "-" * 60
46.
47. ## add next unit to the dictionary ? # # Añadir la siguiente
unidad en el diccionario?
48. if arrive [ add_ctr +1 ] <= time_now: si llega [add_ctr +1] <=
time_now:
49. add_ctr += 1 add_ctr + = 1
50. unit_to_process [ add_ctr ] = [ arrive [ add_ctr ] , exe [
add_ctr ] ] unit_to_process [add_ctr] = [llegar] [add_ctr, [add_ctr
exe]]
51. print "added #" , add_ctr de impresión ", agregó #", add_ctr
52. next_start_time = arrive [ add_ctr +1 ] next_start_time = llegar
[add_ctr 1]
53. print unit_to_process imprimir unit_to_process
54.
55. ## initialize stop time = next start time - time now # #
Inicializar el tiempo de parada = siguiente hora de inicio - Fecha
y hora actual
56. stop_time = arrive [ add_ctr +1 ] - time_now stop_time = llegar
[add_ctr 1] - time_now
57. ## print "initialize stop time", arrive[add_ctr+1],
time_now # # Print "inicializar detener el tiempo", llega a
[add_ctr 1], time_now
58. if stop_time < 0 : ## two units arrive at same time si stop_time
<0: # # dos unidades llegan al mismo tiempo
59. stop_time = 99999 stop_time = 99999
60.
61. ## find smallest completion time and compare to # # Encontrar
menor tiempo para completar y comparar
62. ## the current stop time (next arrive time) # # El tiempo de
parada actual (llegar la próxima vez)
63. smallest = 99999 más pequeño = 99999
64. for key in unit_to_process: para la clave en unit_to_process:
65. ## print "time remaining", unit_to_process[key][1],
stop_time # # Print "tiempo restante", unit_to_process tecla []
[1], stop_time
66. if unit_to_process [ key ] [ 1 ] < smallest: si unit_to_process
tecla [] [1] más pequeña <:
67. smallest = unit_to_process [ key ] [ 1 ] más pequeño =
unit_to_process tecla [] [1]
68. unit_number = key # process smallest unit no matter how long the
time is unit_number tecla # = unidad de proceso más pequeño no
importa el tiempo que el tiempo es
69.
70. if smallest < stop_time: más pequeño si <stop_time:
71. stop_time = smallest stop_time más pequeño =
72.
73. print "processing next unit, stop_time" , stop_time, "unit
number" , unit_number de impresión "al lado de la unidad de
proceso, stop_time", stop_time ", número de unidad", unit_number
74. self . process_unit ( stop_time ) . Process_unit auto (stop_time)
75. time_now += stop_time time_now + stop_time =
76. unit_to_process [ unit_number ] [ 0 ] += stop_time ]
Unit_to_process [unit_number [0] + = stop_time
77. unit_to_process [ unit_number ] [ 1 ] -= stop_time ]
Unit_to_process [unit_number [1] stop_time -=
78.
79. ## if completed, delete from dictionary # # Si se completa,
eliminar del diccionario
80. if unit_to_process [ unit_number ] [ 1 ] < 1 : si]
unit_to_process [unit_number [1] <1:
81. print "dictionary delete key" , unit_number de impresión
"diccionario tecla de borrar", unit_number
82. del unit_to_process [ unit_number ] del unit_to_process
[unit_number]
83.
84.
85. ## add last unit and process remaining in order received # #
Añade última unidad y el proceso queda en orden recibida
86. print " \n -------- processing remaining units ----------------"
print "\ n -------- procesamiento restantes ----------------"
unidades
87. add_ctr += 1 add_ctr + = 1
88. unit_to_process [ add_ctr ] = [ arrive [ add_ctr ] , exe [
add_ctr ] ] unit_to_process [add_ctr] = [llegar] [add_ctr, [add_ctr
exe]]
89. print unit_to_process, " \n " unit_to_process de impresión, "\ n"
90.
91. units = unit_to_process. keys ( ) unidades = unit_to_process.
teclas ()
92. units. sort ( ) unidades. sort ()
93. for key in units: para la clave en las unidades:
94. print "unit =" , key, " time =" , unit_to_process [ key ] [ 1 ]
print "unidad =" clave "= tiempo", unit_to_process tecla [] [1]
95. self . process_unit ( unit_to_process [ key ] [ 1 ] ) .
Process_unit auto (unit_to_process tecla [] [1])
96.
97.
98. def process_unit ( self , time_to_process ) : def process_unit (,
time_to_process mismo):
99. print " " , print "",
100. for n in range ( 0 , time_to_process ) : para n en el rango (0,
time_to_process):
101. time . sleep ( 1.0 ) tiempo. dormir (1.0)
102. print n, n de impresión,
103. print de impresión
104.
105.
##=================================================================
== ##================================================
===================
106. arrive= [ 0 , 3 , 6 , 7 , 7 , 10 , 15 , 16 ] llegan = [0, 3, 6,
7, 7, 10, 15, 16]
107. exe= [ 12 , 3 , 11 , 1 , 4 , 5 , 20 , 7 ] exe = [12, 3, 11, 1, 4,
5, 20, 7]
108.
109. start_time = datetime . datetime . now ( ) start_time = fecha y
hora. fecha y hora. now ()
110. P = ProcessUnit ( arrive, exe ) P = ProcessUnit (llegar, exe)
111. print " \n " , datetime . datetime . now ( ) - start_time print
"\ n", fecha y hora). - fecha y hora. ahora (start_time