Resumen Introduccion A Los Sistemas Operativos

INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS | 2023
Contenido
INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS ............................................................................................................ 2
Definición de Sistema Operativo ............................................................................................................................... 2
Funciones de los sistemas operativos ....................................................................................................................... 2
Características de los sistemas operativos ................................................................................................................. 3
Clasificación de los Sistemas Operativos................................................................................................................... 3
Sistemas Operativos de multiprogramación (o Sistemas Operativos de multitarea). .......................................... 3
Sistema Operativo Monotareas. ........................................................................................................................... 4
Sistema Operativo Monousuario. ......................................................................................................................... 4
Sistema Operativo Multiusuario. .......................................................................................................................... 5
Sistemas Operativos de tiempo real. .................................................................................................................... 5
Sistemas Operativos de Tiempo Compartido. ....................................................................................................... 6
Sistemas Operativos Distribuidos.......................................................................................................................... 6
Sistemas Operativos de Red. ................................................................................................................................. 7
Sistemas Operativos Paralelos. ............................................................................................................................. 7
Arquitectura de los Sistema Operativo UNIX/LINUX................................................................................................. 7
GESTIÓN DE PROCESOS ............................................................................................................................................ 9
Procesos .................................................................................................................................................................... 9
El sistema operativo y los procesos........................................................................................................................... 9
Tipos de procesos y relación entre procesos concurrentes ................................................................................ 10
Estados de un proceso ............................................................................................................................................ 10
Modelo de dos estados ....................................................................................................................................... 10
Modelo de 5 estados ........................................................................................................................................... 11
Planificación de Procesos y Subprocesos. Hilos ...................................................................................................... 14
Planificación de procesos .................................................................................................................................... 14
Utilización del procesador: .................................................................................................................................. 14
Tipos de planificadores........................................................................................................................................ 15
Subproceso .......................................................................................................................................................... 16
Características de los subprocesos ...................................................................................................................... 18
Hilos ......................................................................................................................................................................... 18
Sistemas Multihilo ............................................................................................................................................... 18
GESTIÓN DE MEMORIA........................................................................................................................................... 21
¿Qué es la memoria? ............................................................................................................................................... 21
¿Quién administra la memoria? .............................................................................................................................. 21
¿Qué es la memoria real?........................................................................................................................................ 21
Gestión de Memoria Real .................................................................................................................................... 21
Memoria Virtual ...................................................................................................................................................... 25
Políticas de Asignación Local y Global ................................................................................................................. 26
Control de Carga .................................................................................................................................................. 28
Tamaño de Página ............................................................................................................................................... 29
pág. 1
INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS

Definición de Sistema Operativo
Un sistema operativo puede ser contemplado como una colección organizada de extensiones software del
hardware, consistente en rutinas de control que hacen funcionar al computador y proporcionan un entorno para
la ejecución de programas. Además, estos programas utilizan las facilidades proporcionadas por el sistema
operativo para obtener acceso a recursos del sistema informático como el procesador, archivos y dispositivos de
entrada/salida (E/S). De esta forma, el SO constituye la base sobre la cual pueden escribirse los programas de
aplicación, los cuales invocarán sus servicios por medio de llamadas al sistema. Por otro lado, los usuarios pueden
interactuar directamente con el SO a través de órdenes concretas. En cualquier caso, el SO actúa como interfaz
entre los usuarios/aplicaciones y el hardware de un sistema informático.
El rango y la extensión de los servicios proporcionados por un SO dependen de varios factores.
Así, las funciones visibles al usuario están en gran medida determinadas por la necesidades y características del
entorno objetivo que el SO está destinado a soportar. Por ejemplo, un SO destinado al desarrollo de programas en
un entorno interactivo puede tener un conjunto bastante diferente de llamadas y órdenes que un sistema
operativo diseñado para soporte en tiempo de ejecución a una aplicación de tiempo real dedicada, tal como el
control del motor de un coche, el control del reactor de una central nuclear o el sistema de actualizaciones
derivado de las operaciones de un cajero automático de una entidad bancaria.
Internamente, un SO actúa como gestor de los recursos del sistema informático tales como el procesador, la
memoria, los archivos y los dispositivos de E/S. En esa función, el SO mantiene actualizada la información relativa
al estado de sistemas que soportan la ejecución concurrente de programas, el SO resuelve las peticiones
conflictivas de recursos de manera que preserve la integridad del sistema y al hacerlo intenta optimizar el
rendimiento final.
En general, el SO presenta al usuario el equivalente de una máquina virtual que sea más fácil de utilizar que la
máquina subyacente y uno de sus objetivos primarios es incrementar la productividad de los recursos que ofrece
al sistema mediante una planificación lo más óptima posible de ellos.
Funciones de los sistemas operativos

1. Aceptar todos los trabajos y conservarlos hasta su finalización.
2. Interpretación de comandos: Interpreta los comandos que permiten al usuario comunicarse con el
ordenador.
3. Control de recursos: Coordina y manipula el hardware de la computadora, como la memoria, las
impresoras, las unidades de disco, el teclado o el Mouse.
4. Manejo de dispositivos de E/S: Organiza los archivos en diversos dispositivos de almacenamiento, como
discos flexibles, discos duros, discos compactos o cintas magnéticas.
5. Manejo de errores: Gestiona los errores de hardware y la pérdida de datos.
6. Secuencia de tareas: El sistema operativo debe administrar la manera en que se reparten los procesos.
Definir el orden. (Quien va primero y quien después).
pág. 2
7. Protección: Evitar que las acciones de un usuario afecten el trabajo que esta realizando otro usuario.
8. Multiacceso: Un usuario se puede conectar a otra máquina sin tener que estar cerca de ella.
9. Contabilidad de recursos: establece el costo que se le cobra a un usuario por utilizar determinados
recursos.
Características de los sistemas operativos.

En general, se puede decir que un Sistema Operativo tiene las siguientes características:
 Conveniencia. Un Sistema Operativo hace más conveniente el uso de una computadora.

 Eficiencia. Un Sistema Operativo permite que los recursos de la computadora se usen de la manera más
eficiente posible.
 Habilidad para evolucionar. Un Sistema Operativo deberá construirse de manera que permita el
desarrollo, prueba o introducción efectiva de nuevas funciones del sistema sin interferir con el servicio.
 Encargado de administrar el hardware. El Sistema Operativo se encarga de manejar de una mejor manera
los recursos de la computadora en cuanto a hardware se refiere, esto es, asignar a cada proceso una parte
del procesador para poder compartir los recursos.
 Relacionar dispositivos (gestionar a través del kernel). El Sistema Operativo se debe encargar de
comunicar a los dispositivos periféricos, cuando el usuario así lo requiera.
 Organizar datos para acceso rápido y seguro.

 Manejar las comunicaciones en red. El Sistema Operativo permite al usuario manejar con alta facilidad
todo lo referente a la instalación y uso de las redes de computadoras.
 Procesamiento por bytes de flujo a través del bus de datos.

 Facilitar las entradas y salidas. Un Sistema Operativo debe hacerle fácil al usuario el acceso y manejo de
los dispositivos de Entrada/Salida de la computadora.
Clasificación de los Sistemas Operativos.

Con el paso del tiempo, los Sistemas Operativos fueron clasificándose de diferentes maneras, dependiendo del
uso o de la aplicación que se les daba. A continuación se mostrarán diversos tipos de Sistemas Operativos que
existen en la actualidad, con algunas de sus características:
Sistemas Operativos de multiprogramación (o Sistemas Operativos de multitarea).

Es el modo de funcionamiento disponible en algunos sistemas operativos, mediante el cual una computadora
procesa varias tareas al mismo tiempo. Existen varios tipos de multitareas. La conmutación de contextos (context
Switching) es un tipo muy simple de multitarea en el que dos o más aplicaciones se cargan al mismo tiempo, pero
en el que solo se está procesando la aplicación que se encuentra en primer plano (la que ve el usuario). Para
activar otra tarea que se encuentre en segundo plano, el usuario debe traer al primer plano la ventana o pantalla
que contenga esa aplicación. En la multitarea cooperativa, la que se utiliza en el sistema operativo Macintosh, las
pág. 3
tareas en segundo plano reciben tiempo de procesado durante los tiempos muertos de la tarea que se encuentra
en primer plano (por ejemplo, cuando esta aplicación está esperando información del usuario), y siempre que esta
aplicación lo permita. En los sistemas multitarea de tiempo compartido, como OS/2, cada tarea recibe la atención
del microprocesador durante una fracción de segundo. Para mantener el sistema en orden, cada tarea recibe un
nivel de prioridad o se procesa en orden secuencial. Dado que el sentido temporal del usuario es mucho más lento
que la velocidad de procesamiento del ordenador, las operaciones de multitarea en tiempo compartido parecen
ser simultáneas.
Se distinguen por sus habilidades para poder soportar la ejecución de dos o más trabajos activos (que se están
ejecutado) al mismo tiempo. Esto trae como resultado que la Unidad Central de Procesamiento (UCP) siempre
tenga alguna tarea que ejecutar, aprovechando al máximo su utilización.
Su objetivo es tener a varias tareas en la memoria principal, de manera que cada uno está usando el procesador, o
un procesador distinto, es decir, involucra máquinas con más de una UCP.
Sistemas Operativos como UNIX, Windows 95, Windows 98, Windows NT, Windows XP, MAC-OS, OS/2, soportan
la multitarea.
Las características de un Sistema Operativo de multiprogramación o multitarea son las siguientes:
 Mejora productividad del sistema y utilización de recursos.
 Multiplexa recursos entre varios programas.
 Generalmente soportan múltiples usuarios (multiusuarios).
 Proporcionan facilidades para mantener el entorno de usuarios individuales.
 Requieren validación de usuario para seguridad y protección.
 Proporcionan contabilidad del uso de los recursos por parte de los usuarios.
 Multitarea sin soporte multiusuario se encuentra en algunos computadores personales o en sistemas de
