Vous êtes sur la page 1sur 32

TECNOLOGICO DE ESTUDIOS SUPERIORES DE COACALCO

SISTEMAS OPERATIVOS

INTEGRANTES:

GOMEZ MARQUEZ CARLOS LUCAS CORNEJO JONATHAN CARRERA: INGENIERIA EN SISTEMAS COMPUTACIONALES

TITULO: PLANIFICACIN DE PROCESOS SISTEMAS OPERATIVOS TCNICAS DE ADMINISTRACIN DE DEL PLANIFICADOR

GRUPO: 3511

FECHA: 30 DE MAYO DE 2013

PROFESORA: ING. YENI GARDUO

ndice 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 Planificacin de procesos Sistemas Operativos--------------------------2 Procesos----------------------------------------------------------------------------2 Objetivos de la Planificacin de procesos---------------------------------2 Algoritmos de planificacin---------------------------------------------------2 Primero llegado, primero servido (FCFS)--------------------------------3 El proceso ms corto a continuacin (SPN)-------------------------------4 SPN preventivo (PSPN)---------------------------------------------------------6 El ms penalizado a continuacin (HPRN)--------------------------------6 Ronda (Round Robn)-----------------------------------------------------------7

1.1.1 Planificacin por Prioridad-------------------------------------------------------------9 1.1.2 Retroalimentacin multinivel (FB) --------------------------------------10 1.1.3 Esquemas hbridos------------------------------------------------------------13 1.1.4 Algoritmo por cola dentro de FB-----------------------------------------14 1.1.5 Mtodos dependientes del estado del sistema------------------------14 1.1.6 Ronda egosta (SRR) ---------------------------------------------------------16 1.1.7 Planificacin de Plazo Fijo -------------------------------------------------17
2.1 2.2 Tcnicas de administracin del planificador-------------------------------------17 Introduccin-------------------------------------------------------------------------------17

2.3 2.4 2.5 2.6 2.7 2,8 2.9

Planificacin FCFS-------------------------------------------------------------17 Planificacin SJF---------------------------------------------------------------19 Planificacin por Prioridades-----------------------------------------------22 Planificacin por turnos------------------------------------------------------23 Planificacin mediante colas multinivel----------------------------------25 Planificacin mediante colas multinivel realimentadas--------------26 Planificacin de sistemas multiprocesador------------------------------28

2.1.1 2.1.2 2.1.3 2.1.4 2.1.5 2.1.6 2.1.7 2.1.9 2.1.9

Mtodos de planificacin en los sistemas multiprocesador--------28 Afinidad al procesador Algoritmos Planificacin de diferentes sistemas operativos -----29 Planificadores-----------------------------------------------------------------29 Planificacin en Windows--------------------------------------------------29 Windows XP-------------------------------------------------------------------30 Planificacin en Linux-------------------------------------------------------30 Planificacin en AIX---------------------------------------------------------31 Planificacin en Solaris-----------------------------------------------------31

3 1.1 Planificacin de procesos Sistemas Operativos.

Conjunto de polticas y mecanismos incorporados al sistema operativo, a travs de un mdulo denominado planificador, que debe decidir cul de los procesos en condiciones de ser ejecutado conviene ser despachado primero y qu orden de ejecucin debe seguirse. Esto debe realizarse sin perder de vista su principal objetivo que consiste en el mximo aprovechamiento del sistema, lo que implica proveer un buen servicio a los procesos existentes en un momento dado. 1.2 Procesos Un proceso es un programa en ejecucin. Existen 3 estados en los que puede encontrarse un proceso, estos son: "Listo", "Bloqueado" y "En ejecucin". Para el control de los mismos internamente son almacenados en una lista, cada uno de los nodos guarda informacin de un proceso. En esa informacin se almacena, entre otros aspectos, el estado en que se encuentra el proceso, el tiempo que el proceso ha usado el CPU, e informacin de E/S (entrada/salida). Los sistemas operativos cuentan con un componente llamado planificador, que se encarga de decidir cul de los procesos har uso del procesador. La toma de esta decisin, as como el tiempo de ejecucin del proceso, estar dada por un algoritmo, denominado Algoritmo de Planificacin. 1.3Objetivos de la Planificacin de procesos La Planificacin de procesos tiene como principales objetivos la equidad, la eficacia, el tiempo de respuesta, el tiempo de regreso y el rendimiento.

Equidad: Todos los procesos deben ser atendidos. Eficacia: El procesador debe estar ocupado el 100% del tiempo. Tiempo de respuesta: El tiempo empleado en dar respuesta a las solicitudes del usuario debe ser el menor posible. Tiempo de regreso: Reducir al mnimo el tiempo de espera de los resultados esperados por los usuarios por lotes. Rendimiento: Maximizar el nmero de tareas que se procesan por cada hora.

1.4 Algoritmos de Planificacin


