diff options
Diffstat (limited to 'iso/n2.lyx')
| -rw-r--r-- | iso/n2.lyx | 1232 |
1 files changed, 1232 insertions, 0 deletions
diff --git a/iso/n2.lyx b/iso/n2.lyx new file mode 100644 index 0000000..4a252fc --- /dev/null +++ b/iso/n2.lyx @@ -0,0 +1,1232 @@ +#LyX 2.3 created this file. For more info see http://www.lyx.org/ +\lyxformat 544 +\begin_document +\begin_header +\save_transient_properties true +\origin unavailable +\textclass book +\use_default_options true +\maintain_unincluded_children false +\language spanish +\language_package default +\inputencoding auto +\fontencoding global +\font_roman "default" "default" +\font_sans "default" "default" +\font_typewriter "default" "default" +\font_math "auto" "auto" +\font_default_family default +\use_non_tex_fonts false +\font_sc false +\font_osf false +\font_sf_scale 100 100 +\font_tt_scale 100 100 +\use_microtype false +\use_dash_ligatures true +\graphics default +\default_output_format default +\output_sync 0 +\bibtex_command default +\index_command default +\paperfontsize default +\spacing single +\use_hyperref false +\papersize default +\use_geometry false +\use_package amsmath 1 +\use_package amssymb 1 +\use_package cancel 1 +\use_package esint 1 +\use_package mathdots 1 +\use_package mathtools 1 +\use_package mhchem 1 +\use_package stackrel 1 +\use_package stmaryrd 1 +\use_package undertilde 1 +\cite_engine basic +\cite_engine_type default +\biblio_style plain +\use_bibtopic false +\use_indices false +\paperorientation portrait +\suppress_date false +\justification true +\use_refstyle 1 +\use_minted 0 +\index Index +\shortcut idx +\color #008000 +\end_index +\secnumdepth 3 +\tocdepth 3 +\paragraph_separation indent +\paragraph_indentation default +\is_math_indent 0 +\math_numbering_side default +\quotes_style french +\dynamic_quotes 0 +\papercolumns 1 +\papersides 1 +\paperpagestyle default +\tracking_changes false +\output_changes false +\html_math_output 0 +\html_css_as_file 0 +\html_be_strict false +\end_header + +\begin_body + +\begin_layout Standard +Normalmente hay bastantes más procesos que CPUs, por lo que hay que repartir + el uso de estas por parte de los procesos, buscando bien la eficiencia, + como en sistemas antiguos, o el poder ejecutar varios programas dando la + sensación de que todos se ejecutan a la vez, como ocurre actualmente. + El paralelismo y el pseudoparalelismo, que se dan normalmente a la vez, + permiten compartir recursos físicos y lógicos entre varios resultados y + acelerar los cálculos dividiéndolos entre varias CPUs, además de aportar + modularidad, al poder diseñar un sistema como un conjunto de procesos, + y comodidad, permitiendo a los usuarios hacer varias cosas a la vez. +\end_layout + +\begin_layout Standard +El cambio de un proceso a otro se llama +\series bold +cambio de proceso +\series default + o de +\series bold +contexto +\series default +. + El +\series bold +planificador +\series default + es el procedimiento que decide el siguiente proceso a ejecutar mediante + un +\series bold +algoritmo de planificación +\series default +, y modifica las estructuras necesarias para que el cambio de contexto sea + correcto. +\end_layout + +\begin_layout Standard +En UNIX, los procesos se organizan en un árbol de procesos y se crean con + la llamada al sistema +\family typewriter +fork() +\family default +, que crea una copia idéntica del proceso que hace la llamada y devuelve + al hijo el valor 0 y al padre el PID ( +\emph on +process identifier +\emph default +) del proceso hijo. + El PID del propio proceso se obtiene con la llamada al sistema +\family typewriter +getpid +\family default +. + Las llamadas de la familia +\family typewriter +exec +\family default +, como +\family typewriter +execve +\family default +, hacen que un proceso sustituya su código y datos por los de otro programa, + que comienza la ejecución desde el principio, si bien se conservan los + ficheros abiertos (aunque se puede especificar el cierre de algunos descriptore +s de ficheros en +\family typewriter +execve +\family default +), el PID y casi todas las propiedades. +\end_layout + +\begin_layout Standard +En Windows la jerarquía de procesos de UNIX desaparece al poder un proceso + cambiar de proceso padre, y los procesos se crean con +\family typewriter +CreateProcess +\family default +, que equivale a ejecutar un +\family typewriter +fork +\family default + seguido de +\family typewriter +exec +\family default + en el proceso hijo. +\end_layout + +\begin_layout Standard +La terminación voluntaria de un proceso se hace mediante la llamada al sistema + +\family typewriter +exit +\family default + en UNIX y +\family typewriter +ExitProcess +\family default + en Windows. + La terminación involuntaria es producida por el sistema operativo si se + produce un error fatal (división por cero, acceso a una zona memoria incorrecta +, etc.) o por otro proceso autorizado a ello con la llamada al sistema +\family typewriter +kill +\family default + en UNIX o +\family typewriter +TerminateProcess +\family default + en Windows. +\end_layout + +\begin_layout Section +Estados +\end_layout + +\begin_layout Standard +Un proceso puede estar en uno de varios estados: +\end_layout + +\begin_layout Itemize + +\series bold +Nuevo +\series default +: El proceso acaba de ser creado y todavía no tiene los recursos necesarios. +\end_layout + +\begin_layout Itemize + +\series bold +En ejecución +\series default +: Utilizando la CPU. +\end_layout + +\begin_layout Itemize + +\series bold +Listo +\series default + o +\series bold +listo suspendido +\series default +: Ejecutable pero detenido porque otro proceso está usando la CPU. +\end_layout + +\begin_layout Itemize + +\series bold +Bloqueado +\series default + o +\series bold +bloqueado +\series default + +\series bold +suspendido +\series default +: A la espera de un evento externo. +\end_layout + +\begin_layout Itemize + +\series bold +Saliente +\series default + ( +\emph on +zombie +\emph default +): El proceso ha terminado su ejecución pero todavía no ha desaparecido + del todo. + Por ejemplo, en UNIX, cuando un proceso acaba debe esperar a que su padre + recoja su estado de salida mediante la llamada al sistema +\family typewriter +wait +\family default + o +\family typewriter +waitpid +\family default +. +\end_layout + +\begin_layout Standard +Un proceso suspendido no puede ejecutarse y suele guardarse en disco. + La +\series bold +suspensión +\series default + y posterior +\series bold +reanudación +\series default + de un proceso, por parte de otro(s), es útil: +\end_layout + +\begin_layout Itemize +Si el sistema está funcionando mal, mientras se corrige el problema. +\end_layout + +\begin_layout Itemize +Si se cree que los resultados del proceso son incorrectos, para comprobar + si lo son. +\end_layout + +\begin_layout Itemize +Si el sistema está muy cargado, para dar servicio a procesos de más prioridad. +\end_layout + +\begin_layout Standard +Cambios de estado: +\end_layout + +\begin_layout Itemize +De +\begin_inset Quotes fld +\end_inset + +Nuevo +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Listo +\begin_inset Quotes frd +\end_inset + + cuando ya dispone de los recursos o a +\begin_inset Quotes fld +\end_inset + +Listo suspendido +\begin_inset Quotes frd +\end_inset + + si no hay memoria disponible y el proceso no tiene prioridad suficiente + para expulsar a otro. +\end_layout + +\begin_layout Itemize +De +\begin_inset Quotes fld +\end_inset + +Listo +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +En ejecución +\begin_inset Quotes frd +\end_inset + + o viceversa, debido al planificador. +\end_layout + +\begin_layout Itemize +De +\begin_inset Quotes fld +\end_inset + +En ejecución +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Bloqueado +\begin_inset Quotes frd +\end_inset + +, si el proces, ueado suspendido +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Listo suspendido +\begin_inset Quotes frd +\end_inset + +, cuando ocurre el evento esperado. +\end_layout + +\begin_layout Itemize +De +\begin_inset Quotes fld +\end_inset + +Bloqueado +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Bloqueado suspendido +\begin_inset Quotes frd +\end_inset + + o de +\begin_inset Quotes fld +\end_inset + +Listo +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Listo suspendido +\begin_inset Quotes frd +\end_inset + +, o viceversa. +\end_layout + +\begin_layout Itemize +De +\begin_inset Quotes fld +\end_inset + +En ejecución +\begin_inset Quotes frd +\end_inset + + a +\begin_inset Quotes fld +\end_inset + +Saliente +\begin_inset Quotes frd +\end_inset + + cuando termina. +\end_layout + +\begin_layout Section +Implementación +\end_layout + +\begin_layout Standard +El SO mantiene una +\series bold +tabla de procesos +\series default + con una entrada, +\series bold +PCB +\series default + ( +\emph on +Process Control Block +\emph default +) o BCP para cada proceso, donde se guarda todo lo necesario para poder + continuar la ejecución tras perder la CPU y recuperarla luego, junto con + datos estadísticos, el estado del proceso, etc. + En concreto suelen guardarse: +\end_layout + +\begin_layout Itemize +Para +\series bold +administración de procesos +\series default +, PID, registros (incluyendo contador del programa, palabra de estado y + puntero de pila), estado del proceso, prioridad, parámetros de planificación, + PID del proceso padre, grupo de procesos, señales, hora de inicio, tiempo + usado de CPU. +\end_layout + +\begin_layout Itemize +Para +\series bold +administración de memoria +\series default +, apuntadores a los segmentos de texto, datos, memoria dinámica. +\end_layout + +\begin_layout Itemize +Para +\series bold +administración de ficheros +\series default +, directorio raíz, directorio actual, descriptores de fichero, identificadores + de usuario y grupo. +\end_layout + +\begin_layout Standard +Crear un proceso consiste en darle nombre (como el PID en UNIX), insertarlo + en la tabla de procesos, determinar su prioridad inicial y asignarle recursos + iniciales. + En el caso de UNIX, +\family typewriter +fork +\family default + busca una entrada libre en la entrada de procesos y copia la información + del PCB del padre a esta, cambiando el PID; evita que uno sobrescriba la + memoria del otro +\begin_inset Foot +status open + +\begin_layout Plain Layout +Según los apuntes se copian los segmentos de datos y de pila, y el de código + se comparte por ser de sólo lectura. + Realmente, desde hace mucho Linux implementa copia en escritura, consistente + en marcar las entradas de la tabla de página de ambos de forma que el núcleo + solo tenga que hacer la copia de una página cuando uno de los procesos + escriba en ella. +\end_layout + +\end_inset + +; incrementa los contadores de los descriptores de ficheros del padre para + reflejar que estos también están abiertos en el hijo, y marca el proceso + hijo como +\begin_inset Quotes fld +\end_inset + +Listo +\begin_inset Quotes frd +\end_inset + +. +\end_layout + +\begin_layout Standard +Los procesos en UNIX tienen dos modos: modo usuario, en que ejecutan un + programa normal, y modo núcleo, común a todos los procesos, en que ejecutan + código del SO al hacer una llamada al sistema. + En este último los procesos pueden bloquearse esperando a algún evento, + lo que hace que se le ceda la CPU a otro proceso hasta que el evento suceda, + momento en que el proceso continuará su ejecución en modo núcleo. + Otro enfoque es considerar el SO como una colección de procesos de sistema + distintos a los procesos de usuario, de modo que cada proceso ejecuta sólo + código de usuario, lo que ocurre en los sistemas cliente-servidor. +\end_layout + +\begin_layout Standard +En las llamadas al sistema, el hardware almacena en una pila el contador + de programa del proceso que se interrumpe, pasa a modo núcleo y almacena + un elemento del vector de interrupciones, que debe ser la dirección de + inicio de alguna rutina del SO, en el contador de programa. + Entonces, un procedimiento guarda el contexto del proceso activo en su + PCB (pudiendo actualizarse otra información como estado, contabilidad o + auditoría), elimina la información introducida en la pila por el hardware, + configura una pila en el núcleo para la llamada al sistema, comprueba que + esta es válida y llama a un procedimiento que procesa la llamada. + Tras esta, el primer procedimiento ejecuta el planificador si lo determina + necesario, teniendo en cuenta que, si el proceso se ha bloqueado en la + llamada, este ya ha sido invocado y no es necesario llamarlo de nuevo, + y finalmente ejecuta el +\series bold +despachador +\series default +, que restaura el contexto del proceso a ejecutar, entre otras cosas cambiando + a la pila de usuario e introduciendo en esta la dirección de su contador + de programa. +\end_layout + +\begin_layout Section +Hilos +\end_layout + +\begin_layout Standard +Un proceso tradicional es: +\end_layout + +\begin_layout Itemize +Unidad de propiedad de recursos, con un espacio de direcciones, variables + globales, ficheros abiertos, procesos hijos, alarmas, señales, semáforos, + información contable, etc. +\end_layout + +\begin_layout Itemize +Unidad de planificación y ejecución, con un contador de programa, una serie + de registros, una pila y un estado. +\end_layout + +\begin_layout Standard +Estas funciones son independientes, y los sistemas operativos modernos llaman + +\series bold +hilos +\series default + ( +\emph on +threads +\emph default +), +\series bold +procesos ligeros +\series default + ( +\emph on +LightWeight Processes +\emph default +, LWP), +\series bold +hebras +\series default + o +\series bold +subprocesos +\series default + a las unidades de ejecución y procesos a las de propiedad de recursos, + de forma que un mismo proceso puede tener uno o varios hilos. + Cuando comienza la ejecución de un programa existe un único hilo, el +\series bold +hilo principal +\series default +, que puede crear otros. +\end_layout + +\begin_layout Standard +En Linux y otros muchos UNIX, un hilo puede crear otro mediante +\family typewriter +pthread_create +\family default +, que entre sus parámetros recibe un puntero a otra función que es donde + comienza la ejecución el hilo hijo. + Todo hilo tiene un TID ( +\emph on +thread identifier +\emph default +), que se obtiene desde el propio hilo con la llamada al sistema +\family typewriter +gettid +\family default +. + Para facilitar la colabolación entre hilos, que pueden necesitar acceder + y modificar las mismas variables globales, existen métodos de sincronización + como +\emph on +mutex +\emph default + (exclusión mutua) y semáforos. +\end_layout + +\begin_layout Standard +Ventajas de los hilos: +\end_layout + +\begin_layout Itemize +Al compartir espacio de direcciones, se pueden comunicar entre sí sin intervenci +ón del núcleo, por lo que esta comunicación es más rápida. +\end_layout + +\begin_layout Itemize +Los hilos se pueden bloquear mientras termina una llamada al sistema, por + lo que si hay varios, la E/S puede solaparse con el cómputo. +\end_layout + +\begin_layout Itemize +Es mucho más rápido crear un hilo en un proceso existente que un nuevo proceso, + y el cambio de uno a otro es más rápido. +\end_layout + +\begin_layout Itemize +Se puede conseguir paralelismo real dentro de un mismo proceso. +\end_layout + +\begin_layout Standard +Los hilos pueden ser soportados directamente por el núcleo, como en Windows + y Linux, o ser implementados mediante una biblioteca a nivel de usuario, + como se hacía en Linux antes de que implementara hilos en el núcleo. +\end_layout + +\begin_layout Standard +La implementación en modo usuario tiene como ventajas que el programa se + puede usar en núcleos que no implementan hilos, los cambios de contexto + son mucho más rápidos al no tener que pasar por el núcleo y cada proceso + puede tener un algoritmo distinto de planificación. + Sin embargo, en este caso una llamada al sistema bloqueante, o un fallo + de página, bloquearía a todos los hilos del proceso, y no es posible obtener + paralelismo real dentro de un mismo proceso. +\end_layout + +\begin_layout Standard +En la implementación en modo núcleo, la creación, destrucción y sincronización + entre hilos es más costosa, pero esto se puede aliviar usando una biblioteca + de sincronización que sólo realice llamadas al sistema cuando sea estrictamente + necesarios, y manteniendo las estructuras de un hilo después de que termine + para poder usarlo posteriormente en vez de crear otro nuevo. + En cualquier caso todos los hilos deben pasar a estado suspendido al mismo + tiempo, pues la memoria de todo el proceso se mueve al disco. +\end_layout + +\begin_layout Section +Planificación +\end_layout + +\begin_layout Standard +Metas: +\end_layout + +\begin_layout Itemize + +\series bold +Equidad +\series default +: Dar a cada proceso una proporción adecuada de CPU. +\end_layout + +\begin_layout Itemize +Maximizar la +\series bold +eficacia +\series default + de la CPU, +\begin_inset Formula $E:=\frac{\text{Tiempo útil}}{\text{Tiempo total}}\cdot100$ +\end_inset + +, y el +\series bold +rendimiento +\series default + o +\series bold +productividad +\series default +, el número de tareas procesadas por unidad de tiempo. +\end_layout + +\begin_layout Itemize +Minimizar el +\series bold +tiempo de espera +\series default + (el que pasa un proceso en estado +\begin_inset Quotes fld +\end_inset + +Listo +\begin_inset Quotes frd +\end_inset + +), el de +\series bold +respuesta +\series default + (el que pasa desde que se solicita la ejecución de una acción hasta que + se obtienen los primeros resultados, importante para usuarios interactivos) + y el de +\series bold +regreso +\series default + o +\series bold +retorno +\series default + (el que pasa desde que se entrega a un trabajo hasta que termina y se obtienen + sus resultados, importante para trabajos por lotes). +\end_layout + +\begin_layout Standard +Algunas de estas, como el tiempo de espera y la eficacia, son contradictorias. +\end_layout + +\begin_layout Standard +Una planificación es +\series bold +apropiativa +\series default + si puede expulsar a procesos de la CPU para ejecutar otros sin necesidad + de que se bloqueen, y +\series bold +no apropiativa +\series default + o +\series bold +de ejecución hasta terminar +\series default + en caso contrario. + Para los procesos por lotes son convenientes tanto una planificación no + apropiativa como una apropiativa con periodos de CPU largos (pues los cambios + de proceso desperdician CPU), mientras que para procesos interactivos suele + ser necesaria una planificación apropiativa para cambiar la CPU rápidamente + de un proceso a otro. +\end_layout + +\begin_layout Standard +Los procesos alternan entre ráfagas de CPU y de E/S, comenzando y terminando + por una de CPU. + Decimos que un proceso es +\series bold +limitado por E/S +\series default + si pasa la mayor parte de su tiempo en espera de E/S, y normalmente tendrá + muchas ráfagas de CPU aunque breves, y es +\series bold +limitado por CPU +\series default + si usa la CPU la mayor parte del tiempo, y normalmente tendrá pocas ráfagas + de CPU aunque muy largas. +\end_layout + +\begin_layout Standard +Podemos representar un algoritmo de planificación mediante un +\series bold +diagrama de colas +\series default +, en el que cada rectángulo es una cola, los círculos son recursos que dan + servicio a las colas y las flechas indican el flujo de los procesos. + Un +\series bold +diagrama de Gantt +\series default + representa el proceso en ejecución en cada momento mediante rectángulos + de longitud proporcional a la duración de la ráfaga de CPU. +\end_layout + +\begin_layout Standard +\begin_inset Float figure +wide false +sideways false +status open + +\begin_layout Plain Layout +\align center +\begin_inset Graphics + filename pegado3.png + width 80text% + +\end_inset + + +\end_layout + +\begin_layout Plain Layout +\begin_inset Caption Standard + +\begin_layout Plain Layout +Diagrama de colas de planificación de procesos. +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard +\begin_inset Float figure +wide false +sideways false +status open + +\begin_layout Plain Layout +\align center +\begin_inset Graphics + filename pegado4.png + width 80text% + +\end_inset + + +\end_layout + +\begin_layout Plain Layout +\begin_inset Caption Standard + +\begin_layout Plain Layout +Diagrama de Gantt. +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard +Algoritmos no apropiativos: +\end_layout + +\begin_layout Itemize + +\series bold +FCFS +\series default + ( +\emph on +First Coming, First Served +\emph default +, +\begin_inset Quotes fld +\end_inset + +primero en llegar, primero en ser servido +\begin_inset Quotes frd +\end_inset + +). + Es el más simple y se puede implementar con una cola FIFO. + El tiempo medio de respuesta puede ser bastante largo debido al +\series bold +efecto convoy +\series default +: Un proceso limitado por CPU ocupa la CPU mucho tiempo mientras el resto + terminan su E/S y entonces los dispositivos de E/S quedan inactivos hasta + que el proceso en ejecución pasa a realizar su E/S; entonces los procesos + limitados por E/S pasan a usar la CPU y terminan rápido por tener ráfagas + de CPU breves y la CPU queda inactiva hasta que el proceso limitado por + CPU continúa su ejecución, momento en que el ciclo se repite, resultando + en desaprovechamiento de recursos. +\end_layout + +\begin_layout Itemize + +\series bold +SJF +\series default + ( +\emph on +Shortest Job First +\emph default +, +\begin_inset Quotes fld +\end_inset + +primero el trabajo más corto +\begin_inset Quotes frd +\end_inset + +). + Adecuado para procesos por lotes, donde los tiempos de ejecución aproximados + se suelen conocer de antemano, y de lo contrario se puede estimar mediante + +\series bold +maduración +\series default +: +\begin_inset Formula $E_{t}=aE_{t-1}+(1-a)T_{t-1}$ +\end_inset + +, donde +\begin_inset Formula $E_{t}$ +\end_inset + + es la estimación de tiempo actual, +\begin_inset Formula $E_{t-1}$ +\end_inset + + la estimación anterior para el mismo proceso, +\begin_inset Formula $T_{t-1}$ +\end_inset + + el tiempo que tardó realmente y +\begin_inset Formula $a$ +\end_inset + + un parámetro ajustable entre 0 y 1, pues un valor de +\begin_inset Formula $a$ +\end_inset + + pequeño hace que se olviden rápidamente los tiempos de ejecuciones anteriores + y un valor grande hace que se recuerden demasiado tiempo. + Si se dispone de todos los procesos de forma simultánea, este algoritmo + proporciona el mínimo tiempo medio de retorno. +\end_layout + +\begin_layout Standard +Algoritmos apropiativos: +\end_layout + +\begin_layout Itemize + +\series bold +SRTF +\series default + ( +\emph on +Shortest Remaining Time First +\emph default +, +\begin_inset Quotes fld +\end_inset + +primero el que tenga el menor tiempo restante +\begin_inset Quotes frd +\end_inset + +). + Variante del SJF que permite quitar la CPU a un proceso para dársela a + otro con tiempo total de ráfaga de CPU menor al tiempo restante de CPU + de la ráfaga del proceso que se está ejecutando. +\end_layout + +\begin_layout Itemize + +\series bold +\emph on +Round Robin +\series default +\emph default + ( +\series bold +RR +\series default +) o +\series bold +circular +\series default +. + Es de los más antiguos, sencillos, equitativos y de mayor uso. + Similar al FCFS pero con un +\emph on +quantum +\emph default + de tiempo +\begin_inset Formula $q$ +\end_inset + + tal que, si un proceso consume un +\emph on +quantum +\emph default +, pasa al final de la cola de procesos listos para dar la CPU al siguiente + proceso. + De esta forma, si hay +\begin_inset Formula $n$ +\end_inset + + procesos, ninguno tiene tiempo de espera mayor a +\begin_inset Formula $(n-1)q$ +\end_inset + +. + Si +\begin_inset Formula $q$ +\end_inset + + es pequeño se desperdicia tiempo de CPU en cambios de proceso, pero si + es grande, los últimos procesos tardan mucho en ser atendidos, resultando + en tiempos de respuesta muy pobres en procesos interactivos. +\end_layout + +\begin_layout Standard +Otras formas de planificación pueden hacerse apropiativas o no apropiativas: +\end_layout + +\begin_layout Itemize + +\series bold +Planificación por prioridad +\series default +. + Cada proceso tiene una prioridad, normalmente un número que es mayor a + mayor prioridad (en UNIX es al revés), de modo que la CPU se da al primer + proceso de la cola con la mayor prioridad. + La asignación de prioridad puede ser +\series bold +estática +\series default +, si no cambia durante la ejecución del proceso, o +\series bold +dinámica +\series default + si depende de parámetros. + Un ejemplo de asignación dinámica para favorecer a los procesos limitados + por E/S, y que puedan ejecutarse pronto para enviar su siguiente solicitud + de E/S, es hacer que la prioridad sea inversamente proporcional a la fracción + del último +\emph on +quantum +\emph default + usado por el proceso. + Este +\emph on +quantum +\emph default + puede ser una referencia para medir el tiempo consumido o funcionar como + en la planificación +\emph on +round-robin +\emph default +. +\begin_inset Newline newline +\end_inset + +El +\series bold +bloqueo indefinido +\series default + o +\series bold +inanición +\series default + ocurre cuando los procesos de baja prioridad nunca llegan a ejecutarse. + Para evitarlo se puede disminuir cada cierto tiempo la prioridad del proceso + en ejecución, lo que tiene sentido si la planificación es apropiativa. + Esto sigue teniendo el problema de que pueden llegar continuamente procesos + de mayor cantidad que los que llevan tiempo esperando, por lo que una alternati +va es aumentar cada cierto tiempo la prioridad de los procesos listos. +\end_layout + +\begin_layout Itemize + +\series bold +Planificación de múltiples colas con realimentación +\series default +. + Es la más general, pero también la más compleja. + Existen varias colas de procesos listos y un proceso va a una u otra según + si es interactivo o por lotes, de sistema o de usuario, su prioridad, la + cola que usó la última vez, el consumo de CPU, etc. + Debe haber una planificación dentro de cada cola, y una planificación entre + colas, que suele ser apropiativa por prioridad pero puede ser cualquiera, + como el reparto equitativo y que cada cola se administre de una forma. + Para evitar que el esquema sea inflexible, debe haber un criterio para + que los procesos cambien de cola (realimentación). +\end_layout + +\begin_layout Standard +\begin_inset Float figure +wide false +sideways false +status open + +\begin_layout Plain Layout +\align center +\begin_inset Graphics + filename pegado5.png + width 80text% + +\end_inset + + +\end_layout + +\begin_layout Plain Layout +\begin_inset Caption Standard + +\begin_layout Plain Layout +Planificación de múltiples colas. +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard +Si no se dispone de suficiente memoria es necesario que algunos procesos + se mantengan en disco. + Para ello, los procesos en memoria los gestiona un +\series bold +planificador a corto plazo +\series default + (PCP) mientras que un +\series bold +planificador a medio plazo +\series default + (PMP) es llamado periódicamente y se encarga de la suspensión y reanudación + de procesos, teniendo en cuenta criterios como el tiempo desde el último + intercambio, el tiempo de CPU que ha consumido el proceso recientemente, + el tamaño del proceso (los pequeños no causan problemas) y la prioridad + de este. + También es posible añadir un +\series bold +planificador a largo plazo +\series default + (PLP) que decida, de entre los procesos por lotes preparados, cuál ejecutar + después, eligiendo si este pasa directamente a memoria o a disco. +\end_layout + +\begin_layout Standard +\begin_inset Note Comment +status open + +\begin_layout Plain Layout +\begin_inset Float figure +wide false +sideways false +status open + +\begin_layout Plain Layout +\align center +\begin_inset Graphics + filename pegado6.png + width 80text% + +\end_inset + + +\end_layout + +\begin_layout Plain Layout +\begin_inset Caption Standard + +\begin_layout Plain Layout +Planificación a corto, medio y largo plazo. +\end_layout + +\end_inset + + +\end_layout + +\end_inset + + +\end_layout + +\end_inset + + +\end_layout + +\end_body +\end_document |