tiempo real.
 Sistemas multiprocesadores son sistemas multitareas por definición ya que soportan la ejecución
simultánea de múltiples tareas sobre diferentes procesadores.
 En general, los sistemas de multiprogramación se caracterizan por tener múltiples programas activos
compitiendo por los recursos del sistema: procesador, memoria, dispositivos periféricos.
Sistema Operativo Monotareas.

Los sistemas operativos monotareas son más primitivos y es todo lo contrario al visto anteriormente, es decir, solo
pueden manejar un proceso en cada momento o que solo puede ejecutar las tareas de una en una. Por ejemplo
cuando la computadora está imprimiendo un documento, no puede iniciar otro proceso ni responder a nuevas
instrucciones hasta que se termine la impresión.
Sistema Operativo Monousuario.

Los sistemas monousuarios son aquellos que nada más puede atender a un solo usuario, gracias a las limitaciones
creadas por el hardware, los programas o el tipo de aplicación que se esté ejecutando.
pág. 4
Estos tipos de sistemas son muy simples, porque todos los dispositivos de entrada, salida y control dependen de la
tarea que se está utilizando, esto quiere decir, que las instrucciones que se dan, son procesadas de inmediato; ya
que existe un solo usuario. Y están orientados principalmente por los microcomputadores.
Sistema Operativo Multiusuario.

Es todo lo contrario a monousuario; y en esta categoría se encuentran todos los sistemas que cumplen
simultáneamente las necesidades de dos o más usuarios, que comparten mismos recursos. Este tipo de sistemas
se emplean especialmente en redes.
En otras palabras consiste en el fraccionamiento del tiempo (timesharing).
Sistemas Operativos de tiempo real.

Los Sistemas Operativos de tiempo real son aquellos en los cuales no tiene importancia el usuario, sino los
procesos. Por lo general, están subutilizados sus recursos con la finalidad de prestar atención a los procesos en el
momento que lo requieran. Se utilizan en entornos donde son procesados un gran número de sucesos o eventos.
Muchos Sistemas Operativos de tiempo real son construidos para aplicaciones muy específicas como control de
tráfico aéreo, bolsas de valores, control de refinerías, control de laminadores. También en el ramo automovilístico
y de la electrónica de consumo, las aplicaciones de tiempo real están creciendo muy rápidamente. Otros campos
de aplicación de los Sistemas Operativos de tiempo real son los siguientes:
 Control de trenes.
 Telecomunicaciones.
 Sistemas de fabricación integrada.
 Producción y distribución de energía eléctrica.
 Control de edificios.
 Sistemas multimedia.
Algunos ejemplos de Sistemas Operativos de tiempo real son: VxWorks, Solaris, Lyns OS y Spectra. Los Sistemas
Operativos de tiempo real, cuentan con las siguientes características:
 Se dan en entornos en donde deben ser aceptados y procesados gran cantidad de sucesos, la mayoría
externos al sistema computacional, en breve tiempo o dentro de ciertos plazos.
 Se utilizan en control industrial, conmutación telefónica, control de vuelo, simulaciones en tiempo real.,
aplicaciones militares, etc.
 Objetivo es proporcionar rápidos tiempos de respuesta.
 Procesa ráfagas de miles de interrupciones por segundo sin perder un solo suceso.
 Proceso se activa tras ocurrencia de suceso, mediante interrupción.
 Proceso de mayor prioridad expropia recursos.
 Por tanto generalmente se utiliza planificación expropiativa basada en prioridades.
 Gestión de memoria menos exigente que tiempo compartido, usualmente procesos son residentes
permanentes en memoria.
pág. 5
 Población de procesos estática en gran medida.

 Poco movimiento de programas entre almacenamiento secundario y memoria.
 Gestión de archivos se orienta más a velocidad de acceso que a utilización eficiente del recurso.
Sistemas Operativos de Tiempo Compartido.

Permiten la simulación de que el sistema y sus recursos son todos para cada usuario. El usuario hace una petición
a la computadora, esta la procesa tan pronto como le es posible, y la respuesta aparecerá en la terminal del
usuario.
Los principales recursos del sistema, el procesador, la memoria, dispositivos de E/S, son continuamente utilizados
entre los diversos usuarios, dando a cada usuario la ilusión de que tiene el sistema dedicado para sí mismo. Esto
trae como consecuencia una gran carga de trabajo al Sistema Operativo, principalmente en la administración de
memoria principal y secundaria.
Ejemplos de Sistemas Operativos de tiempo compartido son Multics, OS/360 y DEC-10.
Características de los Sistemas Operativos de tiempo compartido:
 Populares representantes de sistemas multiprogramados multiusuario, ej: sistemas de diseño asistido por
computador, procesamiento de texto, etc.
 Dan la ilusión de que cada usuario tiene una máquina para sí.
 Mayoría utilizan algoritmo de reparto circular.
 Programas se ejecutan con prioridad rotatoria que se incrementa con la espera y disminuye después de
concedido el servicio.
 Evitan monopolización del sistema asignando tiempos de procesador (time slot).
 Gestión de memoria proporciona protección a programas residentes.
 Gestión de archivo debe proporcionar protección y control de acceso debido a que pueden existir
múltiples usuarios accesando un mismo archivo.
Sistemas Operativos Distribuidos.

Permiten distribuir trabajos, tareas o procesos, entre un conjunto de procesadores. Puede ser que este conjunto
de procesadores esté en un equipo o en diferentes, en este caso es trasparente para el usuario. Existen dos
esquemas básicos de éstos. Un sistema fuertemente acoplado esa es aquel que comparte la memoria y un reloj
global, cuyos tiempos de acceso son similares para todos los procesadores. En un sistema débilmente acoplado los
procesadores no comparten ni memoria ni reloj, ya que cada uno cuenta con su memoria local.
Los sistemas distribuidos deben de ser muy confiables, ya que si un componente del sistema se compone otro
componente debe de ser capaz de reemplazarlo.
Entre los diferentes Sistemas Operativos distribuidos que existen tenemos los siguientes: Sprite, Solaris-MC, Mach,
Chorus, Spring, Amoeba, Taos, etc.
Características de los Sistemas Operativos distribuidos:
 Colección de sistemas autónomos capaces de comunicación y cooperación mediante interconexiones
hardware y software.
pág. 6
 Gobierna operación de un S.C. y proporciona abstracción de máquina virtual a los usuarios.

 Objetivo clave es la transparencia.
 Generalmente proporcionan medios para la compartición global de recursos.
 Servicios añadidos: denominación global, sistemas de archivos distribuidos, facilidades para distribución
de cálculos (a través de comunicación de procesos internodos, llamadas a procedimientos remotos, etc.).
Sistemas Operativos de Red.

Son aquellos sistemas que mantienen a dos o más computadoras unidas através de algún medio de comunicación
(físico o no), con el objetivo primordial de poder compartir los diferentes recursos y la información del sistema.
El primer Sistema Operativo de red estaba enfocado a equipos con un procesador Motorola 68000, pasando
posteriormente a procesadores Intel como Novell Netware.
Los Sistemas Operativos de red más ampliamente usados son: Novell Netware, Personal Netware, LAN Manager,
Windows NT Server, Windows Server 2003 UNIX, LANtastic.
Sistemas Operativos Paralelos.

En estos tipos de Sistemas Operativos se pretende que cuando existan dos o más procesos que compitan por
algún recurso se puedan realizar o ejecutar al mismo tiempo.
En UNIX existe también la posibilidad de ejecutar programas sin tener que atenderlos en forma interactiva,
simulando paralelismo (es decir, atender de manera concurrente varios procesos de un mismo usuario). Así, en
lugar de esperar a que el proceso termine de ejecutarse (como lo haría normalmente), regresa a atender al
usuario inmediatamente después de haber creado el proceso.
Ejemplos de estos tipos de Sistemas Operativos están: Alpha, PVM, la serie AIX, que es utilizado en los sistemas
RS/6000 de IBM.
Arquitectura de los Sistema Operativo UNIX/LINUX

Los conceptos centrales en el modelo del sistema UNIX son los archivos y los procesos. En la siguiente figura se
muestra un diagrama de bloques del kernel, mostrando varios módulos y las relaciones entre ellos. En particular,
se muestra el subsistema de archivos en la parte izquierda y el subsistema de control de procesos en la parte
derecha, los dos mayores componentes del Kernel.
pág. 7
Diagrama de Bloques del Kernel del Sistema

