Tema 3 - La gestión de los recursos y de la memoria
1. Gestión de procesos ............................................................................................. 2
1.1 Bloque de control de proceso (BCP) ..................................................................... 3
1.2 Estados de un proceso .......................................................................................... 4
2. Algoritmos de planificación ................................................................................. 6
2.1 FIFO (First In First Out) - FCFS (first come first served)......................................... 8
2.2 SJF (shortest job first) ........................................................................................... 8
2.3 SRT (shortest remaining time first) ........................................................................ 8
2.4 RR (round-robin) o asignación cíclica o planificación en rueda ............................. 9
3. Gestión de la memoria............................................................................................ 10
3.1 Técnicas de gestión de memoria......................................................................... 11
3.1.1 Gestión de memoria con particiones fijas ..................................................... 11
3.1.2 Gestión de memoria con particiones variables ............................................. 12
3.1.3 Memoria virtual............................................................................................. 13
El sistema operativo gestiona el acceso a los recursos del sistema informático. En
este tema veremos cómo gestiona los accesos a CPU, Memoria Principal (RAM) y
dispositivos de E/S. La buena gestión de un sistema informático se basa en equilibrar
dos de sus elementos principales: los procesos y los recursos.
1. Gestión de procesos
Como los recursos suelen ser escasos, los procesos compiten por su uso, lo que
obliga a que el sistema operativo medie entre los procesos para asignar los recursos
de una forma imparcial y eficiente. Podemos definir un proceso como una instancia de
un programa en ejecución que es creado y gestionado por el sistema operativo.
Cuando se solicita (por parte del sistema operativo o del usuario), la ejecución de
un programa, éste se carga en memoria principal (RAM). Todo proceso va a necesitar
una serie de recursos para poder realizar su trabajo.
El sistema operativo es el encargado de coordinar y controlar todos los recursos y
condiciones de ejecución que necesitan los procesos. Ya vimos en la primera unidad,
que los sistemas operativos se clasifican según el número de procesos que se pueden
ejecutar simultáneamente en monotarea y multitarea.
Los sistemas operativos multitarea tienen que encargase de determinar qué
proceso se ejecuta en un momento determinado y evitar conflictos entre procesos a la
hora de acceder a recursos. La gestión de procesos incluye:
• La creación y destrucción de procesos.
• La gestión de tiempo compartido: decidir qué proceso y durante cuánto tiempo
se ejecuta este implica que el sistema operativo se encargará de pausar
(suspender) y reanudar la ejecución.
• La sincronización y comunicación entre los procesos. Los procesos deben
sincronizarse entre sí para asegurar que las tareas que pretenden realizar se
completen
¿Quién es el responsable de su ejecución?
• Proceso de sistema: los ejecuta el propio sistema operativo
• Proceso de usuario: los ejecutados por un usuario, que puede ser físico (una
persona), o una tarea programada.
Según su interactuación con el usuario los procesos pueden ser:
• Interactivo o en primer plano: es con el que interactúa el usuario de una forma
directa. Ejemplo: un procesador de textos.
• En segundo plano: son aquellos con los que el usuario no tiene interacción
directa. En Linux son conocidos como “demonios”. Ejemplo: servicios del sistema.
1.1 Bloque de control de proceso (BCP)
Para llevar a cabo la gestión de los procesos, el sistema operativo necesita
guardar cierta información sobre ellos. Existe un registro especial donde se almacena
esta información y que se conoce como bloque de control del proceso (BCP).
El BCP es creado por el sistema operativo cada vez que aparece un nuevo proceso y
guarda la información que necesita el sistema operativo para controlar el proceso.
Difiere mucho de un sistema a otros, pero existen informaciones comunes y son las
siguientes:
• PID(Process Identifier): identificador único del proceso.
• Estado del proceso
• Prioridad: define la importancia que el planificador de procesos debe conceder
a tal proceso. Cuanto más prioritario sea, más tiempo de procesador tendrá
asignado.
• Uso de memoria: la cantidad de memoria asignada al proceso
• Recursos asignados : dispositivos de entrada/salida asignados al proceso, lista
de archivos abiertos con los que trabaja
• Propietario del proceso (sistema operativo o usuario).
1.2 Estados de un proceso
Los estados de un proceso son almacenados en su PCB. Pueden ser los
siguientes:
• Creado: el proceso existe pero aún no se la ha notificado al procesador
• Listo (preparado o en espera de ejecución): en un proceso en este estado, no
se están ejecutando órdenes, pero está a disposición del sistema para que
cuando el procesador quede libre pueda pasar a estar en ejecución.
• Ejecución: el proceso está ejecutándose en la CPU. Estando en ejecución,
puede cambiar de estado por varias causas…
o Porque ha finalizado su ejecución.
o Porque haya terminado el tiempo asignado de CPU
o Porque ocurra un evento externo que lo bloquee
• Bloqueado: el proceso está a la espera de un recurso no disponible u ocupado.
Cuando el recurso quede libre, el proceso pasará a estado “Listo”.
• Zombie: exclusivo de los sistemas basados en UNIX. El proceso está finalizado
pero no se ha podido borrar su PCB y sigue figurando en la cola de procesos.
• Terminado: ha finalizado la ejecución del proceso o el sistema operativo ha
detectado un error fatal y lo ha transferido a dicho estado
• Suspendido: el proceso se detiene a petición del usuario. Durante el tiempo en
el que esté en suspensión, no va a entrar en el planificador. Al reactivar el
proceso, pasará a estado “Listo”.
La explicación de las transiciones entre estados de la figura es la siguiente:
El sistema operativo posee un módulo que gestiona los procesos llamado
distribuidor que se encarga de activar los procesos que están en la cola de listos o
preparados de acuerdo con unos criterios por ejemplo, en función de la prioridad.
El proceso en ejecución puede volver a la cola de procesos listos o preparados por
ejemplo, si hay un proceso con una prioridad mayor o si ha finalizado el tiempo que se
le había asignado para usar el procesador
Un proceso bloqueado puede pasar a la cola de procesos preparados si ocurre el
evento o suceso que estaba esperando para poder ejecutarse.
Un proceso en ejecución puede pasar a la cola de procesos bloqueados si solicita un
recurso que no está disponible y sin el que no puede continuar. Por ejemplo, está
esperando a que el usuario introduzca un dato por teclado.
Un proceso pasa al estado terminado cuando finaliza o el sistema operativo detecta un
error fatal.
El sistema operativo crea varias colas en las que coloca a los procesos según el
estado en el que se encuentran:
• El planificador a largo plazo se encarga de gestionar aquellos que están en
la cola de bloqueados.
• El planificador a corto plazo se encarga de gestionar aquellos que están en
la cola de listos o preparados asignándoles el recurso que corresponda ya
sea el procesador o un dispositivo de E/S (entrada/salida.
2. Algoritmos de planificación
La planificación de la CPU es la base de los sistemas operativos multitarea.
Alternando el uso de la CPU entre los distintos procesos a ejecutar, el sistema
operativo consigue que el ordenador sea más productivo.
Los algoritmos de planificación son las políticas que se seguirán para elegir qué
proceso entra en cada momento a ejecutarse en el procesador.
Para elegir una política planificación se siguen los siguientes criterios:
• Maximizar la utilización y productividad de la CPU.
• Minimizar el tiempo de servicio, el tiempo de espera y el índice se servicio
La multiprogramación significa que varios programas que están en memoria al
mismo tiempo pueden compartir la CPU con la intención de mejorar la eficiencia del
sistema realizando más trabajo en menos tiempo
Para estudiar y evaluar el comportamiento de las distintas políticas de
planificación se definen las siguientes variables:
• ti es el instante en que el usuario solicita la ejecución del proceso.
• tf es el instante en el que el proceso termina su ejecución.
• t es el tiempo de procesador o el tiempo que un proceso necesita estar en
ejecución para llevar a cabo el trabajo para el que ha sido creado.
• Tiempo de servicio (Ts) es el tiempo que necesita un proceso para ejecutarse.
Ts = tf – ti
• Tiempo de espera (Te) es el tiempo que permanece un proceso en el sistema
sin que se esté ejecutando. Te = Ts – t
• Índice de servicio (I) es el tanto por uno de tiempo que el proceso está en
ejecución respecto al tiempo de vida del mismo en el sistema. Su valor máximo
es 1. I=t/Ts
Las políticas de planificación se pueden dividir en:
• Apropiativas: permiten que un proceso con mayor prioridad quite la CPU al
proceso que se está ejecutando antes de su finalización.
Inconvenientes: el coste de tiempo al cambiar de proceso, la coordinación del
acceso a datos compartidos y evitar que estructuras de datos del núcleo puedan
quedar inconsistentes por los cambios de contexto.
• No apropiativas: una vez que un proceso obtiene la CPU no se le puede quitar
hasta que no acabe su ejecución.
Inconvenientes: acaparamiento injusto de la CPU.
Para representar los diferentes algoritmos de planificación usamos el diagrama de Gant.
Un diagrama de Gant es un gráfico en el que vamos dibujando el tiempo que ocupa
cada uno de los procesos el procesador.
Para obtener el valor tf de cada proceso hay que contar los cuadrados
correspondientes, con los que se simplifica notablemente la tarea.
2.1 FIFO (First In First Out) - FCFS (first come first served)
Este algoritmo también se conoce como "primero en entrar, primero en salir". El
proceso que toma la CPU no la abandonará hasta acabar. El primer proceso que
llega es el primero al que se le asigna CPU. Propiedades de esta política:
• El algoritmo FCFS es justo pero los procesos largos harán esperar a los procesos
cortos.
• Es muy predecible.
• Los tiempos medios de Servicio suelen ser demasiado grandes y dependen
mucho del orden de llegada de los procesos
• Es no apropiativa.
• La prioridad se establece por el orden de llegada.
2.2 SJF (shortest job first) tareas por lotes: son las tareas de las que no tenemos el control
tareas inetactivas: son las que podemos modificar y controlar
Al igual que FIFO, ejecuta el proceso sin interrupciones a no ser que el recurso
quede bloqueado. El algoritmo SJF prima a los procesos cortos. Esta política escoge
de la cola de procesos preparados el proceso que necesite estar menos tiempo en el
sistema para realizar su trabajo. Propiedades de esta política:
• El algoritmo SJF penaliza los procesos largos.
• Es poco predecible.
• Es más apropiada para tareas por lotes que para tareas interactivas
• Es no apropiativa.
• La prioridad se establece por el tamaño de los procesos.
• La regulación se lleva a cabo eligiendo el de más prioridad o el más
antiguo en caso de empate
2.3 SRT (shortest remaining time first)
Es una modificación del SJF para convertir el algoritmo anterior en apropiativo.
Consiste en que si se carga un proceso nuevo en el sistema cuyo tiempo de ejecución
sea más corto que el tiempo restante del que está en ejecución, el planificador del
sistema operativo lo interrumpe y lo cambia. Propiedades de esta política:
• El algoritmo SRT es injusto ya que un proceso corto puede echar a uno
largo que está utilizando el procesador y que está terminando de
ejecutarse.
• Produce una gran sobrecarga del procesador ya que hay que mantener
un registro con los tiempos de ejecución restante de cada proceso.
• Conserva las dificultades de implementación de la política anterior ya
que hay que saber el tiempo de ejecución del proceso con antelación.
• Es apropiativa.
• El cálculo de la prioridad se hace en tiempo real. Depende de cada
proceso y del que se está ejecutando.
• La regulación se lleva a cabo eligiendo el de más prioridad o el más
antiguo en caso de empate.
2.4 RR (round-robin) o asignación cíclica o planificación en rueda
El diseño del algoritmo RR consiste en definir una unidad de tiempo llamada
quantum, de forma que los procesos ya no pelean por los recursos sino que se les
asignan equitativamente a todos ellos un turno o quantum
Cuando un proceso llega al planificador se coloca al final de la cola de procesos
preparados. Lo mismo sucede cuando un proceso agota su quantum de tiempo. El
tamaño del quantum puede variar lo que modificará el rendimiento del sistema:
• Si el quantum es muy grande este algoritmo se comportará como el FCFS.
• Si el quantum es muy pequeño este algoritmo producirá sobrecarga en el
sistema porque el tiempo se consume en cambios de contexto.
Propiedades de esta política:
• El algoritmo RR producirá baja sobrecarga en el sistema si el tamaño del
quantum es el adecuado y si los cambios de contexto se hacen de forma
eficiente.
• El rendimiento depende del tamaño del quantum.
• Es fácil de implementar. Es por ello que es la política más utilizada en los
sistemas de tiempo compartido
• Es apropiativa.
• El cálculo de la prioridad se hace por orden de llegada.
• La regulación se lleva a cabo mediante turnos lo que lleva a una rueda que se
repite hasta que se terminen de ejecutar todos los procesos.
3. Gestión de la memoria
Antes de estudiar cómo el sistema operativo gestiona la memoria, es preciso recordar
tres aspectos:
• La ejecución de todo programa supone que tanto su código como los datos que
manipula se carguen en memoria RAM.
• La memoria está dividida en celdas, cuyo contenido constituye una palabra, en
general de un byte (8 bits). A cada palabra, se le asigna una dirección de
memoria.
• Espacio físico de memoria: tamaño total de la memoria. El espacio de la
memoria es bastante limitado debido al elevado precio de la RAM. Esta limitación
de espacio, hace indispensable que el sistema operativo gestione su uso.
El reparto de la memoria entre los procesos lo realiza una parte del sistema operativo
que se conoce como gestor de memoria. Su labor es asignar a los procesos aquellas
partes de memoria principal que se encuentran desocupadas mediante el traspaso de
información desde la memoria secundaria a la principal.
Esto sucede cuando la memoria RAM no es lo suficientemente grande para acoger
simultáneamente a todos los procesos que es prácticamente siempre.
Con la llegada del concepto de multiusuario apareció la necesidad de repartir la
memoria principal entre varios usuarios y se hizo necesario habilitar un mecanismo de
protección que aislara cada actividad de los programas. Por lo tanto para realizar una
buena gestión habrá que proteger, compartir y reasignar la memoria dinámicamente.
• Proteger: al existir la posibilidad de que varios procesos compartan la memoria
principal, hay que asegurarse de que ninguno de ellos pueda acceder al
contenido de la memoria asignada a otro.
• Compartir: en ocasiones es necesario compartir el acceso a la memoria principal
pues se pueden tener varios procesos que deban acceder al mismo bloque de
memoria (por ejemplo en las bases de datos).
• Reasignar: el gestor de memoria debe resolver las peticiones de acceso a la
memoria por parte de los procesos. Esto lo resuelve mediante la recolocación en
memoria usando direcciones relativas que permiten cargar el programa en
cualquier parte de la memoria.
3.1 Técnicas de gestión de memoria
La memoria se divide en bloques que ocupan direcciones contiguas de memoria. Cada
bloque es denominado partición.
Se conoce como registro base a la dirección de memoria donde comienza la partición.
Se conoce como registro límite a la dirección de memoria donde termina la partición. La
partición tiene un tamaño concreto
Las técnicas de gestión de la memoria son: Particiones fijas, particiones variables y
Memoria virtual.
3.1.1 Gestión de memoria con particiones fijas
La memoria se divide en particiones de un tamaño fijo que no cambia durante la
ejecución y cada partición está ocupada solamente por un proceso.
En la imagen se representa en negro el espacio ocupado por un proceso y en blanco, el
espacio desaprovechado de cada partición.
Si el proceso cargado en una partición es más pequeño que la partición, se
desaprovecha espacio, produciéndose fragmentación interna.
Si una partición es tan pequeña que no cabe en ella ningún proceso, ese espacio se
estará desperdiciando, produciéndose fragmentación externa
3.1.2 Gestión de memoria con particiones variables
Al trabajar con particiones fijas nos encontramos con un grave problema: cómo
determinar el tamaño de partición más apropiado a priori para que se minimicen los
problemas de fragmentación interna y externa.
La solución es permitir que los tamaños de las particiones varíen de forma que cada
proceso ocupe el tamaño que necesite, de este modo, su tamaño de memoria estará
asignado y no existirá fragmentación interna
Al principio, toda la memoria que no está ocupada por el sistema operativo está
disponible y puede considerarse como un solo bloque.
Cuando un proceso demanda memoria, el gestor de memoria busca un hueco que
sea lo suficientemente grande para asignárselo de forma que el resto de la memoria
queda disponible para ser asignada a futuras solicitudes de otros procesos.
Cuando la ejecución del proceso termina, el bloque de memoria ocupado queda libre y
es devuelto al conjunto de bloques libres.
A medida que los procesos terminan van quedando huecos libres en la posición que
ocupaban por lo que surgen de nuevo problemas de fragmentación.
Ejemplo:
-En un principio, tenemos los procesos A, B y C ocupando tres particiones contiguas
ubicadas en el principio de la memoria:
-Ahora, el proceso B termina y se libera el espacio que se le había concedido:
-El proceso D entra en ejecución, pero el espacio que requiere en memoria es más
pequeño que el que tenía asignado el proceso B. En la representación gráfica siguiente,
veremos cómo se desaprovechará espacio entre la segunda y la tercera partición:
La solución es compactar (cuando los haya) dos huecos libres contiguos para crear uno
mayor.
Esta compactación también puede mover todos los procesos a un extremo de la
memoria para que todo el espacio libre quede contiguo al principio o al final de la misma
3.1.3 Memoria virtual
La memoria virtual es una técnica que, utilizando la memoria secundaria permite
ejecutar programas más grandes que el tamaño de la memoria principal.
Mediante esta técnica el espacio libre que existe en el disco duro se usa virtualmente
como memoria RAM.
Los programas que se están ejecutando tendrán partes en la memoria principal y el resto
en la memoria secundaria.
Si en un determinado instante varios fragmentos de un programa están ejecutándose y
alguno de ellos hace referencia a otro trozo aún no cargado en la memoria principal se
produce lo que se llama un fallo de página.
Cuando se produce el fallo de página, el sistema operativo tendrá que llevar a la
memoria principal el trozo pedido.
Si la memoria está llena tendrás que sacar de la misma un trozo antes de añadir otro.
Para decidir cuál se usan unos algoritmos.
Algunos de estos algoritmos son:
• LRU (Least Recently Used): se reemplaza la página que se usó hace más tiempo
y que no tiene por qué ser la que lleve más tiempo en la memoria.
• FIFO (First In, First Out): la primera página que llega es la primera que se
reemplaza.
• Óptimo: es un algoritmo teórico que prevé cuáles serán las siguientes peticiones
de página.
Cuando el sistema operativo pasa más tiempo ocupado con el intercambio de
fragmentos que con la ejecución de los mismos se produce el problema conocido como
hiperpaginación.
Las técnicas que se utilizan para usar la memoria secundaria como memoria virtual son
• La paginación: consiste en dividir la memoria en zonas fijas llamadas frames o
marcos de página y los programas en porciones iguales a estos marcos
denominados páginas.
Con esta técnica el sistema operativo utiliza una tabla de páginas para cada
proceso y una tabla de marcos de páginas libres para realizar las asignaciones.
La tabla de páginas sirve para establecer la correspondencia entre páginas del
programa y marcos de memoria física
• La segmentación. En la técnica de segmentación, el programa se divide en
segmentos que se diferencian de las páginas en que su tamaño no es fijo
aunque sí existe un tamaño máximo de segmento. Para gestionarlos se usa una
tabla de segmentos para cada proceso donde almacenamos la dirección de
comienzo y el tamaño de cada uno de ellos y otra tabla de segmentos libres
para asignárselos a los procesos que entren en ejecución