El planificador a corto plazo puede ser invocado cuando un proceso se encuentra en algunas de las cuatro siguientes circunstancias: 1. Pasa de estar ejecutando a estar en espera (por ejemplo, por solicitar una operacin de E/S, esperar a la sincronizacin con otro proceso, etc.) 2. Pasa de estar ejecutando a estar listo (por ejemplo, al ocurrir una interrupcin 3. Deja de estar en espera a estar listo (por ejemplo, al finalizar la operacin de E/S que solicit) 4. Finaliza su ejecucin, y pasa de ejecutando a terminado

En el primer y cuarto casos, el sistemA operativo siempre tomar el control; un sistema que opera bajo multitarea preventiva implementar tambin el segundo y tercer casos, mientras que uno que opera bajo multitarea cooperativa no necesariamente reconocer dichos estados. Ahora, para los algoritmos a continuacin, recordemos que en este caso estamos hablando nicamente del despachador. Un proceso siempre abandonar la cola de procesos listos al requerir de un servicio del sistema. Para todos los ejemplos a continuacin, asumamos que los tiempos estn dados en ticks; no nos preocupa en este caso a cunto tiempo de reloj estos equivalen, sino el rendimiento relativo del sistema entero ante una carga dada. 1.5 Primero llegado, primero servido (FCFS) El esquema ms simple de planificacin es el Primero llegado, primero servido (First come, first serve, FCFS). Este es un mecanismo cooperativo, con la mnima lgica posible: Cada proceso se ejecuta en el orden en que fue llegando, y hasta que suelta el control. El despachador es muy simple, bsicamente una cola FIFO. Consideremos los siguientes procesos: (Finkel 1988, p.35)
Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 3 8 10 15 3 8 10 15 20 3 7 7 6 8 6.2 0 2 5 1 3 2.2 1 1.4 3.5 1.2 1.6 1.74 t Inicio Fin T E P

Primero llegado, primero servido (FCFS)

Si bien un esquema FCFS reduce al mnimo la sobrecarga administrativa (que incluye tanto al tiempo requerido por el planificador para seleccionar al siguiente proceso como el tiempo requerido para el cambio de contexto), el rendimiento percibido por los ltimos procesos en llegar (o por procesos cortos llegados en un momento inconveniente) resulta inaceptable. Este algoritmo dar servicio y salida a todos los procesos siempre que . En caso de que se sostenga , la demora para iniciar la atencin de un proceso crecer cada vez ms, cayendo en una cada vez mayor inanicin. FCFS tiene caractersticas claramente inadecuadas para trabajo interactivo, sin embargo, al no requerir de hardware de apoyo (como un temporizador) sigue siendo ampliamente empleado. 1.6 El proceso ms corto a continuacin (SPN) Cuando no tenemos la posibilidad de implementar multitarea preventiva, pero requerimos de un algoritmo ms justo, y contamos con informacin por anticipado acerca del tiempo que requieren los procesos que forman la lista, podemos elegir el ms corto de los presentes. Ahora bien, es muy difcil contar con esta informacin antes de ejecutar el proceso. Es ms frecuente buscar caracterizar las necesidades del proceso: Ver si durante su historia de ejecucin ha sido un proceso tendiente a manejar rfagas limitadas por entradasalida o limitadas por procesador, y cul es su tendencia actual. Para estimar el tiempo que requerir un proceso en su prxima invocacin, es comn emplear el promedio exponencia l . Definimos un factor atenuante , que determinar qu tan reactivo ser el promedio obtenido a la ltima duracin; es comn que este valor sea cercano a 0.9. Si el emple quantums durante su ltima invocacin, Podemos tomar como semilla para el inicial un nmero elegido arbitrariamente, o uno que ilustre el comportamiento actual del sistema (como el promedio del de los procesos actualmente en ejecucin).

Promedio exponencial (prediccin de prxima solicitud de tiempo) de un proceso. (Silberschatz, p.183) Empleando el mismo juego de datos de procesos que hemos venido manejando como resultados de las estimaciones, obtendramos el siguiente resultado: Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 5 3 10 15 3 10 5 15 20 3 9 2 6 8 5.6 0 4 0 1 3 1.6 1.0 1.8 1.0 1.2 1.6 1.32 t Inicio Fin T E P

El proceso ms corto a continuacin (SPN) Como era de esperarse, SPN favorece a los procesos cortos. Sin embargo, un proceso largo puede esperar mucho tiempo antes de ser atendido, especialmente con valores de cercanos o superiores a 1 Un proceso ms largo que el promedio est predispuesto a sufrir inanicin. En un sistema poco ocupado, en que la cola de procesos listos es corta, SPN generar resultados muy similares a los de FCFS. Sin embargo, podemos observar

en el ejemplo que con slo una permutacin en los cinco procesos ejemplos (B y C), los factores de penalizacin a los procesos ejemplo resultaron muy beneficiados. 1.7 SPN preventivo (PSPN) (Preemptive Shortest Process Next) Finkel (1988, p.44) apunta a que, a pesar de que intuitivamente dara una mayor ganancia combinar las estrategias de SPN con un esquema de multitarea preventiva, el comportamiento obtenido es muy similar para la amplia mayora de los procesos. Incluso para procesos muy largos, PSPN no los penaliza mucho ms all de lo que lo hara la ronda, y obtiene mejores promedios de forma consistente porque, al despachar primero a los procesos ms cortos, mantiene la lista de procesos pendientes corta, lo que lleva naturalmente a menores ndices de penalizacin. 1.8 El ms penalizado a continuacin (HPRN) (Highest Penalty Ratio Next) Si no contamos con multitarea preventiva, las alternativas presentadas hasta ahora resultan invariablemente injustas: FCFS favorece a los procesos largos, y SPN a los cortos. Un intento de llegar a un algoritmo ms balanceado es HPRN. Todo proceso inicia su paso por la cola de procesos listos con un valor de penalizacin . Cada vez que es obligado a esperar un tiempo por otro proceso, se actualiza como que tenga mayor . Mientras largos sufran inanicin. . El proceso que se elige como activo ser el , HPRN evitar que incluso los procesos ms

En los experimentos realizados por Finkel, HPRN se sita siempre en un punto medio entre FCFS y SPN; su principal desventaja se presenta conforme crece la cola de procesos listos, ya que tiene que calcularse para todos ellos cada vez que el despachador toma una decisin. 1.9 Ronda (Round Robn) El esquema ronda busca dar una relacin de respuesta buena tanto para procesos largos como para los cortos. La principal diferencia entre la ronda y FCFS es que en este caso s emplearemos multitarea preventiva: A cada proceso que est en la lista de procesos listos lo atenderemos por un slo quantum ( ). Si un proceso no ha terminado de ejecutar al final de suquantum, ser interrumpido y puesto al final de la lista de procesos listos, para que espere a su turno nuevamente. Los procesos que nos entreguen los planificadores a mediano o largo plazo se agregarn tambin al final de esta lista. Con la misma tabla de procesos que encontramos en el caso anterior (y, por ahora, ignorando la sobrecarga administrativa provocada por los cambios de contexto), obtendramos los siguientes resultados:

8 Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 1 4 9 12 6 11 8 18 20 6 10 5 9 8 7.6 3 5 3 4 3 3.6 2.0 2.0 2.5 1.8 1.6 1.98 t Inicio Fin T E P

Primero llegado, primero servido (FCFS) La ronda puede ser ajustada modificando la duracin de . Conforme incrementamos , la ronda tiende a convertirse en FCFS Si cada quantum es arbitrariamente grande, todo proceso terminar su ejecucin dentro de su quantum; por otro lado, conforme decrece , mayor frecuencia de cambios de contexto tendremos; esto llevara a una mayor ilusin de tener un procesador dedicado por parte de cada uno de los procesos, dado que cada proceso sera incapaz de notar las rfagas de atencin que ste le da (avance rpido durante un periodo corto seguido de un periodo sin avance). Claro est, el procesador simulado sera cada vez ms lento, dada la fuerte penalizacin que ira agregando la sobrecarga administrativa. Finkel (1988, p.35) se refiere a esto como el principio de la histresis: Hay que resistirse al cambio. Como ya lo mencionamos, FCFS mantiene al mnimo posible la sobrecarga administrativa, y aunque sea marginalmente resulta en mejor rendimiento global.

Si repetimos el anlisis anterior bajo este mismo mecanismo, pero con un quantum de 4 ticks, tendremos:
Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 3 7 10 14 3 10 9 19 20 3 9 6 10 8 7.2 0 4 4 5 3 3.2 1.0 1.8 3.0 2.0 1.6 1.88 t Inicio Fin T E P

Primero llegado, primero servido (FCFS) Si bien aumentar el quantum mejora los tiempos promedio de respuesta, aumentarlo hasta convertirlo en un FCFS efectivo degenera en una penalizacin a los procesos cortos, y puede llevar a la inanicin cuando . Silberschatz apunta (p.188) a que tpicamente el quantum debe mantenerse inferior a la duracin promedio del 80% de los procesos. 1.1.2 Planificacin por Prioridad En este algoritmo a cada proceso se le asocia un nmero entero de prioridad. Mientras menor sea este entero pues mayor prioridad tiene el proceso, por lo que la esencia del algoritmo es planificar la entrada de procesos a la CPU de acuerdo a la prioridad asociada de cada uno de ellos.

10

Un caso particular del algoritmo por prioridad es el SJF, donde el valor del prximo ciclo de CPU representa la prioridad. El algoritmo por prioridad corrige algunas deficiencias del SJF, particularmente el retraso excesivo de procesos largos y el favoritismo por procesos cortos. Cmo se determina la prioridad de cada proceso? Existe una disciplina de planificacin no apropiativa en la cual la prioridad de cada proceso no solo se calcula en funcin del tiempo de servicio (tiempo en la CPU) sino tambin del tiempo que ha esperado para ser atendido.

Con esta frmula notamos que como el tiempo de servicio est en el denominador los procesos cortos tendrn preferencia, y como tambin el tiempo de espera aparece en el numerador los procesos largos que tambin han esperado, tendrn una prioridad favorable. Ejemplo de la Planificacin por Prioridad

En el siguiente ejemplo se tienen 4 procesos (P1, P2,P3 y P4). La tabla muesta los tiempos de ejecucin de cada uno y su prioridad.

La imagen muestra la cola de procesos. En el ejemplo se muestra la cola organizada para una mayor comprensin del algoritmo, pero en realidad dicha cola se encuentra desorganizada. De acuerdo a este criterio los procesos entrarn a la CPU y no la cedern hasta no haber terminado, ya que es un algoritmo sin desalojo.

11

Inanicin y Envejecimiento Uno de los problemas que puede presentar esta planificacin es la de un bloqueo indefinido. Es decir, pudiera darse el caso que existan procesos de prioridad alta que haran que los procesos de prioridad baja queden bloqueados esperando por ellos, solo se desbloquearan cuando estos procesos de prioridad baja logren colocarse en la CPU y por ello puede darse una espera indefinida. Es aqu donde se puede aplicar una tcnica conocida como envejecimiento que ir incrementando la prioridad de los procesos en espera cada determinado tiempo hasta que estos se ejecuten. 1.1.2 Retroalimentacin multinivel (FB) (Multilevel Feedback) Este mecanismo maneja no una, sino que varias colas de procesos listos, con diferentes niveles de prioridad a . El despachador elige para su ejecucin al proceso que est al frente de la cola de mayor prioridad que tenga algn proceso esperando , y tras un nmero predeterminado de ejecuciones, lo degrada a la cola de prioridad inmediata inferior . El mecanismo de retroalimentacin multinivel favorece a los procesos cortos, dado que terminarn sus tareas sin haber sido marcados como de prioridades inferiores. La ejecucin del mismo juego de datos que hemos manejado bajo este esquema nos da. Mostramos sobre cada una de las lneas de proceso la prioridad de la cola en que se encuentra antes del quantum en que se ejecuta:
Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 1 3 9 12 7 18 6 19 20 7 17 3 10 8 9 3 12 1 5 3 5 2.3 3.4 1.5 2.0 1.6 2.16 t Inicio Fin T E P

12

Retroalimentacin multinivel (FB) bsica Podemos observar que prcticamente todos los nmeros apuntan a que esta es una peor estrategia que las presentadas anteriormente Los nicos procesos beneficiados en esta ocasin son los recin llegados, que podrn avanzar al principio, mientras los procesos ms largos sern castigados y podrn eventualmente (a mayor ) enfrentar inanicin. Sin embargo, esta estrategia nos permite ajustar dos variables: Una es la cantidad de veces que un proceso debe ser ejecutado antes de ser degradado a la prioridad inferior, y la otra es la duracin del quantum asignado a las colas subsecuentes. Vemos tambin un caso que se repite a los ticks 8, 10, 11, 13 y 14: El despachador interrumpe la ejecucin del proceso activo, para volver a cedrsela. Esto ocurre porque, efectivamente, concluy su quantum Idealmente, el despachador se dar cuenta de esta situacin de inmediato y no iniciar un cambio de contexto al mismo proceso. En caso contrario, el trabajo perdido por gasto administrativo se vuelve innecesariamente alto. El panorama cambia si ajustamos estas variables: Si elegimos un quantum de , donde es el identificador de cola y la longitud del quantum base, un proceso largo ser detenido por un cambio de contexto al llegar a , , , , etc. lo que llevar al nmero total de cambios de contexto a frente a los , lo cual resulta atractivo

cambios de contexto que tendra bajo un esquema de ronda.

Veamos cmo se comporta nuestro juego de procesos con una retroalimentacin multinivel con un incremento exponencial al quantum:

13 Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 1 4 10 13 4 10 8 18 20 4 9 5 9 8 7 1 4 3 4 3 3 1.3 1.8 2.5 1.8 1.6 1.8 t Inicio Fin T E P

Retroalimentacin multinivel (FB) con q exponencial Vemos en este caso que, a pesar de que esta estrategia favorece a los procesos recin llegados, al tick 3, 9 y 10, llegan nuevos procesos, pero a pesar de estar en la cola de mayor prioridad, no son puestos en ejecucin, dado que llegaron a la mitad del quantum (largo) de otro proceso. Incluso los promedios de tiempos de terminacin, respuesta, espera y penalizacin para este conjunto de procesos resultan mejores que los de la ronda. Tpicamente veremos incrementos mucho ms suaves, y de crecimiento ms controlado, como o inlcuso , dado que en caso contrario un proceso muy largo podra causar muy largas inaniciones para el resto del sistema. Para evitar la inanicin, puede considerarse tambin la retroalimentacin en sentido inverso: Si un proceso largo fue degradado a la cola y pasa determinado tiempo sin recibir servicio, puede promoverse de nuevo a la cola $CP-1$ para que no sufra inanicin. Hoy en da, muchos de los principales sistemas operativos operan bajo diferentes versiones de retroalimentacin multinivel.

14

1.1.3 Esquemas hbridos En lneas generales, podemos clasificar a los siete algoritmos presentados sobre dos discriminadores primarios: Si estn pensados para emplearse en multitarea cooperativa o preventiva, y si emplean informacin intrnseca a los procesos evaluados o no lo hacen, esto es, si un proceso es tratado de distinta forma dependiendo de su historial de ejecucin. Caracterizacin de los mecanismos de planificacin a corto plazo
No considera intrnseca Cooperativa Primero llegado primero servido (FCFS) Considera intrnseca Proceso ms corto (SPN), Proceso ms penalizado (HPRN) Preventiva Ronda (RR), Retroalimentacin (FB), Ronda egosta (SRR) Proceso ms corto preventivo (PSPN)

Ahora bien, estas caractersticas primarias pueden ser empleadas en conjunto, empleando diferentes algoritmos a diferentes niveles, o cambindolos segn el patrn de uso del sistema, aprovechando de mejor manera sus bondades y logrando evitar sus deficiencias. A continuacin, algunos ejemplos de esquemas hbridos. 1.1.4Algoritmo por cola dentro de FB Al introducir varias colas, se abre la posibilidad de que cada una de ellas siga un esquema diferente para elegir cul de sus procesos est a la cabeza. En los ejemplos antes presentados, todas las colas operaban siguiendo una ronda, pero podramos contemplar, por ejemplo, que parte de las colas sean procesadas siguiendo una variacin de PSPN que empuje a los procesos ms largos a colas que les puedan dar atencin con menor nmero de interrupciones (incluso sin haberlos ejecutado an). Podra emplearse un esquema SRR para las colas de menor prioridad, siendo que ya tienen procesos que han esperado mucho tiempo para su ejecucin, para sin que repercutan en el tiempo de respuesta de los procesos cortos que van entrando a las colas superiores terminen lo antes posible su ejecucin.

15

1.1.5 Mtodos dependientes del estado del sistema Podemos variar tambin ciertos parmetros dependiendo del estado actual del sistema, e incluso tomando en consideracin valores externos al despachador. Algunas ideas al respecto son:

Si los procesos listos son en promedio no muy largos, y el valor de saturacin es bajo ( ), optar por los mtodos que menos sobrecarga administrativa signifiquen, como FCFS o SPN (o, para evitar los peligros de la multitarea cooperativa, un RR con un quantum muy largo). Si el despachador observa que la longitud de la cola excede un valor determinado (o muestra una tendencia en ese sentido, al incrementarse ), cambiar a un mecanismo que garantice una mejor distribucin de la atencin, como un RR con quantum corto o PSPN. Usar un esquema simple de ronda. La duracin de un quantum puede ser ajustada peridicamente (a cada cambio de contexto, o como un clculo peridico), para que la duracin del siguiente quantum dependa de la cantidad de procesos en espera en la lista . Si hay pocos procesos esperando, cada uno de ellos recibir un quantum ms largo, reduciendo la cantidad de cambios de contexto. Si hay muchos, cada uno de ellos tendr que esperar menos tiempo para comenzar a liberar sus pendientes. Claro est, la duracin de un quantum no debe reducirse ms all de cierto valor mnimo, definido segn la realidad del sistema en cuestin, dado que podra aumentar demasiado la carga burocrtica.

Despachar los procesos siguiendo una ronda, pero asignarles una duracin de quantum proporcional a su prioridad externa (fijada por el usuario). Un proceso de mayor prioridad ejecutar quantums ms largos. Peor servicio a continuacin (WSN, Worst Service Next). Es una generalizacin sobre varios de los mecanismos mencionados; su principal diferencia respecto a HPRN es que no slo se considera penalizacin el tiempo que ha pasado esperando en la cola, sino que se considera el nmero de veces que ha sido interrumpido por el temporizador o su prioridad externa, y se considera (puede ser a favor o en contra) el tiempo que ha tenido que esperar por E/S u otros recursos. El proceso que ha sufrido del peor servicio es seleccionado para su ejecucin, y si varios empatan, se elige uno en ronda. La principal desventaja de WSN es que, al considerar tantos factores, el tiempo requerido por un lado para recopilar todos estos datos, y por otro lado calcular el peso que darn a cada uno de los procesos implicados, puede impactar en el tiempo global de ejecucin. Es posible acudir a WSN peridicamente (y no cada vez que el despachador es invocado) para que reordene las colas segn criterios generales, y abanzar sobre dichas colas con algoritmos ms simples, aunque esto reduce la velocidad de reaccin ante cambios de comportamiento.

16

Algunas versiones histricas de Unix manejaban un esquema en que la prioridad especificada por el usuario6 era matizada y re-evaluada en el transcurso de su ejecucin. Peridicamente, para cada proceso se calcula una prioridad interna, que depende de la prioridad externa (especificada por el usuario) y el tiempo consumido recientemente por el proceso. Conforme el proceso recibe mayor tiempo de procesador, esta ltima cantidad decrece, y aumenta conforme el proceso espera (sea por decisin del despachador o por estar en alguna espera). Esta prioridad interna depende tambin del tamao de la lista de procesos listos para su ejecucin: Entre ms procesos haya pendientes, ms fuerte ser la modificacin que efecte. El despachador ejecutar al proceso que tenga una mayor prioridad despus de realizar estos pesos, decidiendo por ronda en caso de haber empates. Claro est, este algoritmo resulta sensiblemente ms caro computacionalmente, aunque ms justo, que aquellos sobre los cuales construye.

1.1.6 Ronda egosta (SRR) (Selfish Round Robin) Este mtodo busca favorecer a los procesos que ya han pasado tiempo ejecutando que a los recin llegados. De hecho, los nuevos procesos no son programados directamente para su ejecucin, sino que se les forma en la cola de procesos nuevos, y se avanza nicamente con la cola de procesos aceptados. Para SRR emplearemos los parmetros y , ajustables segn las necesidades de nuestro sistema. Indica el ritmo segn el cual se incrementar la prioridad de los procesos de la cola de procesos nuevos, y el ritmo del incremento de prioridad para los procesos aceptados. Cuando la prioridad de un proceso nuevo alcanza a la prioridad de un proceso aceptado, el nuevo se vuelve aceptado. Si la cola de procesos aceptados queda vaca, se acepta el proceso nuevo con mayor prioridad. Veamos el comportamiento en nuestro ejemplo:
Proceso Tiempo de Llegada A B C D E Promedio 0 1 3 9 12 3 5 2 5 5 4 0 2 6 10 15 4 10 9 15 20 4 9 6 6 8 6.6 1 4 4 1 3 2.6 1.3 1.8 3.0 1.2 1.6 1.79 t Inicio Fin T E P

17

Ronda egosta (SRR) con a = 2 y b = 1 Mientras , la prioridad de un proceso entrante eventualmente alcanzar a la de los procesos aceptados, y comenzar a ejecutarse. Mientras el control va alternando entre dos o ms procesos, la prioridad de todos ellos ser la misma (esto es, son despachados efectivamente por una simple ronda). Incluso cuando , el proceso en ejecucin terminar, y este caso, este esquema se convierte en FCFS. Si (esto es, si ser aceptado. En

), los procesos recin llegados sern aceptados

inmediatamente, con lo cual se convierte en una ronda. Mientras , la ronda ser relativamente egosta, dndole entrada a los nuevos procesos incluso si los que llevan mucho tiempo ejecutando son muy largos (y por tanto, su prioridad es muy alta) 1.1.7 Planificacin de Plazo Fijo En la planificacin de plazo fijo se programan ciertos trabajos para terminarse en un tiempo especfico o plazo fijo. Estas tareas pueden tener un gran valor si se entregan a tiempo, y carecer de l si se entregan despus del plazo. Esta planificacin es compleja por varios motivos: El usuario debe informar por adelantado de las necesidades precisas de recursos del proceso. Semejante informacin rara vez est disponible. El sistema debe ejecutar el proceso en un plazo fijo sin degradar demasiado el servicio a los otros usuarios y debe planificar cuidadosamente sus necesidades de recursos dentro del plazo. Esto puede ser difcil por la llegada de nuevos procesos que impongan demandas imprevistas al sistema. Si hay muchas tareas a plazo fijo activas al mismo tiempo, la planificacin puede ser tan compleja que se necesiten mtodos de optimizacin avanzados para cumplir los plazos.

18

La administracin intensiva de recursos requerida por la planificacin de plazo fijo puede producir un gasto extra substancial. 2.1 Tcnicas de administracin del planificador 2.2 Introduccin La cuestin de la planificacin del procesador aborda el problema de decidir a qu proceso de la cola de procesos preparados debe asignrsele al procesador. Existen distintos algoritmos de planificacin del procesador, a continuacin analizaremos algunos de ellos. 2.3 Planificacin FCFS Este es el algoritmo ms simple de planificacin (First Come, First Served; primero en llegar, primero servido). En este esquema se asigna el CPU al primer proceso que lo solicite. La implementacin de esta poltica se gestiona con una cola FIFO (First In, First Out; primero en entrar, primero en salir). Cuando un proceso entra en la cola de procesos preparados, su PCB se coloca al final de la cola. Cuando el procesador queda libre, se le asigna al siguiente proceso de la cola y al pasar a ejecutarse se elimina de la cola. El tiempo medio de espera con el algoritmo FCFS es normalmente bastante largo. Suponiendo que el siguiente conjunto de procesos llega en el instante 0, estando la rfaga de CPU especificada en milisegundos: Proceso P1 P2 P3 Tiempo de rfaga 24 3 3

Si lo procesos llegan en el orden P1, P2, P3 y se sirven segn el orden FCFS, obtendremos el resultado mostrado en el siguiente diagrama de Gantt: P1 0 24 P2 27 P3 30

El tiempo de espera es de 10 milisegundos para el proceso P1, de 24 milisegundos para el proceso P2 y de 27 milisegundos para P3. Por tanto el tiempo medio de espera es de (0+24+27)/3 = 17 milisegundos. Sin embargo, si los procesos llegan en el orden P2, P3, P1, los resultados se muestran en el siguiente diagrama de Gantt: P2 0 P3 24 27 P1 30

19

Ahora el tiempo de espera es de (6+0+3)/3 = 3 milisegundos. Esta reduccin es sustancial. Por tanto, el tiempo medio de espera con una poltica FCFS no es, generalmente, mnimo y puede variar si la duracin de las rfagas del CPU de los procesos es muy variable. El algoritmo de planificacin FCFS es cooperativo. Una vez que el CPU ha sido asignado a un proceso, dicho proceso conserva el CPU hasta que lo libera, ya sea por que termina su ejecucin o por que realiza una peticin de E/S. El algoritmo FCFS resulta, especialmente problemtico en los sistemas de tiempo compartido, donde es importante que cada usuario obtenga una cuota del CPU a intervalos regulares. Sera desastroso que un proceso mantuviera el CPU durante un periodo largo de tiempo. 2.4 Planificacin SJF Shortest-job-First (Trabajo ms corto Primero), este algoritmo asocia con cada proceso la duracin de la siguiente rfaga de CPU del proceso. Cuando el CPU est disponible, se asigna al proceso que tiene la siguiente rfaga de CPU ms corta. Cuando las siguientes rfagas de CPU de dos procesos son iguales, se usa la planificacin FCFS para romper el empate. Un trmino ms apropiado sera el de algoritmo de la siguiente rfaga de CPU ms corta, ya que la planificacin depende de la duracin de la siguiente rfaga de CPU, en lugar de depender de la duracin total. Como ejemplo de planificacin SFJ, tenemos el siguiente conjunto de procesos, estando especificada la duracin de la rfaga de CPU en milisegundos: Proceso P1 P2 P3 P4 Tiempo de rfaga 6 8 7 3

Usando la planificacin SJF, planificaramos estos procesos de acuerdo al siguiente diagrama de Gantt: P4 0 3 P1 9 P3 16 P2 24

El tiempo de espera es de 3 milisegundos para el proceso P1, de 16 milisegundos para el proceso P2, de 9 milisegundos para el proceso P3 y de 0 milisegundos para el proceso P4. Por tanto, el tiempo medio de espera es de (3+16+9+0)/4 = 7 milisegundos. Por comparacin, si estuviramos usando el esquema de planificacin FCFS, el tiempo de espera seria de 10.25 milisegundos, El algoritmo de planificacin SJF es probablemente ptimo, ya que proporciona el tiempo medio de espera mnimo para un conjunto de procesos. Al anteponer un proceso corto a uno largo disminuye el tiempo de espera del proceso corto en

20

mayor medida de lo que incrementa el tiempo de espera del proceso largo. Por esto, el tiempo medio de espera disminuye. La dificultad del algoritmo SJF es conocer la duracin de la siguiente solicitud de CPU. En una planificacin a largo plazo en un sistema de procesamiento por lotes, podemos usar una duracin el lmite del tiempo del proceso que el usuario especifique en el momento de enviar el trabajo. La planificacin SJF se usa frecuentemente como mecanismo de planificacin a largo plazo. Aunque el algoritmo SJF es ptimo, no se puede implementar en el nivel de planificacin del CPU a corto plazo, ya que no hay forma de conocer la duracin de la siguiente rfaga de CPU. Un mtodo consiste en intentar aproximar la planificacin SJF: podemos no conocer la duracin de la siguiente rfaga de CPU, pero podemos predecir su valor, por el procedimiento de confiar en que la siguiente rfaga de CPU sea similar en duracin a las anteriores. De esta manera, calculando una aproximacin de la duracin de la siguiente rfaga de CPU, podemos tomar el proceso que tenga la rfaga de CPU predicha ms corta. La siguiente rfaga de CPU se predice como una media exponencial de las duraciones medias anteriores. Sea tn la duracin de la n-sima rfaga de CPU y sea n+1 el valor predicho rapa la siguiente rfaga de CPU. Entonces, para , 01, se define: n+1 = tn + (1 - ) tn. Esta frmula define un promedio exponencial. El valor de tn contiene la informacin ms reciente; n almacena el historial pasado. El parmetro controla el peso relativo del historial reciente y pasado de nuestra prediccin. Si =0, entonces n+1 = n, y el historial reciente no tiene ningn efecto; si =1, entonces n+1 = n y solo la rfaga de CPU mas recie nte importa. Frecuentemente, =1/2, el historial reciente y pasado tienen el mismo peso. El valor inicial 0 puede definirse como una constante o como un promedio global para todo el sistema. La siguiente figura muestra el promedio exponencial como =1/2 y 0 = 10.

21

Para entender el comportamiento del promedio exponencial, podemos desarrollar la formula n+1 sustituyendo el valor de n y el de los trminos sucesivos, obteniendo n+1 = tn + (1 ) tn-1 + + (1 ) jtn-j + + (1 ) n-1 0 Dado que tanto como 1 - con menores o iguales a 1, cada trmino sucesivo tiene menor peso que su predecesor. El algoritmo SJF puede ser cooperativo o apropiativo. La necesidad de elegir surge se da cuando un proceso llega a la cola de procesos preparados mientras que un proceso anterior est todava en ejecucin. La siguiente rfaga de CPU del proceso que acaba de llegar puede ser ms corta que lo que quede del proceso actualmente en ejecucin. Un algoritmo SJF apropiativo detendr el proceso, mientras que un algoritmo sin desalojo permitir que dicho proceso termine su rfaga de CPU. La planificacin SJF apropiativa tambin es conocida como: planificacin con seleccin del proceso con tiempo restante ms corto. Analizaremos el siguiente ejemplo con cuatro procesos donde tenemos especificada la duracin de la rfaga de CPU en milisegundos: Proceso P1 P2 P3 P4 Tiempo de llegada 0 1 2 3 Tiempo de rfaga 8 4 9 5

Si los procesos llegan a la cola de procesos preparados en los instantes que se muestran y necesitan los tiempos que se muestran los tiempos de rfaga indicados, entonces la planificacin SJF apropiativa es la que se muestra en el siguiente diagrama de Gantt: P1 0 1 P2 5 P4 10 P1 17 P3 26

El proceso P1 se inicia en el instante 0, dado que es el nico proceso que hay en la cola. El proceso P2 llega en el instante 1. El tiempo que le da al proceso P1 (7 milisegundos) es mayor que el tiempo requerido por el proceso P2 (4 milisegundos), por lo que el proceso P1 se desaloja y se planifica el proceso P2. El tiempo medio de espera en este ejemplo es de ((10 - 1) + (1 - 1) + (17 - 2) + (5 3))/4 = 26/4 = 6.5 milisegundos. La planificacin SJF cooperativa proporcionara un tiempo promedio de espera de 7.75 milisegundos.

22

2.5 Planificacin por Prioridades El algoritmo SJF es un caso especial del algoritmo de planificacin por prioridades general. A cada proceso se le asocia una prioridad y el CPU se le asigna al proceso que tenga la prioridad ms alta. Los procesos con la misma prioridad se planifican con un orden FCFS. Un algoritmo SJF es simplemente un algoritmo por prioridades donde la prioridad (p) es el inverso de la siguiente rfaga de CPU (predicha). Cuanto ms larga sea la rfaga del CPU, menor ser la prioridad y viceversa. Se debe observar que al hablar de planificacin se piensa en trminos de alta prioridad y baja prioridad. Generalmente, las prioridades se indican mediante un rango de nmeros fijo, como por ejemplo de 0 al 7, o del 0 al 4095. Sin embargo, no existe un consenso sobre si 0 es la prioridad ms alta o ms baja. Algunos sistemas usan los nmeros bajos para representar una prioridad baja, mientras que otros sistemas operativos manejan los nmeros bajos como prioridad alta; esta diferencia puede presentar confusiones. En este caso supondremos que los nmeros bajos son las prioridades altas. Por ejemplo, consideremos el siguiente conjunto de procesos y supongamos que llegan en el instante, en este orden P1, P2,, P5, estando la duracin de las rfagas de CPU especificada en milisegundos Proceso P1 P2 P3 P4 P5 Tiempo de rfaga 10 1 2 1 5 prioridad 3 1 4 5 5

Usando la planificacin por prioridades, vamos a planificar estos procesos de acuerdo con el siguiente diagrama de Gantt: P2 0 1 P5 6 P1 16 P3 P4 18 19

El tiempo de espera es de 8.2 milisegundos.

Las prioridades pueden definirse interna o externamente. Las prioridades definidas internamente usan algn valor mensurable para calcular la prioridad de un proceso. Por ejemplo para calcular las prioridades se han usado en distintos sistemas magnitudes tales como los lmites de tiempo, los requisitos de memoria, el nmero de archivos abiertos y la relacin entre la rfaga de E/S y la rfaga de CPU promedio. Las prioridades definidas externamente se establecen en funcin

23

de criterios externos al sistema operativo, como por ejemplo la importancia, el coste monetario de uso de la computadora, el departamento que patrocina el trabajo y otros factores, a menudo de carcter poltico. La planificacin por prioridades puede ser apropiativa o cooperativa. Un algoritmo de planificacin por prioridades apropiativo, expulsara del CPU al proceso actual si la prioridad del proceso que acaba de llegar es mayor. Y de manera cooperativa simplemente pondr el nuevo proceso al principio de la cola de procesos preparados. Un problema importante de los algoritmos de planificacin por prioridades es el bloqueo indefinido o la muerte por inanicin. Un proceso que est preparado a para ejecutarse pero est esperando a acceder del CPU puede considerarse bloqueado; un algoritmo de planificacin por prioridades puede dejar a algunos procesos de baja prioridad esperando indefinidamente. Una solucin al problema del bloqueo indefinido de procesos de baja prioridad consiste en aplicar mecanismos de envejecimiento. Esta tcnica consiste en aumentar gradualmente la prioridad de los procesos que estn esperando en el sistema durante mucho tiempo. 2.6 Planificacin por turnos El algoritmo de planificacin por turnos (RR, round robin) est diseado especialmente para los sistemas de tiempo compartido. Es similar a la planificacin FCFS, pero se aade la tcnica de desalojo para conmutar entre procesos. En este tipo de sistema se define una pequea unidad de tiempo, denominada cuanto de tiempo, franja temporal. Generalmente, el cuanto de tiempo se encuentra en el rango comprendido entre 10 y 100 milisegundos. La cola de procesos preparados se trata como una cola circular. El planificador del CPU recorre la cola de procesos preparados, asignando el CPU a cada proceso durante un intervalo de tiempo de hasta 1 cuanto de tiempo. Para implementar esta planificacin, mantenemos la cola de procesos preparados en una cola FIFO de procesos. Los procesos nuevos se aaden al final. El planificador del CPU toma el primer proceso de la cola, configura un temporizador para que interrumpa pasado 1 cuanto de tiempo y despacha el proceso. Puede ocurrir una de dos cosas. El proceso puede tener una rfaga de CPU cuya duracin sea menor de 1 cuanto; en este caso el propio proceso libera el CPU. Entonces el planificador continuara con el siguiente proceso preparado de la cola. Pero si la rfaga es mayor a 1 cuanto de tiempo, se producir un fin de cuenta del temporizador y este enviara una interrupcin al sistema operativo; entonces se ejecutara un cambio de contexto y el proceso se colocara al final de la cola. El planificador seleccionara al siguiente proceso de la cola. El tiempo medio de espera en los sistemas por turnos es, con frecuencia, largo. Consideremos el siguiente caso, un conjunto de procesos llega en el instante 0 especificada la duracin en rfagas de milisegundos:

24

Proceso P1 P2 P3

Tiempo de rfaga 24 3 3

Si usamos un cuanto de tiempo de 4 milisegundos, entonces el proceso P1 obtiene los 4 primeros milisegundos. Dado que necesita otros 20 milisegundos, es desalojado despus del primer cuanto de tiempo, y la CPU se concede al siguiente proceso de la cola, proceso P2. Puesto que el proceso P2 no necesita 4 milisegundos, termine antes de que caduque su cunto. Entonces el CPU se proporciona al siguiente proceso, el proceso P3. Una vez que cada proceso ha recibido un cuanto de tiempo, el CPU es devuelta al proceso P1 para un cuanto de tiempo adicional. La planificacin por turnos restante es: P1 0 4 P2 7 P3 10 P1 14 P1 18 P1 22 P1 26 P1 30

El tiempo medio de espera es 17/3 = 5.66 milisegundos.

2.7 Planificacin mediante colas multinivel Un algoritmo de planificacin mediante colas multinivel divide la cola de procesos preparados en varias colas distintas.

Los procesos se asignan permanentemente a una cola en funcin de alguna propiedad del proceso, por ejemplo, el tamao de memoria, la prioridad del proceso o el tipo de proceso. Cada cola tiene su propio algoritmo de planificacin.

25

Por ejemplo, pueden emplearse colas distintas para los procesos de primer plano y de segundo plano. La cola de primer plano puede planificarse mediante un algoritmo por turnos, mientras que para la cola de segundo plano puede emplearse un algoritmo FCFS. Adems, debe definirse una planificacin entre las colas, la cual suele implementarse como una planificacin apropiativa y prioridad fija. Por ejemplo, la cola de procesos de primer plano puede tener prioridad absoluta sobre la cola de procesos de segundo plano. Veamos un ejemplo de algoritmo de planificacin mediante colas multinivel con las cinco colas que se enumeran a continuacin, segn su orden de prioridad: 1.- Procesos del sistema 2.- Procesos interactivos 3.- Procesos de edicin interactivos 4.- Procesos por lotes 5.- Procesos de estudiantes

Cada cola tiene prioridad absoluta sobre las colas de prioridad ms baja. Por ejemplo, ningn proceso de la cola por lotes podr ejecutarse hasta que se hayan vaciado completamente las colas de los procesos del sistema, los procesos

26

interactivos y los procesos de edicin interactivos. Si un proceso de edicin interactivo llega a la cola de procesos preparados mientras se est ejecutando unos procesos por lotes, el proceso por lotes ser desalojado. Otra posibilidad consiste en repartir el tiempo entre las colas. En este caso, cada cola obtiene una cierta porcin del tiempo del CPU, con la que puede entonces planificar sus distintos procesos. Por ejemplo, en el caso de las colas de procesos de primer plano y segundo plano, la cola de primer plano puede disponer del 80% del tiempo del CPU, mientras que la cola de segundo proceso obtiene el 20% para gestionar sus procesos mediante el mtodo FCFS. 2,8 Planificacin mediante colas multinivel realimentadas El algoritmo de planificacin mediante colas multinivel realimentadas permite mover un proceso de una cola a otra. La idea es separar los procesos en funcin de las caractersticas de sus rfagas de CPU. Si un proceso utiliza demasiado tiempo de CPU, se pasa a una cola de prioridad ms baja. Este esquema deja los procesos limitados por E/S y los procesos interactivos en las colas de prioridad ms alta. Adems un proceso que est esperando demasiado tiempo en una cola de baja prioridad puede pasarse a una cola de prioridad ms alta. Este mecanismo de envejecimiento evita el bloqueo indefinido. Por ejemplo, consideremos un planificador de colas multinivel retroalimentadas, numeradas de 0 a 2 (ver figura abajo). En primer lugar, el planificador ejecuta todos los procesos de la cola 0. Solo cuando la cola 0 este vaca ejecutara los procesos de la cola 1. De forma similar los procesos de la cola 2 solo se ejecutaran si las colas 0 y 1 estn vacas. Un proceso que llegue a la cola 1 desalojara a un proceso de la cola 2 y este proceso de la cola 1 ser, a su vez, desalojado por un proceso que llegue de la cola 0.

27

Un proceso que entre en la cola de procesos preparados se coloca en la cola 0 y a cada uno de los procesos de esa cola se le proporciona un cuanto de tiempo de 8 milisegundos. Si el proceso no termina en ese tiempo, se pasa al final de la cola 1. Si al cola 0 esta vaca, al proceso que se encuentra al principio de la cola 1 se le asigna un cuanto de 16 milisegundos. Si no se completa en ese tiempo, se lo desaloja y se lo incluye en la cola 2. Los procesos de la cola 2 se ejecutan basndose en una planificacin FCFS, pero solo cuando las colas 0 y 1 estn vacas. Este algoritmo de planificacin proporciona la prioridad ms alta a todo proceso que tenga una rfaga de CPU de 0 milisegundos o menos. Tales procesos acceden rpidamente al CPU, concluyen su rfaga de CPU y pasan a su siguiente rfaga de E/S. Los procesos que necesitan ms de 8 milisegundos y menos de 24 milisegundos tambin son servidos rpidamente, aunque con una prioridad ms baja que los procesos ms cortos. Los procesos largos terminan yendo automticamente a la cola 2 y se sirven, siguiendo el orden FCFS, son los ciclos de CPU no utilizados por las colas 0 y 1. En general, un planificador mediante colas multinivel realimentadas se define mediante los parmetros siguientes: 1.- El nmero de colas 2.- El algoritmo de planificacin de cada cola 3.- El mtodo usado para determinar cundo pasar un proceso a una cola de 4.prioridad ms alta

28

5.- El mtodo usado para determinar cundo pasar un proceso a una cola de prioridad ms baja 6.- El mtodo usado para determinar en qu cola se introducir un proceso cuando haya que darle servicio La definicin del planificador mediante colas multinivel realimentadas le convierte en el algoritmo de planificacin del CPU ms general. Puede configurarse este algoritmo para adaptarlo a cualquier sistema especfico que se quiera disear. Lamentablemente, tambin es el algoritmo ms complejo, puesto que definir el mejor planificador requiere disponer de algn mecanismo para seleccionar los valores de todos los parmetros. 2.9 Planificacin de sistemas multiprocesador Cuando se cuenta con mltiples procesadores; se puede compartir la carga; sin embargo, el problema de la planificacin se hace ms complejo. Presentaremos diversas cuestiones acerca de la planificacin multiprocesador. Nos concentraremos en los sistemas homogneos (procesadores idnticos en su funcionalidad). 2.1.1 Mtodos de planificacin en los sistemas multiprocesador Un mtodo para planificar el CPU en un sistema multiprocesador consiste en que todas las decisiones sobre la planificacin, el procesamiento de E/S y otras actividades del sistema sean gestionadas por un mismo procesador, el servidor maestro. Los dems procesadores solo ejecutan cdigo de usuario. Este procesamiento asimtrico resulta simple, porque solo hay un procesador que accede a las estructuras de datos del sistema, reduciendo la necesidad de compartir datos. Un segundo mtodo utiliza el multiprocesamiento simtrico (SMP), en el que cada uno de los procesadores se auto-planifica. Todos los procesos pueden estar en una cola comn de procesos preparados o cada procesador puede tener su propia cola privada de procesos preparados. Independientemente de esto, la planificacin se lleva a cabo haciendo que el planificador de cada procesador examine la cola de procesos preparados y seleccione un proceso para ejecutarlo. Prcticamente todos los Sistemas Operativos modernos soportan el multiprocesamiento simtrico.

2.1.2 Afinidad al procesador Esto significa que un proceso tiene una afinidad hacia el procesador en que est ejecutndose actualmente.

29

La afinidad al procesador toma varias formas. Cuando un sistema operativo tiene la poltica de intentar mantener un proceso en ejecucin en el mismo procesador, pero no est garantizado que lo haga, nos encontramos ante una situacin conocida como afinidad suave. En este caso, es posible que un proceso migre entre procesadores. Algunos sistemas como Linux, tambin proporcionan llamadas al sistema que soportan la afinidad dura, la cual permite a un proceso especificar que no debe migrar a otros procesadores. 2.1.3 Algoritmos Planificacin de diferentes sistemas operativos Para hacer un comentario de los respectivos algoritmos de Planificacin de la distintos sistemas Operativos he credo conveniente primero empezar analizando que es un Planificador y posteriormente analizar cmo funciona cada algoritmo utilizado por el respectivo sistema 2.1.4 Planificadores El planificador o Schedule es un componente del Sistema Operativo que se encarga de elegirla tarea siguiente que hay que admitir en el sistema y el proceso siguiente que hay que ejecutar. La finalidad del planificador es asignar procesos para que sean ejecutados por el procesador o procesadores con el fin de obtener mejores tiempos de respuesta, mayor productividad o rendimiento y eficiencia del procesador. 2.1.5 Planificacin en Windows El componente que se encarga de administrar los procesos de Windows 95 trabaja con dos modelos de Multitarea: Multitarea Cooperativa La Multitarea con Derecho Preferente 1.- Mediante el mtodo de Multitarea Cooperativa, el Sistema Operativo deja que sea el proceso quien compruebe la cola de procesos que quieren ejecutarse y que cada proceso, deje tiempo de UCP al resto de aplicaciones que se estn ejecutando. Puede ocurrir que el programa que est en ejecucin, no compruebe peridicamente la cola y se apodere completamente de la UCP, con lo cual ningn proceso responder hasta que termine el que est en ejecucin. 2.- En la Multitarea con Derecho Preferente, es el Planificador de Procesos quien quita o da el control a un proceso y adems determina el tiempo que dicho proceso va a ocupar la UCP. El cambio de un proceso a otro, generalmente est dado a un suceso o evento (un clic del ratn, minimizar una ventana). En la Multitarea con Derecho, el Planificador asigna unas prioridades a los procesos que determinan la forma de ejecucin, sin embargo estas prioridades varan segn

30

avanza la ejecucin, ya que, en caso contrario, cuando un proceso de mxima prioridad tomase la UCP nunca la soltara. Windows 95 solo utiliza la Multitarea Cooperativa, con las aplicaciones de 16 bits. Todas las aplicaciones de 32 bits se ejecutan en Multitarea con Derecho Preferente. 2.1.6 Windows XP Planifica las hebras utilizando un algoritmo de planificacin de modo apropiativo basado en prioridades. El planificador de Windows XP asegura que siempre se ejecute la hebra de prioridad ms alta. Las prioridades se dividen en dos clases: la clase variable contiene hebras cuyas prioridades comprendidas van de 1 a 15, mientras que la clase de tiempo real contiene hebras con prioridad 0 y que se emplea para la gestin de memoria. Windows XP diferencia entre el proceso de primer plano que est actualmente seleccionado en la pantalla y los procesos de segundo plano que no estn actualmente seleccionados. Cuando un proceso pasa a primer plano, Windows XP multiplica el cuanto de planificacin por cierto factor, este incremento proporciona al proceso en primer plano tres veces ms tiempo para ejecutarse, antes de que se produzca un desalojo a la comparticin de tiempo. 2.1.7 Planificacin en Linux Los tipos de algoritmos de planificacin usados en este ncleo estn definidos en las extensiones de tiempo real del estndar POSIX (POSIX.1b, antes llamado POSIX.4). El algoritmo de planificacin es bastante parecido a un Round Robin con prioridades. Puede haber a la vez en el sistema procesos con distinta poltica de planificacin establecida. En realidad cada proceso se puede planificar de varias maneras, las polticas de planificacin de un proceso se pueden cambiar en tiempo de ejecucin y son: Los algoritmos que controlan los procesos son dos algoritmos: tiempo compartido y tiempo real Tiempo compartido 1.- Priorizado basado en crdito proceso con ms crditos se procesa a continuacin 2.- Se resta crdito cuando ocurre una interrupcin por tiempo 3.- Cuando el crdito = 0, se escoge otro proceso 4.- Cuando todos los procesos tienen crdito = 0, se reasignan crditos 6.- Basado en factores como prioridad e historia

31

7.- Tiempo real 8.- Tiempo real suave 9.- Cumple con Posix.1b dos clases FCFS y RR 10.- Proceso de ms alta prioridad siempre corre primero 2.1.8 Planificacin en AIX P = min + nice + (0.5 x recent) Donde P indica la prioridad dinmica (a menor P mayor prioridad) y recent es una medida de cuanto ha recibido la CPU el proceso recientemente. Recentse calcula de la siguiente forma: Inicialmente vale 0 Al final de cada time slice (aprox. 10 milisegundos) recent se incrementa en 1 para el proceso que est usando la CPU Una vez por segundo se divide por dos el valor recent para todos los procesos Normalmente el valor nice se hereda del proceso padre. El dueo del proceso o el propio proceso pueden elevar su valor nice (menor prioridad). El superusuario puede modificar el valor nice de todos los procesos a gusto. En los sistemas a la BSD el valor del nmero nice puede variar entre -20 y +20, siendo por defecto 0. En System V en cambio los valores posibles van de 0 a 39, siendo 20 el valor por defecto. Se puede modificar el valor nice por defecto en el momento de lanzar un programa lanzndolo a correr con el comando nice, o posteriormente utilizando el comando renice. 2.1.9 Planificacin en Solaris Utiliza una planificacin de hebras basada en prioridades, definiendo cuatro clases para planificacin. Estas clases son: Tiempo real, Sistema, Tiempo Compartido e Interactiva, de acuerdo a su orden de prioridad. La poltica de planificacin para tiempo compartido modifica dinmicamente las prioridades y asigna cuantos de tiempo diferente usando colas multinivel realimentadas. Cuanta ms alta sea la prioridad, ms pequeo ser el cuanto de tiempo; y cuanto menor sea la prioridad ms larga ser la franja. Los procesos interactivos suelen tener la prioridad ms alta, los procesos limitados por la CPU tienen la prioridad

32

ms baja. La clase interactiva usa la misma poltica de planificacin que la clase de tiempo compartido, pero proporciona a las aplicaciones con interfaz de ventanas una prioridad ms alta, para maximizar el rendimiento. En la versin 9, Solaris ha introducido dos nuevas clases de planificacin: de prioridad fija y de cuota equitativa. Las hebras de prioridad fija tienen el mismo rango de prioridades que las de tiempo compartido; sin embargo, sus prioridades no se ajustan dinmicamente. La clase de cuota equitativa usa cuotas de CPU en lugar de prioridades a la hora de tomar decisiones de planificacin. Las hebras de la clase de tiempo real, siempre les es asignada la prioridad ms alta. Para que tenga una respuesta asegurada del sistema dentro de un periodo limitado de tiempo. Un proceso de este tipo se ejecutar antes de cualquier otro. Cada clase de planificacin incluye un conjunto de prioridades. Sin embargo, el planificador convierte las prioridades especficas de una clase en prioridades globales y selecciona la hebra que tenga la prioridad global ms alta para ejecutarla. La hebra seleccionada se ejecuta en la CPU hasta que (1) se bloquea, (2) consume su cuanto de tiempo o (3) es desalojada por una hebra de prioridad ms alta. Si existen mltiples hebras con la misma prioridad, el planificador usa una cola y selecciona las hebras por turnos. Se puede decir que cada Sistema Operativo utiliza diferentes tipos de Algoritmos de Planificacin, pero algo que pude darme cuenta es que los mismos se basan en los Algoritmos de Planificacin estudiados. Por lo tanto podemos concluir que cada uno de los sistemas antes mencionados, utiliza una planificacin de acuerdo a sus necesidades, requerimientos y caractersticas diseadas, para favorecer los procesos que se deseen ejecutar, mejorar el rendimiento de la CPU y satisfacer las necesidades del usuario.