En esta figura muestra tres niveles: usuario, Kernel y hardware. Las llamadas al sistema y las librerías representan
entre los programas de usuario y el Kernel. Las llamadas al sistema son parecidas a las funciones en los programas
en C y las librerías transforman estas funciones a las primitivas necesarias para entrar en el sistema operativo. Los
programas en lenguaje ensamblador deben invocar a las llamadas al sistema directamente sin las librerías de las
llamadas al sistema.
Las llamadas interactúan con el subsistema de archivos y con el subsistema de control de procesos. El subsistema
de archivos controla los archivos, asigna espacio a los archivos, administra el espacio libre, controla el acceso a los
archivos, etc. Los procesos interactúan con el subsistema de archivos mediante un específico conjunto de llamadas
al sistema.
El subsistema de archivos accede a los archivos de datos usando un mecanismo de búffer que regula el flujo de
datos entre el Kernel y los dispositivos de almacenamiento secundario. El mecanismo de búffer interactúa con los
controladores de dispositivos de E/S de tipo de bloque para iniciar la transferencia de datos desde y hacia el
Kernel.
El subsistema de procesos es el responsable de la sincronización de los procesos, la comunicación entre procesos,
administración de memoria principal y la planificación de procesos. Tanto el subsistema de archivos y el
subsistema de procesos interactúan cuando se carga un archivo en memoria para su ejecución.
El módulo de administración de memoria controla la asignación de memoria. Si en algún momento no hay
suficiente memoria física para todos los procesos, el Kernel los mueve entre la memoria principal y la secundaria.
pág. 8
El módulo de planificador o sheduler asigna la CPU a los procesos. Planifica los procesos para ser ejecutados por
turno hasta que voluntariamente liberen la CPU mientras esperan un recurso o hasta que el Kernel los saca
cuando su tiempo de ejecución supera el tiempo cuantum.
Finalmente, el control de hardware es el responsable de las interrupciones y de las comunicaciones con la
máquina. Los dispositivos como los discos o terminales pueden interrumpir a la CPU mientras un proceso se está
ejecutando. Así, el Kernel debe restablecer la ejecución del proceso interrumpido después de servir a la
interrupción.
GESTIÓN DE PROCESOS
Procesos
Una definición tradicional de proceso es la de instancia de un programa en ejecución. La ejecución de tal programa
es indicada al SO mediante una acción u orden especializada.
El SO responde en ese punto creando un nuevo proceso. En general, esta actividad consiste en la creación e
inicialización de estructuras de datos en el SO para monitorizar y controlar el progreso de proceso en cuestión.
Una vez creado, el proceso pasará a estar activo y competirá por la utilización de recursos del sistema como el
procesador y los dispositivos I/O.
Un proceso evoluciona cíclicamente entre períodos de ejecución activa y de espera por la terminación de
actividades de I/O. Cuando un proceso queda inactivo por especificar una operación de I/O y quedar a la espera de
que ésta se complete, el SO puede planificar la ejecución de otro proceso.
Desde este punto de vista, un proceso es una entidad individualmente planificable, que puede ser asignada al
procesador y ejecutada por éste. El SO controla, pues, dinámicamente la evolución de los procesos registrando la
información correspondiente a sus cambios cuando éstos se produzcan. Esta información es utilizada por el SO
para sus labores de planificación y gestión sobre el conjunto de procesos que en un determinado momento
pueden coexistir en el sistema informático.
De esta forma además de la plantilla estática constituida por el programa ejecutable en que se basa, un proceso
posee ciertos atributos que ayudan al SO en su gestión.
Los atributos de un proceso incluyen su estado actual, unidad de planificación, derechos de acceso, nivel de
prioridad entre otros datos. Desde el punto de vista del usuario, un proceso no es más que la ejecución de un
conjunto de instrucciones que llevan a cabo una determinada tarea, mientras que para el SO es una entidad que
atraviesa dinámicamente un conjunto de estados y que solicita los recursos del sistema que le son necesarios. De
esta forma, el acceso a tales recursos debe ser planificado de forma que se consiga un rendimiento en la
utilización de los mismos lo más óptimo posible.
El sistema operativo y los procesos

Todos los SO de multiprogramación están construidos en torno al concepto de proceso. Los requisitos principales
que debe cumplir un SO para con los procesos son los siguientes:
1. El SO debe intercalar la ejecución de procesos para optimizar la utilización del procesador ofreciendo a la vez
un tiempo de respuesta razonable.
2. El SO debe asignar los recursos del sistema a los procesos en conformidad con una política específica que
evite situaciones de interbloqueo.
pág. 9
3. El SO podría tener que dar soporte a la comunicación entre procesos y ofrecer mecanismos para su creación,
labores que pueden ser de ayuda en la estructuración de aplicaciones.
Tipos de procesos y relación entre procesos concurrentes

En principio, podemos realizar una clasificación muy general de los procesos entre procesos de usuario y procesos
de sistema. Un proceso de usuario es aquel creado por el SO como respuesta a una de ejecución del usuario o de
una aplicación que ejecuta a instancias de éste.
Un proceso de sistema es un proceso que forma parte del propio SO y que desempeña alguna de sus labores
características, como por ejemplo, la elección del siguiente proceso a ejecutar o bien la prestación de un servicio
determinado como el acceso a un recurso de I/O del sistema.
Cualquiera que sea la naturaleza de los procesos, éstos pueden mantener fundamentalmente dos tipos de
relaciones: Competición y/o Colaboración.
En virtud de la compartición de recursos de un solo sistema, todos los procesos concurrentes compiten unos con
otros por la asignación de los recursos del sistema necesarios para sus operaciones respectivas. Además, una
colección de procesos relacionados que representen colectivamente una sola aplicación lógica, suelen cooperar
entre sí. La cooperación es habitual entre los procesos creados como resultado de una división explícita de tareas.
Los procesos cooperativos intercambian datos y señales de sincronización necesarios para estructurar su progreso
colectivo. Tanto la competición como la colaboración de procesos requiere una cuidada asignación y protección de
los recursos en términos de aislamiento de los diferentes espacios de direcciones. La cooperación depende de la
existencia de mecanismos para la utilización controlada de los datos compartidos y el intercambio de señales de
sincronización.
Los procesos cooperativos comparten típicamente algunos recursos y atributos además de interactuar unos con
otros. Por esta razón, con frecuencia se agrupan en lo que se denomina una familia de procesos. Aunque dentro
de una familia son posibles relaciones complejas entre sus procesos miembro, la relación más comúnmente
soportada por los sistemas operativos es la relación padre-hijo. Esta relación se establece cuando el SO crea un
nuevo proceso a instancias de otro ya existente. Los procesos hijos heredan generalmente los atributos de sus
procesos padres en el momento de su creación y también pueden compartir recursos con sus procesos hermanos.
Estados de un proceso
En cualquier sistema operativo, es básico conocer el comportamiento que exhibirán los distintos procesos y el
conjunto de estados que pueden atravesar.
Modelo de dos estados

