Está en la página 1de 11

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
¿Qué nos muestra la Simulación? El aspecto de la herramienta lo podemos observar en la

¿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,

rotulo "PROCESOS DORMIDOS/TERMINADOS".

La caja viene etiquetada con el

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

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á.

en el estado actual hasta la nueva posición que ocupará. ¿Cómo la hago funcionar? La segunda
en el estado actual hasta la nueva posición que ocupará. ¿Cómo la hago funcionar? La segunda

¿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.

en tanto por ciento, de nuevos procesos al algoritmo. El Banco de Pruebas En esta simulación,

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.

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