El modelo más sencillo que puede construirse tiene en cuenta que un momento dado un proceso puede estar
ejecutándose en el procesador o no. Así pues, un proceso puede estar en uno de dos estados: Ejecución o No
ejecución
pág. 10
Cuando el SO crea un nuevo proceso, éste entra en el sistema en el estado de No ejecución. De este modo, el
proceso existe, es conocido por el SO y está esperando la oportunidad de ejecutarse. En un momento dado, el
sistema operativo decide otorgar el procesador a un proceso determinado con lo que dicho proceso pasará de
estado No ejecución a Ejecución.
Cada cierto tiempo, el proceso en ejecución es interrumpido y el sistema operativo seleccionará un nuevo proceso
para que tome el control del procesador. El proceso interrumpido pasa del estado de Ejecución al de No ejecución
mientras que el proceso elegido realiza la transición inversa.
Incluso en este modelo tan simple, se aprecian ya algunos de los elementos importantes en el diseño de SO. Cada
proceso debe representarse de forma que el sistema operativo tenga conocimiento de su estado actual y de su
posición en memoria.
Aquellos procesos que no estén en estado de ejecución deberán almacenarse en algún tipo de estructura de datos
mientras esperan que el sistema operativo les otorgue el control sobre el procesador. La siguiente figura propone
una estructura basada en una cola de procesos.
Dicha cola consiste en una lista enlazada de bloques en la que cada uno de estos bloques representa a un proceso.
Cada bloque consistirá en un puntero a la estructura de datos donde el SO guarda toda la información relativa al
proceso. El comportamiento del SO en este caso es similar al de un gestor de colas. Así, cada vez que el SO cree un
nuevo proceso se introducirá el correspondiente bloque al final de la cola, acción que también se llevará a cabo
cuando un proceso sea expropiado del procesador en favor de otro o cuando se bloquee en espera de que se
complete una operación de E/S. Cuando un proceso termine su ejecución, será descartado del sistema. Si todos los
procesos estuvieran siempre listos para ejecutar, la disciplina de comportamiento de cola presentada sería eficaz.
El modelo de cola sigue un comportamiento FIFO y el procesador opera siguiendo un turno rotatorio con los
procesos disponibles. De esta forma, a cada proceso de la cola se le otorga una cierta cantidad de tiempo para
ejecutar. Si no se presentan bloqueos y transcurrido éste volverá a la cola para optar de nuevo a tener control
sobre el procesador. Sin embargo, esta implementación no es adecuada debido a que algunos procesos en estado
de no ejecución estarán listos para ejecutar mientras que otros se encontrarán a la espera de obtener algún
recurso solicitado o a que se complete una operación de E/S. Así pues, el SO puede no entregar el procesador al
proceso que se encuentre al frente de la cola. Si éste está bloqueado, tendrá que recorrer la cola buscando el
primer proceso que no lo esté y que lleve más tiempo en espera.
Una forma más natural de afrontar esta situación es dividir el estado de no ejecución en dos; los estados listo y
bloqueado. Además se añadirán dos nuevos estados al sistema.
Estos estados son: nuevo y terminado, que resultan de utilidad para las labores de gestión de procesos. Así se dará
lugar al modelo de 5 estados.
Modelo de 5 estados
En este modelo un proceso puede encontrarse en cualquiera de los siguientes 5 estados.
pág. 11
1. Estado Nuevo: este estado corresponderá a procesos que acaban de ser definidos pero que aún no han
sido admitidos por el sistema operativo como procesos ejecutables. Para estos procesos se habrán
realizado ciertas tareas de gestión interna como la asignación de un identificador y la creación de algunas
estructuras de control. La principal motivación para la existencia de este estado es la limitación por parte
del SO del número total de procesos activos por razones de rendimiento o por las estricciones impuestas
por la capacidad de la memoria.
2. Estado Listo o Preparado: En este estado se encontrarán aquellos procesos que dispongan de todos los
recursos necesarios para comenzar o proseguir su ejecución y se encuentran a la espera de que se les
conceda el control del procesador.
3. Estado de Ejecución: En este estado se encuentra el proceso que tiene el control del procesador. Dado que
se considerarán arquitecturas que disponen de un único procesador, en un instante determinado sólo un
proceso puede encontrarse en este estado.
4. Estado Bloqueado: En este estado se encuentran aquellos procesos que carecen de algún recurso
necesario para su ejecución siendo este recurso distinto del procesador o bien se encuentran a la espera
de que tenga lugar un determinado evento.
5. Estado Terminado: A este estado pertenecen aquellos procesos excluidos por el SO del grupo de procesos
ejecutables. Un proceso alcanza este estado cuando llega al punto normal de terminación, cuando se
abandona debido a un error irrecuperable o cuando un proceso con la debida autoridad hace que termine
su ejecución. En este punto, el proceso ya no es susceptible de ser elegido para ejecutarse. Sin embargo,
el SO conserva cierta información asociada con él para su posible utilización, bien por otras aplicaciones
como programas de utilidad para el análisis de la historia y rendimiento del proceso o bien por parte del
SO con fines estadísticos. Una vez extraída esta información, el SO ya no necesita mantener más datos
relativos al proceso y éstos se borran del sistema.
En la figura presentamos el diagrama de transiciones entre estados
Diagrama de transiciones entre estados. La línea punteada indica situación excepcional.

Transición Nuevo-Preparado: Esta transición tiene lugar cuando el SO está preparado para aceptar o admitir un
proceso más. Se tendrán en cuenta las restricciones derivadas de la capacidad de la memoria y que no haya tantos
procesos activos como para degradar el rendimiento.
Transición Preparado-Ejecución: Esta transición se produce cuando el SO selecciona un nuevo proceso para
ejecutar en función de su política de planificación.
pág. 12
Transición Ejecución-Preparado: La razón más común para esta transición es que el proceso que está en ejecución
ha alcanzado el tiempo máximo permitido de ejecución ininterrumpida. Hay otras causas alternativas que no están
implementadas en todos los SSOO como la expropiación de un proceso en favor de otro más prioritario.
Otra situación, muy extraordinaria, que origina esta transición es que un proceso ceda voluntariamente el control
del procesador.
Transición Ejecución-Bloqueo: Un proceso realiza esta transición cuando queda a la espera por la concesión de un
determinado recurso o por la ocurrencia de un determinado suceso.
Transición Bloqueado-Preparado: Tiene lugar si a un proceso bloqueado se le concede el recurso solicitado u
ocurre el suceso por el que estaba esperando.
Transición Preparado-Terminado: Puede ocurrir si, por ejemplo, un proceso padre decide en un momento
determinado finalizar la ejecución de sus procesos hijos. Si alguno de dichos procesos se encontraba en estado
preparado realizará esta transición. Otra razón puede ser debida a un requisito de memoria que es denegado.
Transición Bloqueado-Terminado: Un proceso hijo puede realizar esta transición por la misma razón que la
anterior. Otra causa puede ser que el proceso supere el tiempo máximo de espera por un recurso y el sistema
operativo decida entonces terminarlo (es la razón más habitual).
Este modelo de 5 estados puede implementarse igualmente mediante estructuras de tipo cola siguiendo un
esquema como se muestra en la figura
Diagrama de transiciones entre estados implementada con una cola.

Ahora se dispone de dos colas, una para los procesos en situación de preparado y otra para los bloqueados. A
medida que se admiten procesos nuevos en el sistema, éstos se sitúan en la cola de preparados. Cuando el SO
tiene que escoger un proceso para ejecutar, lo hace sacando uno de dicha cola. En ausencia de prioridades, la
referida cola puede gestionarse mediante un algoritmo FIFO. Cuando un proceso es expropiado del procesador,
puede ser porque ha terminado su ejecución, porque ha excedido el tiempo máximo de posesión del procesador y
entonces es devuelto a la cola de preparados o porque ha quedado bloqueado a la espera de un determinado
suceso con lo que se introducirá en la cola de bloqueados. Cuando tiene lugar un determinado suceso, todos los
procesos que esperaban por él son pasados desde la cola de bloqueados a la de preparados.
Esta última medida significa que cuando se produce un suceso, el SO debe recorrer toda la cola de bloqueados
buscando aquellos procesos que esperen por el suceso. En un SO grande puede haber una gran cantidad de
procesos en la cola de bloqueados, por tanto, resultará más eficiente disponer de un conjunto de colas, una para
pág. 13
cada suceso. En tal caso, cuando se produzca un evento, la lista entera de procesos en la cola correspondiente a
ese suceso podrá pasarse a estado preparado.
Si la planificación de procesos se realiza mediante un esquema basado en prioridades, entonces es conveniente
tener un cierto número de colas de procesos listos, una para cada prioridad.
Planificación de Procesos y Subprocesos. Hilos

Planificación de procesos
La planificación hace referencia a un conjunto de políticas y mecanismos incorporados al SO que gobiernan el
orden en que se ejecutan los trabajos que deben ser completados por el sistema informático. Un planificador es
un módulo del SO que selecciona el siguiente trabajo a admitir en el sistema y el siguiente proceso que tomará el
control sobre el procesador. El objetivo primario de la planificación es optimizar el rendimiento del sistema de
acuerdo con los criterios considerados más importantes por los diseñadores del mismo.
Entre las medidas de rendimiento y los criterios de optimización más habituales que los planificadores utilizan
para llevar a cabo su labor se encuentran los siguientes:
Utilización del procesador:

La utilización del procesador es la fracción de tiempo promedio durante la cual el procesador está ocupado, es
decir, la fracción de tiempo durante la cual el procesador se encuentra activo ejecutando algún proceso, bien de
usuario, bien del propio SO. Con esta interpretación, la utilización del procesador puede ser medida con relativa
facilidad, por ejemplo mediante un proceso nulo especial que se ejecute cuando ningún otro proceso pueda
hacerlo. Una alternativa es considerar únicamente la operación en modo usuario y, por tanto, excluir el tiempo
empleado para el SO.
En cualquier caso, el objetivo es mantener al procesador ocupado tanto tiempo como sea posible. De esta forma,
se conseguirá que los factores de utilización de los restantes componentes también sean elevados obteniéndose
con ello buenas medidas de rendimiento.
Productividad
La productividad se refiere a la cantidad de trabajo completada por unidad de tiempo.
Un modo de expresarla es definiéndola como el número de trabajos de usuario ejecutados por una unidad de
tiempo. Cuanto mayor sea este número, más trabajo aparentemente está siendo ejecutado por el sistema.
Tiempo de retorno
El tiempo de retorno TR se define como el tiempo que transcurre desde el momento en que un trabajo o
programa es remitido al sistema hasta que es totalmente completado por el mismo. Es decir, el tiempo de retorno
TR es el tiempo consumido por el proceso dentro del sistema y puede ser expresado como la suma del tiempo de
servicio o tiempo de ejecución + el tiempo de espera. TR = TS + TE.
Tiempo de espera
El tiempo de espera TE es el tiempo que un proceso o trabajo consume a la espera de la asignación de algún
recurso o de que tenga lugar algún evento. En este tiempo también se incluyen el periodo de espera por la
obtención del propio procesador debido a la competencia con otros procesos en un sistema con
multiprogramación. Este tiempo es la penalización impuesta por compartir recursos con otros procesos y puede
expresarse como el tiempo de retorno - el tiempo de ejecución efectivo. El tiempo de espera TE elimina la
variabilidad debida a las diferencias en tiempos de ejecución del trabajo.
pág. 14
Tiempo de respuesta
El tiempo de respuesta en sistemas interactivos se define como el tiempo que transcurre desde el momento en
que se introduce el último carácter de una orden que desencadena la ejecución de un programa o transacción
hasta que aparece el primer resultado en el terminal. Generalmente también se le denomina tiempo de respuesta
de terminal.
En sistemas en tiempo real, el tiempo de respuesta es esencialmente una latencia y se define como el tiempo que
transcurre desde el momento en que un suceso interno o externo es señalado hasta que se ejecuta la primera
instrucción de su correspondiente rutina de servicio. A este tiempo suele denominársele tiempo de respuesta al
proceso.
Tipos de planificadores
En un SO complejo pueden coexistir tres tipos de planificadores: A corto, a medio y a largo plazo.
Planificador a largo plazo (PLP)

Su misión consiste en controlar la admisión de procesos nuevos al sistema. Cuando está presente este tipo de
planificador, su objetivo principal es proporcionar una mezcla equilibrada de trabajos. El PLP decide cuándo se da
entrada al sistema a un nuevo proceso para que éste sea ejecutado. Este proceso puede proceder de la respuesta
al envío de un trabajo por lotes o bien a la orden de ejecución realizada por el usuario. En cierto modo, el PLP
actúa como una válvula de admisión de primer nivel para mantener la utilización de recursos al nivel deseado. Es
importante conseguir una administración equilibrada para saber cómo conjugar procesos interactivos que tienen
retardos especiales con procesos por lotes que son una simple de cola de cálculo.
Por ejemplo, cuando la utilización del microprocesador puede admitir más trabajos, el planificador puede dar
entrada al sistema a nuevos procesos y aumentar con ello la probabilidad de asignación de alguno de estos
procesos al procesador. Por el contrario, cuando el tiempo para la utilización del procesador resulte alto y así se
refleje en el deterioro en el tiempo de espera, el PLP puede optar por reducir la frecuencia de admisión de
procesos a situación de preparado. El PLP es invocado generalmente cada vez que un trabajo completado
abandona el sistema.
La frecuencia de llamada al PLP es, por tanto, dependiente del sistema y de la carga de trabajo pero generalmente
es mucho más baja que para los otros dos tipos de planificadores.
Como resultado de esta no demasiada frecuente ejecución, el PLP puede incorporar algoritmos relativamente
complejos y computacionalmente intensivos para admitir trabajos al sistema. En términos del diagrama de
transición de estados de procesos, el PLP quedará a cargo de las transiciones del estado nuevo al estado
preparado o listo.
Planificador a corto plazo (PCP)

Este planificador decide qué procesos toman el control de la CPU. El PCP asigna el procesador entre el conjunto de
procesos preparados residentes en memoria. Su principal objetivo es maximizar el rendimiento del sistema de
acuerdo a con el conjunto de criterios elegidos. Al estar a cargo de la transición de estado preparado a ejecución,
el PCP deberá ser invocado cuando se realice una operación de conmutación de procesos para seleccionar el
siguiente proceso a ejecutar. En la práctica el PCP es llamado cada vez que un suceso interno o externo hace que
se modifique alguna de las condiciones que definen el estado actual del sistema. Algunos de los sucesos que
provocan una replanificación en virtud de su capacidad de modificar el estado del sistema son:
1. Tics de reloj, es decir, interrupciones basadas en el tiempo.
pág. 15
2. Interrupciones y terminaciones de operaciones de E/S.

3. Llamadas de operación al sistema operativo frente a llamadas de consulta.
4. Envío y recepción de señales.
5. Activación de programas interactivos.
En general, cada vez que ocurre uno de estos sucesos, el SO llama al PCP para determinar si debería planificarse
otro proceso para su ejecución.
Planificador a medio plazo (PMP)

El PMP tiene por misión traer procesos suspendidos a la memoria principal. Este planificador controla la transición
de procesos en situación de suspendidos a situación de preparados. El PMP permanecerá inactivo mientras se
mantenga la condición que dio lugar a la suspensión del proceso, sin embargo, una vez desaparecida dicha
condición el PMP intenta asignar al proceso la cantidad de memoria principal que requiera y volver a dejarlo en
situación de preparado. Para funcionar adecuadamente, el PMP debe disponer de información respecto a las
necesidades de memoria de los procesos suspendidos, lo cual no es complicado de llevar a la práctica ya que el
tamaño real del proceso puede ser calculado en el momento de suspenderlo almacenándose en el BCP.
Este planificador será invocado cuando quede espacio libre en memoria por la terminación de un proceso o
cuando el suministro de procesos preparados quede por debajo de un límite especificado.
Subproceso
Ahora bien, no necesitamos que la corrección ortográfica o el reemplazo automático sea inmediato, podemos
seguir escribiendo y dejar que esta función se realice en background, “detrás” de la rutina principal. Si el
subrayado en rojo aparece luego que escribamos dos o tres letras de la próxima palabra, no modifica la
funcionalidad.
Si esto lo implementamos mediante procesos tradicionales, donde al iniciar la ejecución de un procesador de
palabras también iniciáramos un conjunto de procesos, corrector ortográfico, corrector semántico, etc., los
tiempos de cambio de proceso disminuirían drásticamente la velocidad de respuesta.
Pero esto no es necesario, los distintos procesos comparten gran cantidad de datos, el usuario, la posición en
pantalla, etc. por lo que cambiando solamente los datos específicos podemos implementarlo.
Esta es la idea básica de un sistema multihilo, cada proceso ahora, en vez de tener un solo hilo de ejecución, tiene
varios, o sea, generamos varios subprocesos dentro de cada proceso.
Para administrar esto, creamos el registro TCB, Thread Control Block, que va a tener solamente los datos que
cambian entre subproceso y subproceso, gráficamente podemos verlo así:
pág. 16
Entonces tenemos un proceso que tiene n subprocesos, con n variando desde 1 en adelante. De esta manera, el
tiempo de cambio de un subproceso a otro es mucho menor que el tiempo de cambio de un proceso a otro, ya
que numerosos datos son compartidos.
En nuestro ejemplo del procesador de palabra, cuando el subproceso tomar tecla está en espera, puede tomar la
CPU el subproceso control de ortografía, de esta manera, mantenemos un buen tiempo de respuesta y brindamos
todas las funcionalidades deseadas.
El uso de subprocesos mejora el rendimiento de los sistemas con múltiCPU, (antes llamados sistemas
multiprocesadores, pero desde la aparición de procesadores multicore, con dos o más CPUs integradas, tuvimos
que cambiar el nombre), ya que distintos subprocesos pueden ejecutarse simultáneamente en distintas CPU,
teniendo un procesamiento en paralelo dentro del mismo proceso principal.
Ventajas
Inclusive en sistemas monoCPU la el uso de subprocesos brinda múltiples beneficios, por ej: (Tomados de Letwin)
Subproceso en primer plano y múltiples subprocesos en segundo plano: El ejemplo dado del Procesador de
palabras o una planilla de cálculo, en la que mientras el usuario ingresa un dato en segundo plano se calculan los
valores de otras celdas
Procesamiento asíncrono: Crear una copia de seguridad del texto cada minuto puede ser un subproceso.
Incremento de la velocidad de ejecución: Si un proceso debe leer datos y sumarlos, podemos dividirlo en
subprocesos, mientras uno lee, y por lo tanto libera la CPU mientras se atiende su llamada al sistema, el otro
suma.
Estructura modular de programas: Claramente al dividir en subprocesos creamos una estructura modular.
pág. 17
Estas son solo algunas, sería imposible listar todos los usos ventajosos posibles.
Desventajas
También pueden generarse múltiples dificultades por el uso de subprocesos, dentro de ellas cabe destacar el
incremento de la necesidad de sincronización. Sistemas que generaban automáticamente exclusión mutua entre
rutinas, porque al ejecutarse una no se ejecutaba la otra, al migrarlo a sistemas con subprocesos debemos
sincronizar su funcionamiento incorporando semáforos, monitores y otras herramientas.
Características de los subprocesos

Todos los subprocesos de un proceso principal:
· comparten el mismo espacio de dirección.
· comparten los recursos de E/S asignados, por ej. Archivos.
· pueden ser afectados por cualquier otro subproceso del mismo proceso principal. Son, por lo tanto,
interdependientes.
Ciclo de vida de los subprocesos (estados)

Los subprocesos en general pueden tener los siguientes estados:
· Nuevo
· Listo (Ready): En capacidad de ejecutarse
· Ejecución (Run): ejecutándose
· Bloqueado (Lock)
· Finalizado
Hilos
A falta de una definición más formal, un hilo se puede definir como la traza de ejecución de un proceso. Esto se
refiere a la parte dinámica del proceso, la ejecución del código representada por la pila del usuario y la parte del
bloque de control del proceso que hace referencia al estado del procesador y del proceso, frente a la parte más
estática, como es la el resto del bloque de control del proceso y el código mismo.
La aparición de los hilos viene justificada desde dos pilares básicos: facilitar la sincronización entre procesos y
mejorar la eficiencia en la alternancia de procesos en el procesador. A continuación se van a desarrollar esas ideas.
En esta sección vamos a presentar el concepto de sistemas multihilo, justificando la aparición de los hilos,
presentando sus ventajas frente a la idea clásica de proceso y analizando las implicaciones que tienen en la forma
de representar los procesos en el sistema, también se presentarán los estados de los hilos y por último se
analizarán las distintas formas de implementar los hilos.
Sistemas Multihilo
El término multihilo hace referencia a la capacidad de un sistema operativo para mantener varios hilos de
ejecución. Tras la aparición de los hilos se puede considerar que en el enfoque tradicional sólo existe un hilo de
ejecución por proceso, por lo que puede ser llamado monohilo.
En la Figura se pueden observar las combinaciones posibles entre procesos e hilos. Dentro de la categoría de los
sistemas monoproceso y monohilo se puede encuadrar al sistema MS-DOS. Los sistemas UNIX genéricos se
pág. 18
pueden definir como sistemas multiproceso con un único hilo por proceso. Dentro de los sistemas monoproceso
multihilo se puede incluir a las máquinas virtuales Java. Los sistemas operativos más modernos se agrupan dentro
de la categoría de multiproceso.
En un entorno multihilo un proceso se define como la unidad de protección y unidad de asignación de recursos
con los siguientes elementos asociados con ellos:
 Un espacio de direcciones virtuales con la imagen del proceso.
 Acceso protegido a los procesadores, a otros procesos, archivos y dispositivos de E/S.
Un proceso puede tener uno o más hilos, cada uno con:
 El estado de ejecución del hilo.
 El contexto del procesador que se salva cuando el hilo no está en ejecución.
 Una pila de ejecución de usuario (y otra para el núcleo cuando sea preciso).
 Almacenamiento estático para las variables locales.
 Acceso a la memoria y a los recursos del proceso, que son compartidos con todos los otros hilos del
proceso.
Todo esto se puede ver en la Figura anterior, donde se puede ver las diferencias entre la representación de
procesos monohilos y multihilos.
En un sistema multihilo continúa existiendo un solo bloque de control de proceso y un espacio de direcciones de
usuario asociado al proceso, pero ahora hay pilas separadas para cada hilo, así como distintos bloques de control
para cada hilo, que contienen los valores de los registros, prioridad y otras informaciones relativas al estado de los
hilos.
Así pues, todos los hilos de un proceso comparten el estado y los recursos del proceso, residen en el mismo
espacio de direcciones y tienen acceso a los mismos datos. Por todo esto, es fácil ver que la utilización de hilos
produce una mejora en las posibilidades de sincronización de procesos, además de una mejora en el rendimiento.
Las ventajas que se derivan de la utilización de los hilos son las siguientes:
pág. 19
RPCs utilizando procesos e hilos.
1. Respuesta: Una aplicación multihilo puede continuar ejecutándose incluso si una parte de ella está
bloqueada o está realizando una tarea larga, incrementando de este modo el nivel de respuesta frente al
usuario.
2. Compartición de recursos: Los hilos por defecto comparten la memoria y otros recursos del proceso al que
pertenecen por lo que no hay que utilizar ningún mecanismo especial de compartición entre procesos.
Esto permite que la aplicación pueda tener distintos hilos de ejecución con la misma memoria. Además los
hilos aumentan la eficiencia de la comunicación entre programas en ejecución ya que pueden
comunicarse sin la intervención del núcleo del sistema operativo.
3. Economía: Reservar memoria y recursos en la creación de los procesos es una tarea costosa. Como los
hilos comparten los recursos del proceso al que pertenecen, resulta más económico crear hilos nuevos y
alternarlos en el procesador que hacer lo mismo con procesos. Aunque no existen medidas empíricas
definitivas, en Solaris crear un proceso es unas 30 veces más lento que crear un hilo, y realizar un cambio
de contexto entre procesos es 5 veces más lento que hacerlo entre hilos.
4. Utilización de arquitecturas multiprocesador: Los procesos multihilo pueden aprovechar fácilmente una
arquitectura multiprocesador ya que cada hilo podría ejecutarse en un procesador distinto.
Para ilustrar las ventajas de los sistemas multihilo frente a los monohilo, se puede analizar el caso mostrado en la
Figura. En este ejemplo se considera dos versiones del mismo programa que tiene que realizar dos invocaciones a
procedimientos remotos en dos servidores diferentes; en el primer caso sobre un entorno monohilo, y en un
entorno multihilo en el segundo caso. Es fácil observar que en el segundo caso se puede obtener una importante
mejora en el tiempo empleado para ello si cada RPC es realizada desde un hilo diferente.
pág. 20
Esta ventaja también resulta evidente aunque el proceso se ejecute en un entorno monoprocesador, lo que
implica que aunque las solicitudes deben generarse secuencialmente, la espera se realiza en paralelo.
GESTIÓN DE MEMORIA
¿Qué es la memoria?
La memoria es uno de los principales recursos de la computadora, la cual debe de administrarse con mucho
cuidado. Actualmente los sistemas de cómputo cuentan con una alta capacidad de memoria, de igual manera las
aplicaciones actuales tienen también altos requerimientos de memoria, lo que sigue generando escasez de
memoria en los sistemas multitarea y/o multiusuario.
¿Quién administra la memoria?

La parte del sistema operativo que administra la memoria se llama administrador de memoria y su labor consiste
en llevar un registro de las partes de memoria que se estén utilizando y aquellas que no, con el fin de asignar
espacio en memoria a los procesos cuando éstos la necesiten.
Los sistemas de administración de memoria se pueden clasificar en dos tipos: los que desplazan los procesos de la
memoria principal al disco y viceversa durante la ejecución y los que no.
¿Qué es la memoria real?

La memoria real o principal es en donde son ejecutados los programas y procesos de una computadora y es el
espacio real que existe en memoria para que se ejecuten los procesos.
Gestión de Memoria Real
a) Monoprogramación sin intercambio o paginación

El esquema más sencillo de administración de memoria es aquel en el que sólo se tiene un proceso en memoria en
cada instante; esto implica que cada proceso debe contener controladores de dispositivo para cada uno de los
dispositivos de E/S que utilice. Sin embargo, éste método ya no tiene aplicación en la actualidad, ya que era visto
en las computadoras con sistemas operativos de un solo usuario y una sola tarea.
El ejemplo más claro de este esquema es el que podemos ver en el sistema operativo MS-DOS, en que el usuario
escribe un comando al sistema y al ejecutarse el sistema operativo lo carga a memoria desde el disco y realiza sus
funciones.
pág. 21
b) Multiprogramación y uso de memoria

Esta organización facilita la programación de una aplicación al dividirla en dos o más procesos. Además ofrece la
capacidad de tener más de un proceso a la vez en memoria así puede ofrecer servicios a varios usuarios a la vez. La
multiprogramación, al tener varios procesos en la memoria principal y dividiéndose el tiempo de uso del
procesador, logra reducir drásticamente el desperdicio del procesador.
c) Multiprogramación con particiones fijas

En el caso de las particiones fijas, la memoria se puede organizar dividiéndose en diversas partes, las cuales
pueden variar en tamaño. Esta partición la puede hacer el usuario en forma manual, al iniciar una sesión con la
máquina. Cuando tenga que iniciar un programa, el sistema le asignará una partición que pueda contenerlo. Suele
haber una cola única de trabajos esperando la primera partición libre. Si no cabe en esa partición, se buscará otro
que quepa, por ejemplo.
Este sistema de particiones puede producir fragmentación interna (un programa más pequeño que la partición) y
fragmentación externa (una partición no utilizada por ser demasiado pequeña).
d) Multiprogramación con particiones variables

El sistema operativo lleva una tabla indicando cuáles partes de la memoria están disponibles y cuáles están
ocupadas. Inicialmente, toda la memoria está disponible para los procesos de usuario y es considerado como un
pág. 22
gran bloque o hueco único de memoria. Cuando llega un proceso que necesita memoria, buscamos un hueco lo
suficientemente grande para el proceso. Si encontramos uno, se asigna únicamente el espacio requerido,
manteniendo el resto disponible para futuros procesos que requieran de espacio.
Este tipo de particiones genera una gran fragmentación externa aunque eliminan la interna. Para solucionar esto,
se puede utilizar dos técnicas de compactación y asignación dinámica.
Compactación
Cuando un proceso llega y necesita memoria, el sistema operativo busca en la tabla de huecos alguno lo
suficientemente grande para el proceso. Si el hueco es muy grande, lo parte en dos. Una parte es asignada al
proceso y la otra se identifica como hueco. Cuando el proceso termina y la memoria es liberada, el espacio es
identificado como un hueco más en la tabla y si el nuevo hueco es adyacente con otro, ambos huecos se unen
formando un solo hueco más grande.
Asignación dinámica
El proceso de compactación del punto anterior es una instancia particular del problema de asignación de memoria
dinámica, el cual es el cómo satisfacer una necesidad de tamaño n con una lista de huecos libres. Las estrategias
más comunes para asignar algún hueco de la tabla son:
 Primer ajuste: Consiste en asignar el primer hueco con capacidad suficiente.
 Mejor ajuste: Busca asignar el espacio más pequeño de los espacios con capacidad suficiente.
pág. 23
 Peor ajuste: Asigna el hueco más grande. Una vez más, se debe de buscar en toda la tabla de huecos a
menos que esté organizada por tamaño.
e) Administración de la memoria con mapas de bits

Este tipo de administración divide la memoria en unidades de asignación, las cuales pueden ser tan pequeñas
como unas cuantas palabras o tan grandes como varios kilobytes. A cada unidad de asignación le corresponde un
bit en el mapa de bits, el cual toma el valor de 0 si la unidad está libre y 1 si está ocupada (o viceversa).
f) Administración de la memoria con listas ligadas

Una forma de mantener un registro de la memoria es mediante una lista ligada de los segmentos de memoria
asignados o libres, en donde un segmento puede ser un proceso o un hueco entre dos procesos.
pág. 24
g) Asignación del hueco de intercambio

En algunos sistemas, cuando el proceso se encuentra en la memoria, no hay un hueco en el disco asignado a él.
Cuando deba intercambiarse, se deberá asignar un hueco para él en el área de intercambio del disco. En otros
sistemas, al caerse un proceso, se le asigna un hueco de intercambio en el disco. Cuando el proceso sea
intercambiado, siempre pasará al hueco asignado, en vez de ir a otro lugar cada vez.
h) Fragmentación
Son huecos en la memoria que no pueden usarse debido a lo pequeño de su espacio, provoca un desperdicio de
memoria principal. Tal vez en conjunto si sea espacio suficiente, pero se requeriría de un proceso de
desfragmentación de memoria o compactación para lograrlo. Esta fragmentación se denomina fragmentación
externa. Existe otro tipo de fragmentación conocida como fragmentación interna, la cual es generada cuando se
reserva más memoria de la que el proceso va realmente a usar.
Memoria Virtual
Hace ya muchos años que aparecieron los primeros programas demasiado grandes para caber en la memoria
disponible. La solución usualmente adoptada fue dividir el programa en trozos, llamados recubrimientos
(overlays). El recubrimiento 0 era el que se ejecutaba primero. Cuando terminaba, llamaba a otro recubrimiento.
Algunos sistemas de recubrimientos eran altamente complejos, permitiendo tener varios recubrimientos en
pág. 25
memoria a la vez. Los recubrimientos se mantenían en el disco y el sistema operativo los intercambiaba entre el
disco y la memoria, dinámicamente según se iban necesitando.
Aunque el sistema realizaba el trabajo real de intercambiar los recubrimientos, el programador tenía que
encargarse de dividir en trozos apropiados el programa. La tarea de dividir programas grandes en pequeños trozos
modulares era laboriosa y tediosa, así que no pasó mucho tiempo antes de que alguien idease una manera de
dejar todo ese trabajo para el ordenador.
El método ideado (Fotheringham, 1961) se conoce ahora como memoria virtual. La idea básica detrás de la
memoria virtual es que el tamaño combinado del programa, sus datos y su pila pueden exceder la cantidad de
memoria física disponible. El sistema operativo mantiene en la memoria principal aquellas partes del programa
que se están usando en cada momento, manteniendo el resto de las partes del programa en el disco. Por ejemplo,
un programa de 16 MB puede ejecutarse sobre una máquina de 4 MB eligiendo cuidadosamente qué 4 MB se
tendrán en la memoria en cada instante, e intercambiando partes del programa entre el disco y la memoria, según
sea necesario.
La memoria virtual puede funcionar también en un sistema multiprogramado, con diversos fragmentos de muchos
programas en memoria a la vez. Mientras un programa espera a que se traiga del disco una parte de si mismo,
está esperando por una E/S y no puede ejecutarse, por lo que debe asignarse la CPU a otro proceso de la misma
forma que en cualquier otro sistema multiprogramado.
Políticas de Asignación Local y Global

¿Cómo debe repartirse la memoria entre todos los procesos ejecutables que compiten por ella?
Echemos un vistazo a la Figura (a). En ella, tres procesos A, B y C constituyen el conjunto de procesos ejecutables.
Supongamos que A provoca una falta de página. ¿El algoritmo de sustitución de páginas debe tratar de encontrar
la página menos recientemente utilizada considerando sólo las seis páginas que A tiene asignadas en la actualidad,
o debe considerar todas las páginas que están en la memoria? Si sólo se consideran las páginas de A, la de menor
edad es A5, y llegaremos a la situación de la Figura (b).
Por otra parte, si se sustituye la página de menor edad sin considerar a qué proceso pertenece, se escogerá la
página B3 y tendremos la situación de la Figura (c). El algoritmo de la Figura (b) se dice que es un algoritmo de
sustitución de páginas local, mientras que el de la Figura (c) se dice que es un algoritmo de sustitución de páginas
global. Los algoritmos locales corresponden de hecho a asignar a cada proceso una fracción fija de la memoria. Los
algoritmos globales asignan dinámicamente los marcos de páginas entre los procesos ejecutables. Así, el número
de marcos de página asignados a cada proceso varía con el tiempo.
pág. 26
Sustitución de páginas local y global. (a) Configuración original. (b) Sustitución de páginas local. (c) Sustitución de
páginas global.
En general, los algoritmos globales funcionan mejor, sobre todo cuando el tamaño del conjunto de trabajo puede
variar durante el tiempo de vida de los procesos. Si se utiliza un algoritmo local y el conjunto de trabajo crece,
habrá trasiego, incluso si hay muchos marcos de página desocupados. Si el conjunto de trabajo se encoge, los
algoritmos locales desperdician memoria. Si se utiliza un algoritmo global, el sistema debe decidir continuamente
cuántos marcos de página asignará a cada proceso. Una forma de hacerlo es monitorizar el tamaño del conjunto
de trabajo mediante los bits de envejecimiento (como en la Figura), pero ese enfoque no previene necesariamente
el trasiego. El tamaño del conjunto de trabajo puede cambiar en microsegundos, mientras que los bits de
envejecimiento son una medida burda que abarca varios tics de reloj.
Otro enfoque consiste en tener un algoritmo para asignar marcos de página a los procesos. Una posible vía es
determinar periódicamente el número de procesos ejecutables y repartir entre ellos a partes iguales todos los
marcos de página. Así, con 12.416 marcos de página disponibles (es decir no ocupados por el sistema operativo) y
10 procesos, cada proceso recibiría 1.241 marcos. Los 6 restantes integrarían una reserva de la que se echaría
mano para afrontar futuras faltas de página.
Aunque este método parece equitativo, no tiene mucho sentido asignar el mismo número de marcos de página a
un proceso de 10 KB y a otro de 300 KB. En vez de eso, los marcos podrían repartirse proporcionalmente al
tamaño total de cada proceso, de modo que un proceso de 300 KB obtendría 30 veces más que uno de 10 KB. Tal
vez sería prudente asignar a cada proceso una cantidad mínima para que pueda ejecutarse por pequeño que sea.
Por ejemplo, en algunas máquinas, una sola instrucción con dos operandos podría requerir hasta seis páginas en
memoria porque la instrucción misma, el operando de origen y el operando de destino podrían estar todos
atravesando fronteras de páginas consecutivas. Con una asignación de sólo cinco páginas en memoria los
programas que contuviesen tales instrucciones no podrían ejecutarse de ninguna manera.
Si se utiliza un algoritmo global, es posible iniciar cada proceso con cierto número de páginas en memoria
proporcional a su tamaño, pero la asignación deberá actualizarse dinámicamente a medida que avance la
ejecución de los procesos. Una forma de gestionar la asignación es utilizar el algoritmo de la frecuencia de faltas
de página (PFF; Page Fault Frequency). Este algoritmo determina cuándo hay que aumentar o reducir el número
pág. 27
de marcos asignados al proceso, pero no dice nada sobre qué página hay que sustituir concretamente si se
produce una falta de página; sólo controla el tamaño de la asignación realizada.
Se sabe que para una amplia clase de algoritmos de sustitución de páginas, incluyendo al LRU, la tasa de faltas de
página disminuye a medida que se asignan más páginas, como ya explicamos. Ésta es la suposición en la que se
basa PFF. Esta propiedad se ilustra en la Figura
La tasa de faltas de página como una función del número de marcos de página asignados.
Medir la tasa de faltas de página es sencillo: basta con contar el número de faltas de página por segundo,
calculando quizá también una media para los segundos transcurridos. Una forma fácil de hacerlo es sumar el
número de segundos presente a la media de ejecución actual y dividir el resultado entre 2. La línea de guiones
marcada con una A corresponde a una tasa de faltas de página inaceptablemente alta, por lo que se asignarían
más marcos de página a ese proceso para reducir la tasa de faltas de página. La línea de guiones marcada con una
B corresponde a una tasa de faltas de página tan baja que podría concluirse que el proceso tiene demasiada
memoria. En este caso, podríamos quitarle marcos de página. Por lo tanto, PFF trata de mantener la tasa de
paginación de cada proceso dentro de límites aceptables.
Es importante señalar que algunos algoritmos de sustitución de páginas pueden operar con una política de
sustitución local o global. Por ejemplo, FIFO puede reemplazar la página más antigua de toda la memoria
(algoritmo global) o la página más antigua del proceso actual (algoritmo local). Similarmente, LRU, o alguna de sus
aproximaciones, puede sustituir la página menos recientemente utilizada de toda la memoria (algoritmo global) o
la menos recientemente utilizada por el proceso actual (algoritmo local). En algunos casos la elección entre una
política local o global es independiente del algoritmo.
Por otra parte, hay algoritmos de sustitución de páginas para los que sólo tiene sentido una estrategia local. En
particular, los algoritmos del conjunto de trabajo y WSClock se refieren a un proceso específico y deben aplicarse
en ese contexto. En realidad no existe un conjunto de trabajo para la máquina en su totalidad, y tratar de usar la
unión de todos los conjuntos de trabajo podría hacer que se perdiera la propiedad de localidad y no funcionaría
bien.
Control de Carga
Incluso con el mejor algoritmo de sustitución de páginas y una asignación global óptima de marcos de página a los
procesos, puede suceder que el sistema tenga trasiego. De hecho, siempre que los conjuntos de trabajo
combinados de todos los procesos exceden la capacidad de la memoria, cabe esperar trasiego. Un síntoma de esta
situación es que el algoritmo PFF indica que algunos procesos necesitan más memoria, pero ningún proceso
pág. 28
necesita menos. En ese caso, es imposible asignar más memoria a los procesos que la necesitan sin perjudicar a
otros procesos. La única solución real es deshacerse temporalmente de algunos procesos.
La forma de reducir el número de procesos que compiten por la memoria es intercambiar algunos de ellos al disco
y liberar todas las páginas que tenían asignadas. Por ejemplo, puede intercambiarse al disco un proceso
repartiéndose todos sus marcos de página entre otros procesos que sufren trasiego. Si el trasiego cesa, el sistema
podrá operar durante un rato en estas condiciones. Si el trasiego no cesa, habrá que intercambiar otro proceso al
disco, y así hasta que desaparezca el trasiego. Entonces, incluso con paginación, sigue siendo necesario el
intercambio, sólo que ahora se utiliza para reducir la demanda potencial de memoria, en vez de para recuperar
bloques de la memoria para uso inmediato.
El intercambio de procesos al disco para aliviar la carga de la memoria es una reminiscencia de la planificación a
dos niveles, en la que algunos procesos se colocan en el disco y se utiliza un planificador a corto plazo para los
procesos restantes. Claramente, las dos ideas pueden combinarse, intercambiando a disco tan solo los procesos
suficientes para lograr que la tasa de faltas de página sea aceptable. Periódicamente, algunos procesos se
cargarán desde el disco y otros se intercambiarán al disco.
Sin embargo, otro factor a considerar es el grado de multiprogramación. Como vimos en la Figura
, cuando el número de procesos en memoria principal es demasiado bajo, la CPU puede estar ociosa durante
periodos de tiempo considerables. Esta consideración es un argumento a favor de considerar no sólo el tamaño de
los procesos y la tasa de paginación al decidir qué procesos se intercambian al disco, sino también sus
características, tales como si son intensivos en CPU o en E/S, así como las características de los demás procesos.
Tamaño de Página
El tamaño de la página suele ser un parámetro que puede elegir el sistema operativo.
Incluso si el hardware se diseñó con páginas de, por ejemplo, 512 bytes, el sistema operativo puede fácilmente ver
las páginas 0 y 1, 2 y 3, 4 y 5, etcétera como páginas de 1 KB asignándoles siempre dos marcos de página de 512
bytes consecutivos.
Determinar el tamaño de página óptimo requiere equilibrar varios factores en conflicto.
Como resultado, no existe un tamaño óptimo para todos los casos. Para comenzar, hay dos factores que favorecen
el uso de páginas pequeñas. Un segmento de código, datos o pila cualquiera no tiene porqué llenar
completamente un número entero de páginas. En promedio, la mitad de la última página estará vacía, y ese
espacio adicional se desperdicia. Este desperdicio se denomina fragmentación interna. Si hay n segmentos en la
memoria y las páginas son de p bytes, se desperdiciarán np/2 bytes debido a la fragmentación interna. Este
razonamiento nos lleva a escoger páginas pequeñas.
El otro argumento en este sentido se hace evidente si consideramos un programa que consta de ocho fases
sucesivas de 4 KB cada una. Con páginas de 32 KB, será necesario asignar al programa 32 KB todo el tiempo. Con
páginas de 16 KB, solo necesitará 16 KB. Con páginas de 4 KB o menores sólo requerirá 4 KB en cualquier instante
dado. En general, un tamaño de página grande provoca que más partes no utilizadas de los programas estén en la
memoria.
Por otro lado, el uso de páginas pequeñas significa que los programas van a necesitar muchas páginas y, por lo
tanto, una tabla de páginas más grande. Un programa de 32 KB sólo necesita cuatro páginas de 8 KB, pero 64
páginas de 512 bytes. Las transferencias entre la memoria y el disco suelen efectuarse en unidades de una página,
pág. 29
invirtiéndose la mayor parte del tiempo en el posicionamiento del brazo y el retraso rotacional, por lo que
transferir una página pequeña requiere casi el mismo tiempo que transferir una grande. Podrían necesitarse 64 ×
10 milisegundos para cargar 64 páginas de 512 bytes, pero sólo 4 × 12 milisegundos para cargar cuatro páginas de
8 KB.
En algunas máquinas, la tabla de páginas debe cargarse en registros de hardware cada vez que la CPU conmuta de
un proceso a otro. En tales máquinas, el tiempo requerido para cargar esos registros aumenta a medida que
disminuye el tamaño de página. Además, el espacio ocupado por la tabla aumenta a medida que se reduce el
tamaño de página.
Este último punto permite un análisis matemático. Supongamos que el tamaño medio de los procesos es s bytes y
que el tamaño de las páginas es p bytes. Supongamos además que cada entrada de la tabla de páginas ocupa e
bytes. Por lo tanto, el número aproximado de páginas que se requieren por proceso es s/p, ocupando se/p bytes
de espacio para la tabla de páginas. El desperdicio de memoria en la última página del proceso, debido a la
fragmentación interna es p/2. Por lo tanto, la sobrecarga total debida a la tabla de páginas y a la pérdida por
fragmentación interna es la suma de esos dos términos:
sobrecarga = se/p + p/2
El primer término (tamaño de la tabla de páginas) es grande cuando el tamaño de página es pequeño. El segundo
término (fragmentación interna) es grande cuando el tamaño de página es grande. El tamaño óptimo debe estar
en algún punto intermedio. Si obtenemos la primera derivada respecto a p y la igualamos a cero, obtenemos la
ecuación
– se/p2 + 1/2 = 0
De esa ecuación podemos deducir una fórmula que da el tamaño de página óptimo (considerando sólo la memoria
que se desperdicia por fragmentación y el tamaño de la tabla de páginas). El resultado es:
p = 2se
Con s = 1 MB y e = 8 bytes por entrada de la tabla de páginas, el tamaño de página óptimo es de 4 KB. Los
ordenadores comerciales han manejado páginas desde 512 bytes hasta 64 KB. Un valor típico utilizado era 1 KB,
pero actualmente son más comunes 4 KB u 8 KB. A medida que crecen las memorias, el tamaño de página tiende a
aumentar (pero no de manera lineal).
Aumentando cuatro veces el tamaño de la RAM casi nunca se llega a duplicar el tamaño de la página.
pág. 30

Resumen Introduccion A Los Sistemas Operativos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Resumen Introduccion A Los Sistemas Operativos

Cargado por

Copyright:

Formatos disponibles

INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS | 2023

INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS

Funciones de los sistemas operativos

Características de los sistemas operativos.

 Conveniencia. Un Sistema Operativo hace más conveniente el uso de una computadora.

 Organizar datos para acceso rápido y seguro.

 Procesamiento por bytes de flujo a través del bus de datos.

Clasificación de los Sistemas Operativos.

Sistemas Operativos de multiprogramación (o Sistemas Operativos de multitarea).

Sistema Operativo Monotareas.

Sistema Operativo Monousuario.

Sistema Operativo Multiusuario.

Sistemas Operativos de tiempo real.

 Población de procesos estática en gran medida.

Sistemas Operativos de Tiempo Compartido.

Sistemas Operativos Distribuidos.

 Gobierna operación de un S.C. y proporciona abstracción de máquina virtual a los usuarios.

Sistemas Operativos de Red.

Sistemas Operativos Paralelos.

Arquitectura de los Sistema Operativo UNIX/LINUX

Diagrama de Bloques del Kernel del Sistema

El sistema operativo y los procesos

Tipos de procesos y relación entre procesos concurrentes

Modelo de dos estados

Diagrama de transiciones entre estados. La línea punteada indica situación excepcional.

Diagrama de transiciones entre estados implementada con una cola.

Planificación de Procesos y Subprocesos. Hilos

Utilización del procesador:

Planificador a largo plazo (PLP)

Planificador a corto plazo (PCP)

2. Interrupciones y terminaciones de operaciones de E/S.

Planificador a medio plazo (PMP)

Características de los subprocesos

Ciclo de vida de los subprocesos (estados)

RPCs utilizando procesos e hilos.

¿Quién administra la memoria?

¿Qué es la memoria real?

Gestión de Memoria Real

a) Monoprogramación sin intercambio o paginación

b) Multiprogramación y uso de memoria

c) Multiprogramación con particiones fijas

d) Multiprogramación con particiones variables

e) Administración de la memoria con mapas de bits

f) Administración de la memoria con listas ligadas

g) Asignación del hueco de intercambio

Políticas de Asignación Local y Global

También podría gustarte