sistemas operativos 2.0(beta)
Post on 31-Jan-2016
229 Views
Preview:
DESCRIPTION
TRANSCRIPT
UNIVERSIDAD NACIONAL MAYOR DEUNIVERSIDAD NACIONAL MAYOR DESAN MARCOSSAN MARCOS
(Universidad del Perú, Decana de América)
FACULTAD DE INGENIERÍA DE SISTEMAS E INFORMÁTICA
Introducción a la computación
Profesora: Mg. Gloria Castro León
Tema: Sistemas operativos
Alumnos:
Arenas Machaca, Cristian
Calcina Aguilar, Brayan
Chalco Vila, Enrique
Chávez Aliaga, Luis
Ciudad Universitaria, junio de 2015
Sistemas Operativos UNMSM - FISI
Introducción
Uno de los principales problemas que se presentó en el uso de las computadoras
fue la dificultad en su uso, ya que para poder realizar una actividad en ella
requería altos conocimientos en programación e informática. Esta fue una de las
razones por las cuales surgieron los sistemas operativos. Aunque al principio solo
servían para ejecutar un programa después de otro, luego sirvieron para facilitar
su uso mediante una interfaz gráfica mucho más amigable, simple y que todos
entendieran.
En este trabajo abordaremos la definición de un sistema operativo, sus
estructuras y sus operaciones. También las gestiones que realiza tanto en los
procesos, memoria y almacenamiento.
2
Sistemas Operativos UNMSM - FISI
Contenido
Introducción.........................................................................................................2
1. ¿Qué es un sistema operativo?....................................................................7
1.1. Punto de vista del usuario...............................................................7
1.2. Punto de vista del sistema...............................................................8
1.3. Definición de un sistema operativo..................................................8
2. Historia..........................................................................................................9
3. Estructuras de un sistema operativo...........................................................10
3.1. Servicios de un sistema operativo.................................................11
3.2. Kernel............................................................................................13
3.3. Llamadas a un sistema..................................................................14
3.3.1. Tipos de llamadas..........................................................................15
3.4. Programas del sistema operativo..................................................17
3.5. Estructura de un sistema operativo...............................................17
3.5.1. Estructura simple...........................................................................18
3.5.2. Estructura por nivel........................................................................18
3.5.3. Microkernels..................................................................................19
3.5.4. Módulos.........................................................................................20
3.6. Máquinas virtuales.........................................................................21
3.7. Arranque del sistema.....................................................................21
4. Operaciones con el sistema operativo........................................................22
4.1. Operación en modo dual...............................................................22
4.2. Temporizador.................................................................................24
5. Gestión de procesos...................................................................................25
5.1. Concepto de proceso.....................................................................25
5.2. Planificación de procesos..............................................................26
5.2.1. Tipos de planificación....................................................................26
3
Sistemas Operativos UNMSM - FISI
5.3. Comunicación entre procesos.......................................................27
5.3.1. Tipos de comunicación..................................................................28
5.3.2. Comunicación en los sistemas cliente – servidor..........................29
5.4. Hebras...........................................................................................30
5.4.1. Modelos multihebras......................................................................31
5.4.2. Bibliotecas de hebras....................................................................32
5.5. Planificación de la CPU.................................................................33
5.5.1. Ráfagas de CPU y ráfagas de E/S................................................33
5.5.2. Planificador de la CPU...................................................................34
5.5.3. Criterios de planificación................................................................34
5.5.4. Algoritmos de planificación............................................................35
5.5.5. Sincronización de procesos...........................................................35
5.5.6. El problema de la sección critica...................................................36
5.5.7. Solución de Peterson.....................................................................37
5.6. Semáforos.....................................................................................39
5.7. Interbloqueos.................................................................................39
5.7.1. Condiciones necesarias.................................................................40
5.7.2. Evitando bloqueos mutuos............................................................41
5.7.3. Prevención.....................................................................................41
5.7.4. Livelock..........................................................................................42
6. Gestión de memoria...................................................................................43
6.1. Memoria principal..........................................................................43
6.1.1. Fundamentos.................................................................................43
6.1.1.1. Hardware básico............................................................................43
6.1.1.2. Reasignación de direcciones.........................................................45
6.1.1.3. Espacio de direcciones lógico y físico...........................................46
6.1.1.4. Carga dinámica..............................................................................47
4
Sistemas Operativos UNMSM - FISI
6.1.1.5. Montaje dinámico y bibliotecas compartidas.................................47
6.1.2. Intercambio....................................................................................48
6.1.2.1. Asignación de memoria contigua...................................................49
6.1.2.2. Mapeo de memoria y protección...................................................49
6.1.2.3. Asignación de memoria.................................................................50
6.1.3. Fragmentación...............................................................................51
6.1.4. Paginación.....................................................................................52
6.1.5. Segmentación................................................................................53
6.2. Memoria Virtual..............................................................................53
6.2.1. Hardware y estructura de control:..................................................53
6.2.2. Paginación.....................................................................................55
6.2.3. Segmentación................................................................................59
6.2.4. Paginación y segmentación combinadas......................................60
7. Gestión de archivos....................................................................................61
7.1. ¿Qué es un archivo?.....................................................................61
7.2. Atributos de un archivo..................................................................61
7.3. Operación con los archivos...........................................................61
7.4. Tipos de archivos...........................................................................62
7.5. Estructura de archivos...................................................................63
7.6. Introducción de directorios.............................................................64
7.6.1. Operaciones para directorios.........................................................64
7.7. Técnica de protección más usual..................................................65
7.7.1. Tipos de acceso.............................................................................65
7.7.2. Recuperación.................................................................................66
7.7.3. Comprobación de coherencia........................................................66
7.7.4. Copia de seguridad y restauración................................................67
7.8. Gestión del disco...........................................................................68
5
Sistemas Operativos UNMSM - FISI
7.8.1. Formateo del disco........................................................................68
7.8.2. Bloque de arranque.......................................................................70
7.8.3. Bloqueos defectuosos...................................................................71
8. Sistemas distribuidos..................................................................................74
8.1. Características de los sistemas distribuidos..................................74
8.2. Sistemas operativos distribuidos...................................................76
8.3. Ventajas de los sistemas distribuidos con respecto de las PC
independientes...........................................................................................76
8.4. Desventajas de los sistemas distribuidos......................................77
9. Sistemas de propósito general...................................................................79
9.1. Sistemas embebidos en tiempo real..............................................79
9.2. Sistemas multimedia......................................................................79
9.3. Sistemas de mano.........................................................................80
10. Protección y seguridad............................................................................81
Bibliografía........................................................................................................82
6
Sistemas Operativos UNMSM - FISI
1. ¿Qué es un sistema operativo?
Un sistema operativo es un programa que administra los recursos de hardware de
una computadora, proporciona bases para los programas de aplicación y actúa
como intermediario entre el usuario y el hardware. Algo destacable de un sistema
operativo es la gran variedad de formas en la que pueden ejecutar una tarea.
Los sistemas operativos son diseñados para múltiples propósitos como:
Ser eficientes, para optimizar el uso del hardware. Ejemplo: Mainframes o
computador central.
Ser prácticos, para ejecutar todo tipo de aplicaciones y un ser fáciles de
usar. Ejemplo: Una PC.
Ser prácticos y eficientes, para ser de fácil uso y optimizar el hardware.
Ejemplo: Smartphones y tablets.
Un sistema informático está compuesto de: el hardware, el sistema operativo, los
programas de aplicación y los usuarios. El sistema operativo controla y coordina
el uso del hardware entre los diversos programas de aplicación por parte de los
distintos usuarios. Un sistema informático también se puede ver como hardware,
software y datos. El sistema operativo ofrece el medio para hacer el uso
adecuado de los recursos durante su funcionamiento. Es como un gobierno, el
cual no realiza una función útil por sí mismo: solo proporciona el ambiente ideal
para que los otros programas realicen un trabajo útil. Un sistema operativo se
puede ver desde dos puntos de vista:
1.1.Punto de vista del usuario
Este punto de vista varía según la interfaz que este utilice. Generalmente un
usuario que usa una PC cuenta con un monitor, un mouse, un teclado y una
unidad de sistema. Esta clase de sistema se desarrolla para que un usuario
monopolice sus recursos y su objetivo es maximice el trabajo que está
realizando y su fácil uso, prestando atención al rendimiento y nada a la
utilización de recursos.
En otros casos, los usuarios utilizan estaciones de trabajo conectadas en red a
otras estaciones de trabajo o servidores. En este caso se comparten los
recursos en ambas direcciones (usuario-estación de trabajo), por lo que el
7
Sistemas Operativos UNMSM - FISI
sistema de diseñarse para alcanzar el compromiso entre la usabilidad
individual y la utilización de recursos.
En otros casos, los usuarios están conectados a mainframes o
microcomputadores. Entre los usuarios se hace un uso compartido de los
recursos, para lo cual se prioriza maximizar la utilización de recursos que
estén disponibles se usen de manera eficiente y que todo usuario disponga de
la parte que le corresponde.
En el caso de las computadoras de mano, sus sistemas son diseñados
principalmente la usabilidad individual, aunque el rendimiento también es
importante.
1.2.Punto de vista del sistema
Desde el punto de vista de la computadora el sistema operativo es visto como
asignador de recursos, por su íntima relación con el hardware. El sistema
informático tiene muchos recursos que pueden solucionar un problema,
actuando el sistema operativo como un administrador de estos recursos. Este
debe decidir como asignarlos a los programas y usuarios específicos, de modo
que la computadora pueda operar de forma eficiente y equitativa.
Es también vista como un programa de control, ya que gestiona la ejecución
de los programas para evitar errores y mejorar el uso de la computadora.
1.3.Definición de un sistema operativo
En los anteriores párrafos hemos abordado los puntos de vista en los que se
puede analizar un sistema operativo, pero ¿Cómo definimos un sistema
operativo? Lastimosamente no es posible hallar una definición adecuada.
Los sistemas operativos existen porque es la solución más idónea para crear
un sistema informático utilizable. El objetivo de una computadora es ejecutar
los programas del usuario y resolver sus problemas de una forma fácil. Con
este objetivo se construye el hardware de la computadora, pero el acceso
directo a este no es fácil. Con este se desarrollan los programas de aplicación,
que requieren de ciertas operaciones como las que realizan los dispositivos
E/S. Estos a su vez requieren ser controlados, siendo ahí donde interviene el
sistema operativo.
8
Sistemas Operativos UNMSM - FISI
Además, no hay una definición universalmente aceptada de lo que integra un
sistema operativo; porque generalmente se incluye todo lo que se suministra
cuando se pide un sistema operativo, variando sus características en cada uno
de ellos.
2. Historia
El concepto de sistema operativo surge en la década de los 50. El primero de la
historia fue creado en 1956 para un ordenador IBM 704, y básicamente lo único
que hacía era comenzar la ejecución de un programa cuando el anterior
terminaba.
En los años 60 se produce una revolución en el campo y aparecen conceptos
como sistema multitarea, sistema multiusuario, sistema multiprocesadores y
sistema en tiempo real. Es en esta década cuando aparece UNIX, la base de la
gran mayoría de los sistemas operativos que existen hoy en día.
En los años 70 se produce un boom en cuestión de ordenadores personales,
acercando estos al público general de manera impensable hasta entonces. Esto
hace que se multiplique el desarrollo, creándose el lenguaje de programación C
(diseñado específicamente para reescribir por completo el código UNIX).
Como consecuencia de este crecimiento exponencial de usuarios, la gran mayoría
de ellos sin ningún conocimiento sobre lenguajes de bajo o alto nivel, hizo que en
los años 80, la prioridad a la hora de diseñar un sistema operativo fuese la
facilidad de uso, surgiendo así las primeras interfaces de usuario. En los 80
nacieron sistemas como MacOS, MS-DOS, Windows.
En la década de los 90 hace su aparición Linux, publicándose la primera versión
del núcleo en septiembre de 1991, que posteriormente se uniría al proyecto GNU,
un sistema operativo completamente libre, similar a UNIX, al que le faltaba para
funcionar un núcleo funcional.
9
Sistemas Operativos UNMSM - FISI
3. Estructuras de un sistema operativo
Internamente los sistemas operativos varían mucho en su composición, ya que se
han creado a partir de senderos muy diferentes. Pero aún así tienen ciertas
características en común. Una de las más importantes es la capacidad de
multiprogramación.
La multiprogramación es la capacidad de incrementar el uso de la CPU al
organizar los trabajos, de modo que la CPU siempre tengo algo que hacer. El
principio es el siguiente: Una computadora es capaz de ejecutar varios trabajos
simultáneamente en la memoria. Estos trabajos forman un subconjunto de los
trabajos en cola, ya que el espacio en el primer caso suele ser menor que el
segundo. Si el sistema comienza a ejecutar un trabajo este eventualmente tendría
que esperar que se complete alguno otra tarea (por ejemplo una operación de
E/S). Si el sistema no fuese multiprogramado, la CPU quedaría inactiva durante
ese momento. En cambio la multiprogramación evita esto al hacer que el sistema
cambie de trabajo y ejecute otro.
Cuando dicho trabajo tiene que esperar, la CPU conmuta otro trabajo, y así
sucesivamente. Cuando el primer trabajo deja de esperar, vuelve a obtener la
CPU. Mientras haya un trabajo ejecutándose, la CPU no estará inactiva.
Esto ofrece un entorno donde los recursos de la computadora se aprovechan de
una manera eficaz, aunque no proporciona la interacción del usuario con el
sistema informático. La multitarea (o sistema de uso compartido) es la extensión
de este principio, permitiendo que la CPU ejecute múltiples trabajos a la vez de
una manera tan rápida que el usuario puede interactuar con el programa al mismo
tiempo.
La multitarea requiere un sistema informático proporcione comunicación directa
entre el usuario y el sistema. El usuario ingresa instrucciones a un programa con
un dispositivo de entrada y espera los resultados en el dispositivo de salida. Este
tiempo de espera debe ser pequeño (menor de 1 s). Esto permite que varios
usuarios utilicen la computadora al mismo tiempo, por lo que el tiempo de cambio
entre usuarios debe ser mínimo.
10
Sistemas Operativos UNMSM - FISI
Un sistema de uso compartido utiliza los principios de multiprogramación y
planificación de CPU para proporcionar una parte de la computadora a cada
usuario en un tiempo compartido. Cada usuario tiene al menos un programa en la
memoria, y al programa cargado en la memoria y en ejecución se le llama
proceso. Este se ejecuta en un periodo de tiempo pequeño, antes de necesitar
realizar una operación de E/S.
El tiempo compartido y la multiprogramación requieren mantener
simultáneamente en la memoria varios trabajos. Dado que la memoria principal el
por lo general demasiado pequeña, los trabajos se suelen almacenar inicialmente
en el disco, en la denominada cola de trabajos. Para ejecutar varios programas en
la memoria al mismo tiempo se requiere algún mecanismo de gestión de
memoria. La elección de este se llama planificación de CPU. También se requiere
que la capacidad de afectarse entre estos se vea limitada, incluyendo lo
anteriormente mencionado.
El sistema compartido debe asegurar un tiempo de respuesta razonable, por lo
cual usa la técnica de memoria virtual. También debe proporcionar una forma de
gestionar los archivos (a través del sistema de archivos), un mecanismo de
seguridad (para proteger los recursos frente a usos inapropiados) y mecanismos
para la comunicación y sincronización de trabajos (no dando lugar a interbloqueos
que pudieran hacer que se queden en espera permanentemente).
3.1.Servicios de un sistema operativo
El sistema presta ciertos servicios a los programas y a los usuarios de dichos
programas. Los servicios difieren en cada sistema operativo, pero se puede
identificar una serie de clases comunes. Estos servicios se proporcionan para
la comodidad del programador, con el fin de facilitar la tarea de desarrollo. Un
cierto conjunto de servicios del sistema operativo proporciona funciones que
resultan útiles al usuario:
Interfaz de usuario: Casi todos los sistemas operativos disponen de
una interfaz de usuario, que toman diferentes formas. Uno de los tipos
existentes es la interfaz de línea de comandos, que usa comandos de
textos y algún tipo de método para introducirlos. Otro tipo es la interfaz
de proceso por lotes, en la que los comandos y las directivas para
11
Sistemas Operativos UNMSM - FISI
controlar dichos comandos se introduce en archivos para luego ser
ejecutados. La más usada el interfaz grafica de usuario, en el cual se
usa un sistema de ventanas, con un dispositivo señalador (mouse) para
acceder a los distintos menús y un teclado para introducir texto.
Algunos sistemas proporcionan dos o tres de estas variantes.
Ejecución de programas: El sistema tiene que poder cargar un
programa en memoria y ejecutar dicho programa. Todo programa de
poder terminar su ejecución de forma normal o anormal.
Operaciones de E/S: Un programa en ejecución puede llevar a cabo
operaciones de E/S, dirigidas a un archivo o a un dispositivo de entrada
y salida. Por razones de seguridad, el usuario no debe ser capaz de
controlar directamente un dispositivo de E/S, por lo que el sistema de
proporcionar el medio adecuado.
Manipulación del sistema de archivos: Los programas necesitan leer
y escribir archivos y directorios, también crearlos y borrarlos usando su
nombre, realizar búsquedas en un determinado archivo o presentar
información contenida en ese archivo. Deben contar también con una
protección de archivos, que no permita el acceso a usuarios ajenos.
Comunicaciones: Cuando un proceso necesita intercambiar
informacion con otro proceso. Dicha comunicación debe tener lugar
entre los procesos que se ejecuten en la misma computadoras o
computadoras diferentes conectadas en una red. Se pueden
implementar utilizando la memoria compartida o mediante paso de
mensajes, en el que el sistema transmite paquetes de informacion a
otros procesos.
Detección de errores: El sistema necesita detectar los posibles errores
(en hardware, dispositivos de E/S o programas de usuario). Para cada
tipo de error, el sistema operativo debe llevar a cabo la acción
apropiada para asegurar un funcionamiento correcto y coherente.
Hay disponibles otras funciones que no son pensadas para el usuario, pero
que le ayudan a garantizar la eficiencia del sistema como.
Asignación de recursos: Se da cuando hay varios usuarios o varios
trabajos ejecutándose al mismo tiempo, a los cuales se les debe
12
Sistemas Operativos UNMSM - FISI
asignar los recursos adecuados. El sistema gestiona muchos tipos de
recursos; algunos pueden disponer de código software especial que
gestione su asignación (como ciclos de la CPU, memoria principal, etc)
y otros que pueden tener un código que lo gestione de una manera más
general su solicitud y liberación (como los dispositivos de E/S).
Responsabilidad: Normalmente conviene hacer un seguimiento de que
usuarios emplean que clase de recursos y en qué cantidad. Pueden
hacerse por fines contables o para almacenar estadísticas.
Protección y seguridad: Un sistema requiere contralar que usuarios
acceden al informacion que se maneja. Este tema se abordará con más
precisión en las siguientes páginas.
3.2.Kernel
El kernel o núcleo es un software que constituye una parte fundamental del
sistema operativo, y se define como la parte que se ejecuta en modo
privilegiado (conocido también como modo núcleo). Es el principal responsable
de facilitar a los distintos programas acceso seguro al hardware de la
computadora o en forma básica, es el encargado de gestionar recursos, a
través de servicios de llamada al sistema.
Como hay muchos programas y el acceso al hardware es limitado, también se
encarga de decidir qué programa podrá hacer uso de un dispositivo de
hardware y durante cuánto tiempo, lo que se conoce como multiplexado.
Acceder al hardware directamente puede ser realmente complejo, por lo que
los núcleos suelen implementar una serie de abstracciones del hardware. Esto
permite esconder la complejidad, y proporciona una interfaz limpia y uniforme
al hardware subyacente, lo que facilita su uso al programador.
Hay cuatro tipos:
Monolítico: Donde el sistema operativo (en su totalidad) trabaja en espacio
del núcleo, estando él solo en modo supervisor. Su diferencia con otros
núcleos radica en que solo define una interfaz virtual de alto nivel sobre el
hardware del ordenador.
13
Sistemas Operativos UNMSM - FISI
Micronúcleo: Provee un conjunto de primitivas o llamadas mínimas al sistema
para implementar servicios básicos como espacios de direcciones,
comunicación entre procesos y planificación básica. Todos los otros servicios
que en general son provistos por el núcleo, se ejecutan como procesos
servidores en espacio de usuario. Las principales ventajas de su utilización
son la reducción de la complejidad, la descentralización de los fallos y la
facilidad para crear y depurar controladores de dispositivos.
Hibrido: Son micronúcleos modificados que tienen algo de código no esencial
en espacio de núcleo para que éste se ejecute más rápido de lo que lo haría si
estuviera en espacio de usuario. La mayoría de sistemas operativos modernos
pertenecen a esta categoría, siendo los más populares Microsoft Windows,
XNU y Mac OS X.
Exonúcleo: Son extremadamente pequeños y se llaman así porque toda la
funcionalidad deja de estar residente en memoria y pasa a estar fuera, en
bibliotecas dinámicas. Su finalidad es permitir a una aplicación que solicite una
región específica de la memoria, un bloque de disco concreto, etc., y
simplemente asegurarse que los recursos pedidos están disponibles, y que el
programa tiene derecho a acceder a ellos.
3.3.Llamadas a un sistema
Las llamadas al sistema proporcionan una interfaz con la que se puede invocar
a servicios que el sistema operativo ofrece. Estas llamadas, generalmente,
están disponibles como rutinas escritas en C y C++, aunque determinadas
tareas de bajo nivel pueden necesitar escribirse en lenguaje ensamblador.
Un programador utiliza una interfaz programación de aplicaciones o API. La
API especifica un conjunto de funciones que el programador de aplicaciones
puede usar, indicándose los parámetros que hay que pasar a cada función y
los valores de retorno que el programador debe esperar.
El sistema de soporte de tiempo de ejecución de la mayoría de lenguajes de
programación proporciona una interfaz de las llamadas al sistema que sirve
como enlace con las llamadas al sistema disponibles en el sistema operativo.
La interfaz de llamadas del sistema intercepta las llamadas a función dentro de
14
Sistemas Operativos UNMSM - FISI
las API e invoca la llamada del sistema necesaria. Cada llamada al sistema
tiene asociado un número y la interfaz de llamadas al sistema mantiene una
tabla indexada según dichos números. Con esta tabla invoca la llamada
necesaria del kernel del sistema operativo y devuelve el estado de la ejecución
de la llamada al sistema y a los posibles valores de retorno.
Generalmente los programadores no necesitan saber cómo se implementa el
llamado, ya que la API elimina esa necesidad. Las llamadas al sistema se
llevan a cabo de forma distinta en la computadora que se utilice. La
informacion necesaria y el tipo exacto varían según el sistema operativo. Esta
es una de las razones por la cuales los programas diseñados para un sistema
en particular no funciona en otro.
Para pasar de parámetros se emplean tres métodos generales:
En una serie de registros
En un bloque o tabla
Insertándolos en la pila
3.3.1. Tipos de llamadas
a. Control de procesos
Un programa en ejecución necesita poder interrumpir dicha ejecución bien
de la forma normal (end) o bien de la forma anormal (abort). Si se hace
una llamada al sistema para terminar de forma anormal el programa en
ejecución, o si el programa tiene un problema y da lugar a una excepción
del error, en ocasiones se produce el volcado de memoria y manda un
mensaje de error (que se escribe en la memoria y en el depurador). Esto
sirve para poder examinar el error más tarde.
En cualquier caso, el sistema debe trasferir control al intérprete de
comandos que realizó la invocación del programa; el interprete leerá
entonces el comando. Algunos sistemas utilizan tarjetas de control para
indicar acciones especiales de recuperación en caso de que se produzcan
errores. Una tarjeta de control es un comando que permite gestionar la
ejecución de un proceso. Ante un error puede definir un nivel de error y de
acuerdo a ello definir el parámetro de acción.
15
Sistemas Operativos UNMSM - FISI
Un proceso o trabajo ejecuta un programa puede querer cargar y ejecutar
otro programa. Esto permite ejecutar un programa cuando se solicite
mediante una acción, que depende del tipo de sistema. Si se vuelve al
programan anterior cuando el programa en ejecución termina, se debe
crear una imagen para poder acceder a él. Si dos programas se ejecutan
juntos se hace uso de la multiprogramación.
b. Administrador de archivos
Lo que se requiere es poder eliminar (delate) y crear (create)
archivos. En ambas se requiere proporcionar el nombre del archivo y quizá
algunos atributos del mismo. Una vez creado el archivo se debe poder
abrirlo (open) y utilizarlo, así como también, leerlo (read), escribir
(write) sobre él o reposicionarlos (reposition) y luego poder cerrarlos
(close).
c. Administrador de dispositivos
Se pueden ver a cada recurso como un dispositivo y lo que hace asignar
los recursos que demanda un proceso para ejecutarse o esperar a que
haya recursos disponibles para su ejecución. La interfaz de usuario puede
hacer que los archivos y dispositivos sean iguales aunque las llamadas del
sistema subyacente no lo sean.
d. Mantenimiento de información
Muchas de las llamadas al sistema existen simplemente para transferir
informacion entre el programa de usuario y el sistema operativo. Otras
llamadas pueden devolver información sobre el sistema y para acceder a la
informacion de sus procesos.
e. Comunicaciones
Existen dos modelos de comunicación interprocesos:
De paso de mensajes, en la que los procesos que se comunican
intercambian mensajes entre sí para transferirse informacion.
De memoria compartida, en la que los procesos utilizan la llamada
shared memory create y share memory attach para
obtener acceso a regiones de la memoria que son propiedad de
otros procesos
16
Sistemas Operativos UNMSM - FISI
3.4.Programas del sistema operativo
Los programas del sistema proporcionan un cómodo entorno para desarrollar y
ejecutar programas. Algunos de ellos son simplemente interfaces de usuario
para llamadas al sistema; otros son considerablemente más complejos.
Pueden dividirse en:
Administración de archivos: Estos programas crean, borran, copian,
cambian de nombre, etc. En general manipulan archivos y directorios.
Informacion de estado: Son estos programas los formatean los datos
de salida y los envían al terminar o a otros dispositivos o en otros
dispositivos de almacenamiento.
Modificador de archivos: Pueden disponerse de varios editores de
texto para crear y modificar el contenido de los archivos almacenados
en el disco o en los dispositivos de almacenamiento.
Soporte de lenguajes de programación: con frecuencia, con el
sistema operativo se proporcionan al usuario compiladores,
ensambladores, depuradores e intérpretes para los lenguajes de
programación habituales como C, C++, Java, Visual Basic, etc.
Carga y ejecución de programas: Una vez que los programas se han
ensamblado o compilado, debe cargarse en la memoria para poder
ejecutarlas.
Comunicaciones: Estos programas proporcionan los mecanismos para
crear conexiones virtuales entre los procesos, usuarios y computadoras.
3.5.Estructura de un sistema operativo
Un sistema operativo moderno debe hacerse cuidadosamente para que el
sistema funcione apropiadamente y pueda modificarse con facilidad. Un
método habitual consiste en dividir la tarea en componentes más pequeños,
en lugar de tener un sistema monolítico. Cada uno de estos módulos debe ser
una parte bien definida, con entradas, salidas y funciones cuidadosamente
especificadas. En la primera parte abordamos las partes más comunes de los
sistemas operativos. En esta parte, veremos cómo los componentes se
interconectan y funden con el kernel.
17
Sistemas Operativos UNMSM - FISI
3.5.1. Estructura simple
Muchos sistemas comerciales no tenían una estructura bien definida.
Frecuentemente, estos sistemas comienzan siendo sistemas pequeños,
simples y limitados; para luego crecer más allá de sus ámbito original,
como es el caso de MS-DOS. Este fue escrito para proporcionar la máxima
funcionalidad en el menor espacio posible, por no ser dividido en módulos
de forma cuidadosa. Esto también hace que el sistema sea vulnerable a
programas erróneos (o maliciosos), lo que hace que el sistema falle cuando
los programas de usuario fallan.
También hay problemas cuando se estructuraban alrededor de un kernel
monolítico (como es el caso de Unix), en el cual este proporcionaba el
sistema de archivos, los mecanismos de planificación de la CPU, la
funcionalidad de gestión de la memoria y otras funciones del sistema
operativo a través de las llamadas de sistema. Todo esto incluía una
enorme funcionalidad en un solo nivel, lo cual lo hacía difícil de
implementar y mantener.
3.5.2. Estructura por nivel
Con el soporte de hardware apropiado, los sistemas operativos pueden
dividirse en partes más pequeñas y más adecuadas que lo se permitía
inicialmente. Con ello, puede mantener un control mucho mayor sobre la
computadora y sobre las aplicaciones que hacen uso de dicha
computadora. Los implementadores tienen más libertad para cambiar el
funcionamiento interno del sistema y crear sistemas operativos modulares.
La ocultación de los detalles a ojos de los niveles superiores también es
importante, dado que deja libres a los programadores para implementar las
rutinas de bajo nivel como prefieran, siempre que la interfaz externa de la
rutina pertenezca invariable y la propia rutina realice la tarea anunciada.
Un sistema puede hacerse modular de muchas formas. Un posible método
es mediante una estructura por niveles, en la que un sistema operativo se
divide en una serie de capas (niveles). Un nivel de un sistema operativo es
una implementación de un objeto formado por una serie de datos y por las
operaciones que permitan manipular esos datos. Un nivel típico de un
18
Sistemas Operativos UNMSM - FISI
sistema consta de una estructura de datos y un conjunto de rutinas que los
niveles superiores pueden invocar. A su vez un nivel puede invocar a un
nivel inferior.
La principal ventaja de este método es la simplicidad de construcción y
depuración. Los niveles se seleccionan de modo que cada uno usa
funciones y servicios de niveles inferiores. El primer nivel puede depurarse
sin afectar al resto del sistema, dado que solo usa hardware básico para
implementar funciones. Una vez el primer nivel se ha depurado, puede
suponerse su correcto funcionamiento mientras se depura el segundo
nivel, etc. Si se encuentra un error durante la depuración, el error tendrá
que estar localizado en dicho nivel. Un nivel inferior no necesita saber
cómo se implementan las operaciones, solo necesita saber que hacen esas
operaciones.
La principal dificultad es definir apropiadamente los diferentes niveles, dado
que un nivel solo puede invocar a niveles inferiores. El último problema es
que esta implementación suele ser menos eficientes en su implementación.
Por ello los diseños más recientes utilizan menos niveles.
3.5.3. Microkernels
Se da con los el desarrollo de sistema operativo Mach que modularizaba el
kernel usando lo que se denomina microkernel. En un microkernel se
eliminan todos los componentes no esenciales del kernel e
implementándolos como programas de sistema teniendo como resultado un
kernel más pequeño.
Su principal función es proporcionar un mecanismo de comunicaciones
entre el programa clientes y los distintos servicios que se ejecutan también
en el espacio de usuario, mediante el paso de mensajes. El programa
cliente y el servicio nunca interactúa directamente, sino que lo hacen
indirectamente intercambiando mensajes con el microkernel.
Otra ventaja es la facilidad para ampliar el sistema operativo. Todos los
servicios nuevos se añaden al espacio de usuario y no requieren que el
kernel sea modificado. También da mayor seguridad y fiabilidad, dado que
19
Sistemas Operativos UNMSM - FISI
la mayor parte de los servicios se ejecutan como procesos de usuario. Si
un servicio falla, las demás partes del sistema no se ven afectadas. La
desventaja es que suelen tener un rendimiento inferior por la carga de
procesamiento adicional impuesta por las funciones del sistema.
3.5.4. Módulos
Es quizá la mejor metodología para diseñar sistemas operativos en la que
se usa las técnicas de programación orientada a objetos para crear un
kernel modular. En este caso, el kernel dispone de un conjunto de
componentes fundamentales y enlaza dinámicamente los servicios
adicionales, bien durante el arranque o en el tiempo de ejecución. Para
ello utiliza módulos se cargan dinámicamente y resulta habitual en las
implementaciones modernas de UNIX, como Solaris, Linux y Mac OS X.
El resultado global es similar al sisma de niveles, con la diferencia que un
modulo puede llamar a cualquier otro modulo. También es similar al uso de
microkernels, es más eficiente porque los módulos no requieren un
mecanismo de comunicación. En la siguiente imagen se observa la
estructura de Solaris.
3.6.
Máquinas virtuales
Esta estructura por niveles se plasma con el concepto de máquina virtual. La
idea fundamental es la de abstraer el hardware de la computadora, formando
20
Kernel de Solaris
Controladores de bus y los
dispositivos Modulos
misceláneos
Clases de planificacion
Sistema de archivos
Llamadas al sistema
cargables
Módulos STREAMS
Formatos ejecutables
Figura 1 Módulos cargables de Solaris
Sistemas Operativos UNMSM - FISI
varios entornos de ejecución diferentes, creando así la ilusión de que cada
entorno de ejecución está operando en su propia computadora privada. Con
técnicas de planificación de la CPU y las técnicas de memoria virtual, un
sistema operativo puede crear la ilusión de que un proceso tiene su propio
procesador con su propia memoria (virtual). El método de maquina virtual
proporciona una interfaz que es idéntica al básico hardware subyacente.
Una de las principales dificultades que presenta este método son los sistema
son los sistemas de disco, ya que si existieran tres unidades de disco y diez
maquinas virtuales no se les puede asignar a cada máquina una unidad de
disco. Su solución seria proporcionar discos virtuales, llamados minidiscos.
3.7.Arranque del sistema
Es el proceso de inicialización de la computadora mediante la carga del kernel
al momento de encenderse. En la mayoría de sistemas informáticos tiene una
pequeña parte de código conocida como programa de arranque o cargador de
arranque, que ese encarga de localizar el kernel, lo carga a la memoria
principal e inicia la ejecución. Algunos sistemas extraen del disco de programa
un programa más complejo que se encarga de cargar el kernel.
El programa de arranque puede realizar diversas tareas. Normalmente, una de
ellas consiste en ejecutar una serie diagnósticos para determinar el estado de
la maquina, que continua con la ejecución si no encuentra un error.
Una vez que se ha cargado el programa de arranque completo, puede explorar
el sistema de archivos para localizar el kernel, cárgalo en la memoria e iniciar
su ejecución. Solo en esta situación se dice que le sistema está en ejecución.
4. Operaciones con el sistema operativo
Los sistemas modernos están controlados a través de interrupciones (que avisa
cuando un dispositivo de E/S ha terminado). Si no hay ningún proceso para
21
Sistemas Operativos UNMSM - FISI
ejecutar, ningún dispositivo de E/S al que dar un servicio y ningún usuario al que
responder, un sistema operativo de permanecer inactivo, esperando que algo
ocurra. Los sucesos generalmente se indican con las interrupciones y las
excepciones. Una excepción es una interrupción generada por el software, debido
a un error. Las interrupciones son claves para la estructura de un sistema
operativo, ya que está controlado por estas. Para cada tipo de interrupción hay
distintos segmentos de código que determinan que acción se va a tomar ante
estas y se usar un rutina de servicio para tratarlas.
Dado un sistema operativo un grupo de usuarios que comparten recursos de
hardware y software, necesitamos asegurarnos que un error se produzca en un
programa de usuario solo genere problemas en el programa que se está
ejecutando. Un sistema operativo diseñado apropiadamente debe asegurar que
un programa incorrecto no pueda dar lugar a que otros programas se ejecuten
incorrectamente.
4.1.Operación en modo dual
Para asegurarse de la correcta ejecución del sistema operativo, tenemos que
distinguir entre el código del sistema y el código definido por el usuario. Para
esto, los sistemas informáticos proporcionan soporte al hardware que nos
permita diferenciar entre varios modos de ejecución.
Como mínimo necesitamos dos modos de ejecución: el modo usuario y el
modo kernel (también llamado modo supervisor o privilegiado), a los cuales se
les asigna un bit de modo para indicar el modo actual: kernel (0) y usuario (1).
Cuando un sistema está ejecutando una aplicación del usuario, el sistema se
encuentra en modo usuario. Pero, cuando una aplicación de usuario solicita un
servicio al sistema operativo, debe pasar por el modo kernel para satisfacer
esa necesidad.
22
Sistemas Operativos UNMSM - FISI
Cuando arranca el sistema lo hace en modo kernel, luego se cargan y se
inician las aplicaciones del usuario en el modo usuario. Cuan se produce
excepción o interrupción, el hardware conmuta del modo usuario al modo
kernel. En consecuencia, cuando el sistema operativo controla la
computadora, estará en modo kernel; y cambia a modo usuario (anteponiendo
el bit de modo 1) antes de pasar el control al modo usuario.
El modo dual nos permite proteger el sistema operativo de los usuarios que
puedan causar errores, y también proteger a los usuarios de errores de otros
usuarios. Esto se logra designando algunas instrucciones que puedan causar
daño como instrucciones privilegiadas, evitando así que se ejecuten en el
espacio usuario y que el sistema tome el control.
Las llamadas son el método que utiliza un proceso para que el sistema
operativo intervenga. Generalmente toman la forma de excepciones, que
pueden ser ejecutadas por la instrucción genérica trap o syscall.
Al ejecutarse una llamada de sistema, el hardware la trata como una
interrupción software. El control pasa a través del vector de interrupción a una
rutina de servicio del sistema operativo, y el bit de modo se establece en el
modo kernel. La rutina de llamada de servicio es una parte del sistema
operativo. El kernel examina la instrucción que interrumpe para determinar qué
llamado se ha producido; un parámetro indica que tipo de servicio está
requiriendo el programa. Puede pasarse informacion adicional necesaria para
la solicitud mediante registros, la pila o la memoria. El kernel verifica que los
parámetros sean correctos y legales, ejecuta la solicitud y devuelve el control a
la instrucción siguiente a la llamada. La falta de un modo dual puede ocasionar
varios errores al ejecutar un programa. Muchos de los sistemas operativos
actuales aprovechan esta capacidad para ofrecer una mayor protección al
23
Control de sistema operativo (modo
kernel)
Control de usuario (modo usuario)
Se devuelve el control al sistema
(interrupción)
Figura 2 Ciclo de ejecución.
Proceso de usuario
Kernel Excepción Bit de modo = 0 Retorno Bit de modo = 1
Ejecución proceso de usuario Llamadas al sistema Retorno de la llamada al sistema
Ejecutar llamada al sistema
Modo usuario Bit de modo = 1
Modo kernel Bit de modo = 0
Sistemas Operativos UNMSM - FISI
sistema operativo. Cuando se produce un error de programa, el sistema debe
terminar el programa anormalmente con el mismo código software que cuando
el usuario se pide la terminación anómala. El sistema proporciona el mensaje
de error adecuado y se puede volcar a la memoria del programa. Este se
escribe en archivo con el fin que sea corregido o reiniciado.
4.2.Temporizador
Debemos asegurar que el sistema operativo mantenga el control de la CPU
con el fin de impedir que un programa, por ejemplo, entre en un bucle infinito.
El temporizador se fija para que la computadora se interrumpa en un tiempo
dado. Puede ser fijo o variable. Por lo general se utiliza el último mediante un
reloj de frecuencia fija y un contador. El sistema operativo configura el
contador. Cuando el reloj avanza, el contador se decrementa.
Antes de devolver el control al usuario, el sistema operativo se asegura de que
el temporizador este configurado para realizar interrupciones. Cuando este
interrumpe, el control se control pasa directamente al sistema operativo, que
puede interpretarlo como un error fatal o pueden conceder más tiempo al
programa. Estas instrucciones que modifican el contenido del temporizador
son instrucciones privilegiadas.
Por lo tanto, podemos utilizarlo para impedir que un programa de usuario se
ejecute por un tiempo excesivo. Una técnica consiste en inicializar un contador
con la cantidad de tiempo que está permitido que se ejecute una aplicación.
Cada vez que se interrumpe, el contador resta una unidad. Si el valor del
contador pasa a ser positivo, el control se devuelve el programa de usuario; y
si el valor es negativo, el sistema termina el programa.
24
Figura 4 Transición del modo usuario al modo kernel
Sistemas Operativos UNMSM - FISI
5. Gestión de procesos
5.1.Concepto de proceso
Una pregunta que surge cuando se estudian los sistemas operativos es como
llamar a las diversas actividades de la CPU. Los sistemas de procesamiento
por lotes ejecutan trabajos, mientras que un sistema de tiempo compartido
tiene programas de usuario o tareas. Incluso en un sistema monousuario,
como Microsoft Windows, el usuario puede ejecutar varios programas al
mismo tiempo: un procesador de textos, un explorador web y un programa de
correo electrónico. Incluso aunque el usuario pueda ejecutar solo un programa
cada vez, el sistema operativo puede tener que dar soporte a sus propias
actividades internas programadas, como los mecanismos de gestión de la
memoria. En muchos aspectos, todas estas actividades son similares, por lo
que a todas ellas la denominamos procesos.
En este texto, los términos trabajo y proceso se usan indistintamente,
informalmente como hemos indicado antes, un proceso es un programa en
ejecución. Hay que resaltar que un proceso es algo más que el código de un
programa (al que en ocasiones se denomina sección de texto). Además del
código, un proceso incluye también la actividad actual, que queda
representada por el valor del contador de programa y por los contenidos de los
registros del procesador. Generalmente, un proceso incluye también la pila del
proceso, que contiene datos temporales, y una sección de datos, que contiene
las variables globales. El proceso puede incluir, asimismo, un cumulo de
memoria, que es la memoria que se asigna dinámicamente al proceso en
tiempo de ejecución.
Un proceso es simplemente, un programa en ejecución que necesita recursos
para realizar su tarea: tiempo de CPU, memoria, archivos y dispositivos de
E/S. El SO es el responsable de:
Crear y destruir procesos
Parar y reanudar procesos
25
Sistemas Operativos UNMSM - FISI
Ofrecer mecanismos para que los procesos puedan comunicarse y se
sincronicen
La gestión de procesos podría ser similar al trabajo de oficina. Se puede tener
una lista de tareas a realizar y a estas fijarles prioridades alta, media, baja por
ejemplo. Debemos comenzar haciendo las tareas de prioridad alta primero y
cuando se terminen seguir con las de prioridad media y después las de baja.
Una vez realizada la tarea se tacha. Esto puede traer un problema que las
tareas de baja prioridad pueden que nunca lleguen a ejecutarse y
permanezcan en la lista para siempre. Para solucionar esto, se puede asignar
alta prioridad a las tareas más antiguas.
5.2.Planificación de procesos
El objetivo de la multiprogramación es tener en ejecución varios procesos al
mismo tiempo a fin de maximizar la utilización de la CPU. El objetivo de los
sistemas de tiempo compartido es conmutar la CPU entre los distintos
procesos con tanta frecuencia que los usuarios puedan interactuar con cada
programa mientras este se ejecuta. Para conseguir estos objetivos, el
planificador de procesos selecciona un proceso disponible para ejecutar el
programa en la CPU. En los sistemas de un solo procesador, nunca habrá
más de un proceso en ejecución: si hay más procesos tendrán que esperar
hasta que la CPU este libre y se pueda asignar a otro proceso.
5.2.1. Tipos de planificación
La planificación de procesos se refiere a cómo determina el sistema
operativo al orden en que irá cediendo el uso del procesador a los procesos
que lo vayan solicitando, y a las políticas que empleará para que el uso que
den a dicho tiempo no sea excesivo respecto al uso esperado del sistema.
Podemos hablar de tres tipos principales de planificación:
A largo plazo: Decide qué procesos serán los siguientes en ser
iniciados. Este tipo de planificación era el más frecuente en los sistemas
de lotes y multiprogramado en lotes; las decisiones eran tomadas
principalmente considerando los requisitos pre-declarados de los
procesos y los que el sistema tenía libres al terminar algún otro proceso.
26
Sistemas Operativos UNMSM - FISI
La planificación a largo plazo puede llevarse a cabo con periodicidad de
una vez cada varios segundos, minutos e inclusive horas. En los
sistemas de uso interactivo, casi la totalidad de los que se usan hoy en
día, este tipo de planificación no se efectúa, dado que es típicamente el
usuario quien indica expresamente qué procesos iniciar.
A mediano plazo: Decide cuáles procesos es conveniente bloquear en
determinado momento, sea por escasez/saturación de algún recurso
(como la memoria primaria) o porque están realizando alguna solicitud
que no puede satisfacerse momentáneamente; se encarga de tomar
decisiones respecto a los procesos conforme entran y salen del estado
de bloqueado (esto es, típicamente, están a la espera de algún evento
externo o de la finalización de transferencia de datos con algún
dispositivo). En algunos textos, al planificador a mediano plazo se le
llama agendador.
A corto plazo: Decide cómo compartir momento a momento al equipo
entre todos los procesos que requieren de sus recursos, especialmente
el procesador. La planificación a corto plazo se lleva a cabo decenas de
veces por segundo (razón por la cual debe ser código muy simple,
eficiente y rápido); es el encargado de planificar los procesos que están
listos para ejecución. En algunos textos, al planificador a corto plazo se
le llama despachador.
5.3.Comunicación entre procesos
La comunicación entre procesos es una función básica de los sistemas
operativos. Los procesos pueden comunicarse entre sí a través de compartir
espacios de memoria, ya sean variables compartidas o buffers, o a través de
las herramientas provistas por las rutinas de IPC. La IPC provee un
mecanismo que permite a los procesos comunicarse y sincronizarse entre sí,
normalmente a través de un sistema de bajo nivel de paso de mensajes que
ofrece la red subyacente.
La comunicación se establece siguiendo una serie de reglas. Los protocolos
desarrollados para internet son los mayormente usados: IP (capa de red),
protocolo de control de transmisión (capa de transporte) y protocolo de
27
Sistemas Operativos UNMSM - FISI
transferencia de archivos, protocolo de transferencia de hipertexto (capa de
aplicación).
Los procesos pueden estar ejecutándose en una o más computadoras
conectadas a una red. Las técnicas de IPC están divididas dentro de métodos
para: paso de mensajes, sincronización, memoria compartida y llamadas de
procedimientos remotos (RPC). El método de IPC usado puede variar
dependiendo del ancho de banda y latencia (el tiempo desde el pedido de
información y el comienzo del envío de la misma) de la comunicación entre
procesos, y del tipo de datos que están siendo comunicados.
5.3.1. Tipos de comunicación
Síncrona: Quien envía permanece bloqueado esperando a que llegue
una respuesta del receptor antes de realizar cualquier otro ejercicio.
Asíncrona: Quien envía continúa con su ejecución inmediatamente
después de enviar el mensaje al receptor.
Persistente: El receptor no tiene que estar operativo al mismo tiempo
que se realiza la comunicación, el mensaje se almacena tanto tiempo
como sea necesario para poder ser entregado (Ej.: e-Mail).
Momentánea (transient): El mensaje se descarta si el receptor no está
operativo al tiempo que se realiza la comunicación. Por lo tanto no será
entregado.
Directa: Las primitivas enviar y recibir explicitan el nombre del proceso
con el que se comunican. Ejemplo: enviar (mensaje, A) envía un
mensaje al proceso A. Es decir se debe especificar cuál va a ser el
proceso fuente y cuál va a ser el proceso
Destino: Las operaciones básicas Send y Receive se definen de la
siguiente manera: Send (P, mensaje); envía un mensaje al proceso P (P
es el proceso destino). Receive (Q, mensaje); espera la recepción de un
mensaje por parte del proceso Q (Q es el proceso fuente).
Nota: Receive puede esperar de un proceso cualquiera, un mensaje,
pero el Send sí debe especificar a quién va dirigido y cuál es el
mensaje.
28
Sistemas Operativos UNMSM - FISI
Indirecta: Es aquella donde la comunicación está basada en una
herramienta o instrumento ya que el emisor y el receptor están a
distancia.
Simétrica: Todos los procesos pueden enviar o recibir. También
llamada bidireccional para el caso de dos procesos.
Asimétrica: Un proceso puede enviar, los demás procesos solo
reciben. También llamada unidireccional. Suele usarse para hospedar
servidores en Internet.
Uso de buffers automático: El transmisor se bloquea hasta que el
receptor recibe el mensaje (capacidad cero).
5.3.2. Comunicación en los sistemas cliente – servidor
La arquitectura cliente-servidor es un modelo de aplicación distribuida en el
que las tareas se reparten entre los proveedores de recursos o servicios,
llamados servidores, y los demandantes, llamados clientes. Un cliente
realiza peticiones a otro programa, el servidor, quien le da respuesta. Esta
idea también se puede aplicar a programas que se ejecutan sobre una sola
computadora, aunque es más ventajosa en un sistema operativo
multiusuario distribuido a través de una red de computadoras.
Algunos ejemplos de aplicaciones computacionales que usen el modelo
cliente-servidor son el Correo electrónico, un Servidor de impresión y la
World Wide Web.
En esta arquitectura la capacidad de proceso está repartida entre los
clientes y los servidores, aunque son más importantes las ventajas de tipo
organizativo debidas a la centralización de la gestión de la información y la
separación de responsabilidades, lo que facilita y clarifica el diseño del
sistema.
La separación entre cliente y servidor es una separación de tipo lógico,
donde el servidor no se ejecuta necesariamente sobre una sola máquina ni
es necesariamente un sólo programa. Los tipos específicos de servidores
incluyen los servidores web, los servidores de archivo, los servidores del
correo, etc. Mientras que sus propósitos varían de unos servicios a otros, la
arquitectura básica seguirá siendo la misma.
29
Sistemas Operativos UNMSM - FISI
Una disposición muy común son los sistemas multicapa en los que el
servidor se descompone en diferentes programas que pueden ser
ejecutados por diferentes computadoras aumentando así el grado de
distribución del sistema.
La red cliente-servidor es una red de comunicaciones en la cual los clientes
están conectados a un servidor, en el que se centralizan los diversos
recursos y aplicaciones con que se cuenta; y que los pone a disposición de
los clientes cada vez que estos son solicitados. Esto significa que todas las
gestiones que se realizan se concentran en el servidor, de manera que en
él se disponen los requerimientos provenientes de los clientes que tienen
prioridad, los archivos que son de uso público y los que son de uso
restringido, los archivos que son de sólo lectura y los que, por el contrario,
pueden ser modificados, etc. Este tipo de red puede utilizarse
conjuntamente en caso de que se esté utilizando en una red mixta.
5.4.Hebras
En sistemas operativos, un hilo de ejecución, hebra o subproceso es la unidad
de procesamiento más pequeña que puede ser planificada por un sistema
operativo.
La creación de un nuevo hilo es una característica que permite a una
aplicación realizar varias tareas a la vez (concurrentemente). Los distintos
hilos de ejecución comparten una serie de recursos tales como el espacio de
memoria, los archivos abiertos, situación de autenticación, etc. Esta técnica
permite simplificar el diseño de una aplicación que debe llevar a cabo distintas
funciones simultáneamente.
Un hilo es simplemente una tarea que puede ser ejecutada al mismo tiempo
con otra tarea.
Los hilos de ejecución que comparten los mismos recursos, sumados a estos
recursos, son en conjunto conocidos como un proceso. El hecho de que los
hilos de ejecución de un mismo proceso compartan los recursos hace que
cualquiera de estos hilos pueda modificar éstos. Cuando un hilo modifica un
30
Sistemas Operativos UNMSM - FISI
dato en la memoria, los otros hilos acceden a ese dato modificado
inmediatamente.
Lo que es propio de cada hilo es el contador de programa, la pila de ejecución
y el estado de la CPU (incluyendo el valor de los registros).
El proceso sigue en ejecución mientras al menos uno de sus hilos de
ejecución siga activo. Cuando el proceso finaliza, todos sus hilos de ejecución
también han terminado. Asimismo en el momento en el que todos los hilos de
ejecución finalizan, el proceso no existe más y todos sus recursos son
liberados.
Algunos lenguajes de programación tienen características de diseño
expresamente creadas para permitir a los programadores lidiar con hilos de
ejecución (como Java o Delphi). Otros (la mayoría) desconocen la existencia
de hilos de ejecución y éstos deben ser creados mediante llamadas de
biblioteca especiales que dependen del sistema operativo en el que estos
lenguajes están siendo utilizados (como es el caso del C y del C++).
Un ejemplo de la utilización de hilos es tener un hilo atento a la interfaz gráfica
(iconos, botones, ventanas), mientras otro hilo hace una larga operación
internamente. De esta manera el programa responde de manera más ágil a la
interacción con el usuario. También pueden ser utilizados por una aplicación
servidora para dar servicio a múltiples clientes.
5.4.1. Modelos multihebras
Ahora bien, tras centrarnos para toda la presente discusión en los
procesos, ¿cómo caben los hilos en este panorama? Depende de cómo
éstos son mapeados a procesos a ojos del planificador.
Como vimos en la unidad de Administración de procesos, hay dos clases
principales de hilo: Los hilos de usuario o hilos verdes, que son
completamente gestionados dentro del proceso y sin ayuda del sistema
operativo, y los hilos de núcleo o hilos de kernel, que sí son gestionados
por el sistema operativo como si fueran procesos. Partiendo de esto,
podemos hablar de tres modelos principales de mapeo:
31
Sistemas Operativos UNMSM - FISI
Muchos a uno: Muchos hilos son agrupados en un sólo proceso. Los
hilos verdes entran en este supuesto: Para el sistema operativo, hay un
sólo proceso; mientras tiene la ejecución, éste se encarga de repartir el
tiempo entre sus hilos. Bajo este modelo, si bien el código escrito es
más portable entre diferentes sistemas operativos, los hilos no
aprovechan realmente al paralelismo, y todos los hilos pueden tener
que bloquearse cuando uno sólo de ellos realiza una llamada
bloqueante al sistema.
Uno a uno: Cada hilo es ejecutado como un proceso ligero (lightweight
process o LWP); podría dar la impresión de que este esquema
desperdicia la principal característica de los hilos, que es una mayor
sencillez y rapidez de inicialización que los procesos, sin embargo, la
información de estado requerida para crear un LWP es mucho menor
que la de un proceso regular, y mantiene como ventaja que los hilos
continúan compartiendo su memoria, descriptores de archivos y demás
estructuras. Este mecanismo permite a los hilos aprovechar las ventajas
del paralelismo, pudiendo ejecutarse cada hilo en un procesador
distinto, y como única condición para su existencia, el sistema operativo
debe poder implementar los LWP.
Muchos a muchos: Este mecanismo permite que existan hilos de
ambos modelos: Permite la existencia de hilos unidos, en que cada hilo
corresponde a un (y sólo un) LWP, y de hilos no unidos, de los cuales
uno o más estarán mapeados a cada LWP.
El esquema muchos a muchos proporciona las principales
características de ambos esquemas; en caso de ejecutarse en un
sistema que no soporte más que el modelo uno a muchos, el sistema
puede caer en éste como modo degradado.
No nos ocupamos en este caso de los primeros — Cada marco de
desarrollo o máquina virtual que emplee hilos de usuario actuará cual
sistema operativo ante ellos, probablemente con alguno de los
mecanismos ilustrados anteriormente.
32
Sistemas Operativos UNMSM - FISI
5.4.2. Bibliotecas de hebras
Una biblioteca de hebras proporciona al programador una API para crea y
gestionar hebras. Existen dos formas principales de implementar una
biblioteca de hebras. El primer método consiste en proporcionar una
biblioteca enteramente en el espacio de usuario, sin ningún soporte del
kernel. Todas las estructuras de datos y el código de la biblioteca se
encuentran en el espacio de usuario y no una llamada al sistema.
El segundo método consiste en implementar una biblioteca en el nivel del
kernel, soportada directamente por el sistema operativo. En este caso, el
código y las estructuras de datos de la biblioteca se encuentran en el
espacio del kernel. Invocar una función en la API de la biblioteca
normalmente da a lugar a que se produzca una llamada al sistema dirigida
al kernel.
Las tres principales bibliotecas de hebras actualmente en uso son: (1)
POSIX Pthreads, (2) Win32 y (3) Java Pthreads, la extensión de hebras del
estándar POSIX, puede proporcionarse como biblioteca del nivel de usuario
o del nivel del kernel. La biblioteca de hebras de Win32 es una biblioteca
del nivel de kernel disponible en los sistemas Windows. La API de hebras
Java permite crear y gestionar directamente hebras en los programas Java.
Sin embargo, puesto que en la mayoría de los casos la JVM se ejecuta por
encima del sistema operativo del host, la API de hebras Java se
implementa habitualmente usando una biblioteca de hebras disponible en
el sistema host. Esto significa que normalmente en los sistemas Windows,
las hebras Java se implementa usando la API de Win32, mientras que en
los sistemas Linux se suelen implementar usando Pthreads.
5.5.Planificación de la CPU
Los mecanismos de planificación de la CPU son la base de los sistemas
operativos multiprogramado. Mediante la conmutación de la CPU entre
distintos procesos, el sistema operativo puede hacer que la computadora sea
más productiva.
33
Sistemas Operativos UNMSM - FISI
5.5.1. Ráfagas de CPU y ráfagas de E/S.
Anteriormente habíamos mencionado lo que era un proceso, ahora,
viéndolo del área más "física", un proceso es un conjunto de ráfagas de
CPU y ráfagas de E/S, pero ¿qué son estas?
Ráfagas de CPU: es el ciclo en donde se realizan las instrucciones del
proceso.
Ráfagas de E/S: es el ciclo en donde se utilizan o esperan los
dispositivos de Entrada y Salida.
Primero se realiza una ráfaga de CPU, y luego una ráfaga de E/S, luego
una ráfaga de CPU, luego una de E/S, luego una de CPU, y otra de E/S, y
así indefinidamente hasta que el programa se le pida terminar, en este
caso, la última ráfaga es de CPU, puesto que se necesitan las
instrucciones de cerrar.
5.5.2. Planificador de la CPU
Cuando la CPU queda inactiva, el sistema operativo debe seleccionar uno de
los procesos que se encuentran en la cola de procesos preparados para
ejecución. El planificador a corto plazo lleva a cabo esa selección de proceso.
El planificador elige uno de los procesos que están en memoria preparados
para ejecutarse y asigna la CPU a dicho proceso.
El planificador es un componente funcional muy importante de los sistemas
operativos multitarea y multiproceso, y es esencial en los sistemas operativos
de tiempo real. Su función consiste en repartir el tiempo disponible de un
microprocesador entre todos los procesos que están disponibles para su
ejecución.
5.5.3. Criterios de planificación
Utilización de la CPU, queremos que la CPU se mantenga tan ocupada
como sea posible.
Rendimiento, una medida del trabajo es el número de procesos que se
completa por unidad de tiempo.
34
Sistemas Operativos UNMSM - FISI
Tiempo de Retorno, sería la suma de los periodos transcurridos
esperando entrar en la memoria, esperando en la cola de procesos
listos, ejecutándose en la CPU y efectuando operaciones de E/S.
Tiempo de espera, es el tiempo que el proceso espera en la cola de
procesos listos.
El tiempo de respuesta, el tiempo transcurrido desde la presentación de
una solicitud hasta que se produce la primera respuesta.
Siempre vamos a intentar maximizar la productividad (el tiempo de CPU) y
se intenta minimizar el tiempo de retorno, de respuesta y el de espera.
5.5.4. Algoritmos de planificaciónEl planificador a corto plazo puede ser invocado cuando un proceso se
encuentra en algunas de las cuatro siguientes circunstancias:
a. Pasa de estar ejecutando a estar en espera (por ejemplo, por solicitar
una operación de E/S, esperar a la sincronización con otro proceso,
etc.)
b. Pasa de estar ejecutando a estar listo (por ejemplo, al ocurrir una
interrupción. Deja de estar en espera a estar listo (por ejemplo, al
finalizar la operación de E/S que solicitó).
c. Finaliza su ejecución, y pasa de ejecutando a terminado.
d. En el primer y cuarto casos, el sistema operativo siempre tomará el
control; un sistema que opera bajo multitarea preventiva implementará
también el segundo y tercer casos, mientras que uno que opera bajo
multitarea cooperativa no necesariamente reconocerá dichos estados.
e. Ahora, para los algoritmos a continuación, recordemos que en este caso
estamos hablando únicamente del despachador. Un proceso siempre
abandonará la cola de procesos listos al requerir de un servicio del
sistema.
f. Para todos los ejemplos a continuación, asumamos que los tiempos
están dados en ticks; no nos preocupa en este caso a cuánto tiempo de
reloj estos equivalen, sino el rendimiento relativo del sistema entero
ante una carga dada.
35
Sistemas Operativos UNMSM - FISI
5.5.5. Sincronización de procesos
En muchos casos, los procesos se reúnen para realizar tareas en conjunto,
a este tipo de relación se le llama procesos cooperativos. Para lograr la
comunicación, los procesos deben sincronizarse, de no ser así pueden
ocurrir problemas no deseados. La sincronización es la transmisión y
recepción de señales que tiene por objeto llevar a cabo el trabajo de un
grupo de procesos cooperativos.
Es la coordinación y cooperación de un conjunto de procesos para
asegurar la comparación de recursos de cómputo. La sincronización entre
procesos es necesaria para prevenir y/o corregir errores de sincronización
debidos al acceso concurrente a recursos compartidos, tales como
estructuras de datos o dispositivos de E/S, de procesos contendientes. La
sincronización entre procesos también permite intercambiar señales de
tiempo (ARRANQUE/PARADA) entre procesos cooperantes para
garantizar las relaciones específicas de precedencia impuestas por el
problema que se resuelve.
Sin una sincronización adecuada entre procesos, la actualización de
variables compartidas puede inducir a errores de tiempo relacionados con
la concurrencia que son con frecuencia difíciles de depurar. Una de las
causas principales de este problema es que procesos concurrentes puedan
observar valores temporalmente inconsistentes de una variable compartida
mientras se actualizan. Una aproximación para resolver este problema es
realizar actualizaciones de variables compartidas de manera mutuamente
exclusiva. Se pueden mejorar permitiendo que a lo más un proceso entre a
la vez en la sección crítica de código en la que se actualiza una variable
compartida o estructura de datos en particular.
Para que los procesos puedan sincronizarse es necesario disponer de
servicios que permitan bloquear o suspender bajo determinadas
circunstancias la ejecución de un proceso. Los principales mecanismos de
sincronización que ofrecen los sistemas operativos son:
Señales
Tuberías
36
Sistemas Operativos UNMSM - FISI
Semáforos
Mutex y variables condicionales
Paso de mensajes
5.5.6. El problema de la sección critica
Se denomina sección crítica, en programación concurrente, a la porción de
código de un programa de ordenador en la que se accede a un recurso
compartido (estructura de datos o dispositivo) que no debe ser accedido
por más de un proceso o hilo en ejecución. La sección crítica por lo general
termina en un tiempo determinado y el hilo, proceso o tarea sólo tendrá que
esperar un período determinado de tiempo para entrar. Se necesita un
mecanismo de sincronización en la entrada y salida de la sección crítica
para asegurar la utilización en exclusiva del recurso, por ejemplo un
semáforo.
El acceso concurrente se controla teniendo cuidado de las variables que se
modifican dentro y fuera de la sección crítica. La sección crítica se utiliza
por lo general cuando un programa multihilo actualiza múltiples variables
sin un hilo de ejecución separado que lleve los cambios conflictivos a esos
datos. Una situación similar, la sección crítica puede ser utilizada para
asegurarse de que un recurso compartido, por ejemplo, una impresora,
pueda ser accedida por un solo proceso a la vez.
La manera en cómo se implementan las secciones puede variar
dependiendo de los diversos sistemas operativos. Sólo un proceso puede
estar en una sección crítica a la vez. El método más común para evitar que
dos procesos accedan al mismo tiempo a un recurso es el de la exclusión
mutua.
5.5.7. Solución de Peterson
El algoritmo de Peterson, también conocido como solución de Peterson, es
un algoritmo de programación concurrente para exclusión mutua, que
permite a dos o más procesos o hilos de ejecución compartir un recurso sin
conflictos, utilizando sólo memoria compartida para la comunicación.
37
Bandera[0] = false
bandera[1] = false
turno = 0
p0: bandera[0] = true p1: bandera[1] =
true
turno = 1 turno = 0
while( bandera[1] && turno == 1 );
while( bandera[0] && turno == 0 );
//no hace nada; espera.
//no hace nada; espera.
// sección crítica // sección
crítica
// fin de la sección crítica // fin de la
sección crítica
bandera[0] = false bandera[1] =
false
Sistemas Operativos UNMSM - FISI
Peterson desarrolló en 1981 el algoritmo básico para dos procesos, como
una simplificación del algoritmo de Dekker. El algoritmo básico puede
generalizarse fácilmente a un número arbitrario de procesos.
Algoritmo para dos procesos
Los procesos p0 y p1 no pueden estar en la sección crítica al mismo
tiempo: si p0 está en la sección crítica, entonces bandera [0] = 1, y
ocurre que bandera [1] = 0, con lo que p1 ha terminado la sección
crítica, o que la variable compartida turno = 0, con lo que p1 está
esperando para entrar a la sección crítica. En ambos casos, p1 no
puede estar en la sección crítica.
38
// Variables compartidas
bandera: array[0..N-1] of -1..n-2; /* inicializada a –1 */
turno: array[0..N-2] of 0..n-1; /* inicializada a 0 */
// Protocolo para Pi (i=0,..., N-1)
J:0..N-2; /* variable local indicando la etapa */
for j = 0 to N-2
{
bandera[i] = j;
turno[j] = i;
while [(∃ k ≠ i : bandera[k] ≥ j) ∧ (turno[k] == i)] do; }
<sección crítica>
bandera[i] = -1;
Sistemas Operativos UNMSM - FISI
Algoritmo para N procesos
5.6.Semáforos
Un semáforo es una variable especial (o tipo abstracto de datos) que
constituye el método clásico para restringir o permitir el acceso a recursos
compartidos (por ejemplo, un recurso de almacenamiento del sistema o
variables del código fuente) en un entorno de multiprocesamiento (en el que se
ejecutarán varios procesos concurrentemente). Fueron inventados por Edsger
Dijkstra en 1965 y se usaron por primera vez en el sistema operativo THEOS.
Los semáforos se emplean para permitir el acceso a diferentes partes de
programas donde se manipulan variables o recursos que deben ser accedidos
de forma especial. Según el valor con que son inicializados se permiten a más
o menos procesos utilizar el recurso de forma simultánea.
Un tipo simple de semáforo es el binario, que puede tomar solamente los
valores 0 y 1. Se inicializan en 1 y son usados cuando sólo un proceso puede
acceder a un recurso a la vez. Son esencialmente lo mismo que los Mutex.
Cuando el recurso está disponible, un proceso accede y decremento el valor
del semáforo con la operación P. El valor queda entonces en 0, lo que hace
39
Sistemas Operativos UNMSM - FISI
que si otro proceso intenta decrementarlo tenga que esperar. Cuando el
proceso que decremento el semáforo realiza una operación V, algún proceso
que estaba esperando comienza a utilizar el recurso.
Para hacer que dos procesos se ejecuten en una secuencia predeterminada
puede usarse un semáforo inicializado en 0. El proceso que debe ejecutar
primero en la secuencia realiza la operación V sobre el semáforo antes del
código que debe ser ejecutado después del otro proceso. Éste ejecuta la
operación P. Si el segundo proceso en la secuencia es programado para
ejecutar antes que el otro, al hacer P dormirá hasta que el primer proceso de
la secuencia pase por su operación V. Este modo de uso se denomina
señalización, y se usa para que un proceso o hilo de ejecución le haga saber a
otro que algo ha sucedido.
5.7.Interbloqueos
El bloqueo mutuo es el bloqueo permanente de un conjunto de procesos o
hilos de ejecución en un sistema concurrente que compiten por recursos del
sistema o bien se comunican entre ellos. A diferencia de otros problemas de
concurrencia de procesos, no existe una solución general para los
interbloqueos.
Todos los interbloqueos surgen de necesidades que no pueden ser
satisfechas, por parte de dos o más procesos. En la vida real, un ejemplo
puede ser el de dos niños que intentan jugar al arco y flecha, uno toma el arco,
el otro la flecha. Ninguno puede jugar hasta que alguno libere lo que tomó.
En el siguiente ejemplo, dos procesos compiten por dos recursos que
necesitan para funcionar, que sólo pueden ser utilizados por un proceso a la
vez. El primer proceso obtiene el permiso de utilizar uno de los recursos
(adquiere el lock sobre ese recurso). El segundo proceso toma el lock del otro
recurso, y luego intenta utilizar el recurso ya utilizado por el primer proceso,
por lo tanto queda en espera. Cuando el primer proceso a su vez intenta
utilizar el otro recurso, se produce un interbloqueo, donde los dos procesos
esperan la liberación del recurso que utiliza el otro proceso.
40
Sistemas Operativos UNMSM - FISI
5.7.1. Condiciones necesarias
También conocidas como condiciones de Coffman por su primera
descripción en 1971 en un artículo escrito por E. G. Coffman. Estas
condiciones deben cumplirse simultáneamente y no son totalmente
independientes entre ellas.
Sean los procesos P0, P1,..., Pn y los recursos R0, R1,..., Rm:
Condición de exclusión mutua: Existencia de al menos de un recurso
compartido por los procesos, al cual sólo puede acceder uno
simultáneamente.
Condición de retención y espera: Al menos un proceso Pi ha
adquirido un recurso Ri, y lo retiene mientras espera al menos un
recurso Rj que ya ha sido asignado a otro proceso.
Condición de no expropiación: Los recursos no pueden ser
expropiados por los procesos, es decir, los recursos sólo podrán ser
liberados voluntariamente por sus propietarios.
Condición de espera circular: Dado el conjunto de procesos P0...Pm
(subconjunto del total de procesos original), P0 está esperando un
recurso adquirido por P1, que está esperando un recurso adquirido por
P2,..., que está esperando un recurso adquirido por Pm, que está
esperando un recurso adquirido por P0. Esta condición implica la
condición de retención y espera.
5.7.2. Evitando bloqueos mutuos
Los bloqueos mutuos pueden ser evitados si se sabe cierta información
sobre los procesos antes de la asignación de recursos. Para cada petición
de recursos, el sistema controla si satisfaciendo el pedido entra en un
estado inseguro, donde puede producirse un bloqueo mutuo. De esta
forma, el sistema satisface los pedidos de recursos solamente si se
asegura que quedará en un estado seguro. Para que el sistema sea capaz
de decidir si el siguiente estado será seguro o inseguro, debe saber por
adelantado y en cualquier momento el número y tipo de todos los recursos
en existencia, disponibles y requeridos. Existen varios algoritmos para
evitar bloqueos mutuos:
41
Sistemas Operativos UNMSM - FISI
Algoritmo del banquero, introducido por Dijkstra.
Algoritmo de grafo de asignación de recursos.
Algoritmo de Seguridad.
Algoritmo de solicitud de recursos.
5.7.3. Prevención
Los bloqueos mutuos pueden prevenirse asegurando que no suceda
alguna de las condiciones necesarias vistas anteriormente.
Eliminando la exclusión mutua: ningún proceso puede tener acceso
exclusivo a un recurso. Esto es imposible para procesos que no pueden
ser encolados (puestos en un spool), e incluso con colas también
pueden ocurrir interbloqueos.
La condición de posesión y espera puede ser eliminada haciendo que
los procesos pidan todos los recursos que van a necesitar antes de
empezar. Este conocimiento por adelantado muchas veces es imposible
nuevamente. Otra forma es requerir a los procesos liberar todos sus
recursos antes de pedir todos los recursos que necesitan. Esto también
es poco práctico en general.
La condición de no expropiación puede ser también imposible de
eliminar dado que un proceso debe poder tener un recurso por un cierto
tiempo o el procesamiento puede quedar inconsistente.
La condición de espera circular es la más fácil de atacar. Se le permite
a un proceso poseer sólo un recurso en un determinado momento, o
una jerarquía puede ser impuesta de modo tal que los ciclos de espera
no sean posibles.
5.7.4. Livelock
Un livelock es similar a un deadlock, excepto que el estado de los dos
procesos envueltos en el livelock constantemente cambia con respecto al
otro. Livelock es una forma de inanición y la definición general sólo dice
que un proceso específico no está procesando.
En un ejemplo del mundo real, un livelock ocurre por ejemplo cuando dos
personas, al encontrarse en un pasillo angosto avanzando en sentidos
opuestos, y cada una trata de ser amable moviéndose a un lado para dejar
42
Sistemas Operativos UNMSM - FISI
a la otra persona pasar, pero terminan moviéndose de lado a lado sin tener
ningún progreso, pues ambos se mueven hacia el mismo lado, al mismo
tiempo.
Livelock es un riesgo con algunos algoritmos que detectan y recuperan los
interbloqueos, pues si más de uno toma cartas en el asunto, la detección
del interbloqueo puede ser disparada continuamente; pudiendo ser
arreglado asegurándose que sólo un proceso (escogido al azar o por
prioridad) tome acción.
6. Gestión de memoria
6.1.Memoria principal
Hay diversas formas de gestionar la memoria, como los algoritmos de gestión
de memoria. Estos van desde técnicas primitivas, sin soporte hardware
específico, a estrategias de paginación y segmentación. Como veremos
muchos de estos algoritmos requieren soporte de hardware, aunque los
diseños más recientes integran de manera estrecha el hardware y el sistema
operativo.
6.1.1. Fundamentos
La memoria es componente crucial para la operación de un sistema
informático moderno. La memoria está compuesta de una gran matriz de
palabras o bytes, cada uno con su propia dirección. La CPU extrae
instrucciones de la memoria de acuerdo con el valor del contador de
programa. Estas instrucciones pueden provocar operaciones adicionales de
carga o de almacenamiento en direcciones de memoria específicas.
43
Sistemas Operativos UNMSM - FISI
Un ciclo típico de ejecución de una instrucción procedería en primer lugar a
extraer una instrucción de la memoria. Dicha instrucción se decodifica y
puede hacer que se extraigan de memoria una serie de operandos.
Después de haber ejecutado la instrucción con esos operandos, es posible
que se almacenen los resultados de nuevo en memoria. La unidad de
memoria tan solo ve un flujo de direcciones de memoria y no sabe cómo se
generan esas direcciones ni tampoco para que se utilizan. Por tanto,
podemos ignorar el cómo genera el programa las direcciones de memoria,
lo único que nos interesa es la secuencia de direcciones de memoria
generada por el programa en ejecución. Entre estas cuestiones se incluyen
una panorámica de los problemas de hardware básicos, los mecanismos
de acoplamiento de las direcciones físicas reales y los métodos que existen
para distinguir entre direcciones lógicas y físicas.
6.1.1.1. Hardware básico
La memoria principal y los registros integrados dentro del propio
procesador son las únicas aéreas de almacenamiento a las que la CPU
puede acceder directamente. Hay instrucciones de máquina que toman
como argumentos direcciones de memoria, pero no existe ninguna
instrucción que acepte direcciones de disco. Por lo tanto, todas las
instrucciones de ejecución y los datos utilizados por esas instrucciones
deberán encontrarse almacenados en uno de esos dispositivos de
almacenamiento de acceso directo. Si los datos no se encuentran en
memoria, deberán llevarse hasta allí antes de que la CPU pueda operar
con ellos.
Generalmente pueden accederse a los requisitos integrados en la CPU
en un único ciclo de reloj del procesador. No podemos decir lo mismo
de la memoria principal, a la que se accede mediante una transacción
del bus de memoria. El acceso a memoria puede requerir muchos ciclos
del reloj del procesador para poder completar, en cuyo caso el
procesador debe detenerse. Esta situación es intolerable, debido a la
gran frecuencia con la que se accede a la memoria. El remedio consiste
en añadir una memoria rápida entre la CPU y la memoria principal.
44
Sistemas Operativos UNMSM - FISI
No solo debemos preocuparnos de la velocidad relativa del acceso a la
memoria física, sino que también debemos garantizar una correcta
operación que proteja al sistema operativo de los posible accesos por
parte de los procesos de los usuarios y que también proteja a unos
procesos de usuario de otros. Primero tenemos que asegurarnos de
que cada proceso disponga de un espacio de memoria separado. Para
esto debemos poder determinar el rango de direcciones legales. El
registro base almacena la dirección de memoria física legal más
pequeña, mientras que el registro limite específica el tamaño del rango.
La protección del espacio de memoria se consigue haciendo que el
hardware de la CPU compare todas las direcciones generadas en modo
usuario con el contenido de esos registros. Cualquier intento, por parte
de un programa que se esté ejecutando en modo usuario, de acceder a
la memoria del sistema operativo o a la memoria de otros usuarios hará
que se produzca una interrupción hacia el sistema operativo, que tratara
dicho intento como error fatal. Los registros base y limite solo pueden
ser cargados por el sistema operativo, que utiliza una instrucción
privilegiada especial. Para esto ejecuta en el modo kernel; y cuando el
sistema se ejecuta en este modo, tiene acceso no restringido a la
memoria tanto del sistema operativo como de los usuarios, esto permite
al sistema operativo cargarlos programas de los usuarios en la memoria
de los usuarios, volcar dichos programas en caso de error, leer y
modificar parámetros de las llamadas del sistema.
6.1.1.2. Reasignación de direcciones
Usualmente, los programas residen en un disco en forma de archivos
ejecutables binarios. Dependiendo del mecanismo de gestión que se
use, el proceso puede desplazarse entre disco y memoria durante su
ejecución. Los procesos del disco que estén esperando a ser cargados
en la memoria durante su ejecución forman lo que se denomina cola de
entrada.
El procesamiento normal consiste en seleccionar uno de los procesos
de la cola de entrada y cargar dicho proceso de en memoria. A medida
45
Sistemas Operativos UNMSM - FISI
que se ejecute el proceso, este accede a las instrucciones y datos
contenidos en la memoria. Eventualmente, el proceso terminara su
ejecución y su espacio de memoria será declarado como disponible.
Las direcciones del programa fuente son generalmente simbólicas.
Normalmente, un compilador se encargará de reasignar estas
direcciones simbólicas a direcciones reubicables. Clásicamente, la
reasignación de las instrucciones y los datos a direcciones de memoria
puede realizarse en cualquiera de los pasos.
Tiempo de compilación: si sabemos en el momento de realizar
la compilación donde va a residir el proceso en memoria,
podremos generar código absoluto. Si la ubicación inicial
cambiase en algún instante posterior, entonces sería necesario
recopilar ese código.
Tiempo de carga: Si no conocemos el tiempo de compilación
sonde va a residir el proceso en memoria, el compilador deberá
generar código reubicable. En este caso, retarda la reasignación
final hasta el momento de la carga. Si cambia la dirección inicial,
tan solo es necesario volver a cargar el código de usuario para
incorporar el valor modificado.
Tiempo de ejecución: Si el proceso puede desplazarse durante
su ejecución desde un segmento de memoria otro, entonces es
necesario retardar la reasignación hasta el instante de ejecución.
6.1.1.3. Espacio de direcciones lógico y físico
Una dirección generada por la CPU se denomina comúnmente dirección
lógica, mientras que una dirección vista por la unidad de memoria se
denomina memoria física. Los métodos de reasignación en tiempo de
compilación y tiempo de carga generar direcciones lógicas y físicas
idénticas. Sin embargo, el esquema de reasignación de direcciones en
tiempo de ejecución hace que las direcciones lógicas y físicas difieran.
En este caso, usualmente decimos que la dirección lógica es una
dirección virtual. El conjunto de todas las direcciones lógicas generadas
por un programa es lo que se denomina un espacio de direcciones
46
Sistemas Operativos UNMSM - FISI
lógicas; conjunto de todas las direcciones físicas correspondientes a
estas direcciones lógicas es un espacio de direcciones físicas. Así, el
esquema de reasignación de direcciones en tiempo de ejecución,
decimos que los espacios de direcciones lógicas y físicas difieren.
El programa de usuario maneja direcciones lógicas y el hardware de
conversión (mapeo) de memoria convierte esas direcciones lógicas en
direcciones físicas. Ahora tenemos dos tipos diferentes de direcciones
lógicas (de 0 a máx.) y direcciones físicas (de r+0 a r + máx. para un
valor base igual a r). El usuario solo genera direcciones lógicas y piensa
que el proceso se ejecuta en ubicaciones comprensibles entre 0 y máx.
El programa de usuario sumistra direcciones lógicas y estas deben
convertirse en físicas antes de utilizarlas.
El concepto de un espacio de direcciones lógicas que se acopla a un
espacio de direcciones físicas separado resulta crucial para la adecuada
gestión de memoria
6.1.1.4. Carga dinámica
El tamaño del proceso está limitado por el tamaño de la memoria física.
Para obtener una mejor utilización del espacio de memoria, podemos
utilizar el mecanismo de carga dinámica. Con ella, una rutina no se
carga hasta que se la invoca; todas se mantienen el disco como va
carga reubicable. En este método, el programa principal se carga en la
memoria y se ejecuta. Cuando una rutina necesita llamar a otra rutina,
la rutina que realiza la invocación comprueba primero si la otra ya ha
sido cargada, de no ser así, se invoca el cargador de montaje
reubicable para que cargue en memoria la rutina deseada y para que se
actualice las tablas de direcciones del programa con el fin de reflejar
este cambio. Después, se pasa el control a la rutina recién cargada. La
ventaja de este mecanismo de carga dinámica es que una rutina no
utilizada no se cargara nunca en la memoria.
6.1.1.5. Montaje dinámico y bibliotecas compartidas
Algunos sistemas operativos solo permiten el montaje estático,
mediante el cual las bibliotecas de lenguaje del sistema se tratan como
47
Sistemas Operativos UNMSM - FISI
cualquier otro modulo objeto son integradas por el cargador dentro de la
imagen binaria del programa. El concepto de montaje binario es similar
al de carga dinámica, aunque en este caso lo que se pospone hasta el
momento de la ejecución es el montaje, en lugar de la carga. Esta
funcionalidad suele emplearse con las bibliotecas del sistema, como por
ejemplo las bibliotecas de subrutinas de lenguaje.
Con el montaje dinámico, se incluye un stub dentro de la imagen binaria
para cada referencia a una rutina de la biblioteca. El stub es un pequeño
fragmento de código que indica como localizar la rutina adecuada de
biblioteca residente en la memoria o como cargar la biblioteca si esa
rutina no está todavía presente. Cuando se ejecuta el stub, esta
comprueba si la rutina necesaria ya se encuentra en la memoria, de no
ser así, el programa carga en la memoria la rutina. En cualquiera de los
casos, el stub se sustituye así mismo por la dirección de la rutina y
ejecuta la rutina. Así, la siguiente ves que se ejecute ese segmento de
código concreto, se ejecutara directamente la rutina de de biblioteca, sin
tener que realizar de nuevo el montaje dinámico. Con este mecanismo,
todos los procesos que utilicen una determinada biblioteca de lenguaje
solo necesitan ejecutar una copia del código de la biblioteca.
Esta funcionalidad puede ampliarse a las actualizaciones de las
bibliotecas de código. Puede sustituirse una biblioteca por una nueva
versión y todos los programas que hagan referencia a la biblioteca
emplearan automáticamente la versión más reciente. Puede haber más
de una versión de una biblioteca cargada en la memoria y cada
programa utilizará su informacion de versión para decidir que copia de
la biblioteca va a utilizar. Los cambios de menor entidad retendrán el
mismo número de versión, mientras que las de mayor entidad se
incrementarán ese número. De ese modo, solo los programas que se
compilen con la nueva versión de la biblioteca se verán afectados por
los cambios incompatibles incorporados en ella. Otros programas
mondos antes de que se instalara la nueva biblioteca continuaran
utilizando la antigua. Este mecanismo se conoce con el nombre de
mecanismo de bibliotecas compartidas.
48
Sistemas Operativos UNMSM - FISI
6.1.2. Intercambio
Un proceso debe estar en memoria para ser ejecutado. Sin embargo, los
procesos pueden ser intercambiados temporalmente, sacándolos de la
memoria y almacenados en un almacén de respaldo y volviéndolos a llevar
luego a memoria para continuar ejecución.
Los mecanismos de intercambio requieren un almacén de respaldo, que
normalmente será un disco suficientemente rápido. El disco debe ser
también lo suficientemente grande como para poder albergar copias de
todas las imágenes de memoria para todos los usuarios, y debe
proporcionar un acceso directo a esas imágenes de memoria. El sistema
mantiene una cola de procesos preparados que consistirá en todos los
procesos cuyas imágenes de memoria se encuentren en el almacén de
respaldo o en la memoria y estén listos para ejecutarse.
Para que este método se efectivo, el usuario debe mantener informado al
sistema acerca de cualquier cambio que se produzca en los que se refiere
a los requisitos de sistema. Así, un proceso con requisitos de memoria
dinámicos necesitará ejecutar una llamada al sistema (request memory
y relese memory) para informar al sistema operativo de sus
cambiantes necesidades de memoria.
El intercambio está restringido también por otros factores. Si queremos
intercambiar un proceso, deberemos asegurarnos de que esté
completamente inactivo. En este sentido, es necesario prestar una atención
especial a todas las operaciones de E/S pendientes. Generalmente el
espacio de intercambio se asigna como un área disco separada del sistema
de archivos, para que su uso sea lo más rápido posible. Actualmente estos
mecanismos se utilizan en muy pocos sistemas.
6.1.2.1. Asignación de memoria contigua
La memoria principal debe albergar tanto el sistema operativo como los
diversos procesos de usuario. Por lo tanto, necesitamos asignar las
distintas partes de la memoria principal de la forma más eficiente
posible.
49
Sistemas Operativos UNMSM - FISI
La memoria esta usualmente dividida en dos particiones: una para el
sistema operativo en la zona baja o en la zona alta de la memoria. El
principal factor que afecta a esta decisión es la ubicación del vector de
interrupciones. Puesto que el vector de interrupciones se encuentra a
menudo en la parte baja de la memoria, los programadores tienden a
situar también el sistema operativo en dicha zona.
Normalmente, querremos tener varios procesos de usuario residentes
en memoria del mismo tiempo. Por tanto, tenemos que considerar como
asignar la memoria disponible a los procesos que se encuentran en la
cola de entrada, esperando a ser cargados en memoria. En esquema de
asignación contigua de memoria, cada proceso está contenido en una
única sección contigua de memoria.
6.1.2.2. Mapeo de memoria y protección
Antes de seguir analizando la cuestión de la asignación de memoria,
debemos hablar del tema de la conversión de memoria y la protección.
Cuando el planificador de CPU selecciona un proceso para su
ejecución, el despachador carga en los registros de reubicación y de
límite los valores correctos, como parte del proceso de cambio de
contexto. Puesto que todas las direcciones generadas por la CPU se
comparan con estos registros, este mecanismo nos permite tanto al
sistema operativo como los programas y datos de los otros usuarios de
las posibles modificaciones que pudieran realizar este proceso en
ejecución.
6.1.2.3. Asignación de memoria
Unos de los métodos más simples para asignar la memoria consiste en
dividirla en varia particiones de tamaño fijo, cada partición puede
contener exactamente un proceso, de modo que el grado de
multiprogramación estará limitado por el numero de particiones
disponibles, en este método de particiones múltiples, cuando el proceso
termina, la partición pasa a estar disponible para otro proceso
En el esquema de particiones fijas, el sistema operativo mantiene una
tabla que indica que pates de la memoria están disponibles y cuales
50
Sistemas Operativos UNMSM - FISI
están ocupadas. Inicialmente, toda la memoria está disponible para los
proceso de usuario y se considera como un único bloque de gran
tamaño de memoria disponible, al que se denomina agujero, cuando
llega un proceso si lo encontramos, solo se asigna la memoria justa
necesaria, manteniendo el resto de la memoria disponible para
satisfacer futuras solicitudes.
A medida que los proceso entran en el sistema, se introducen en la cola
de entrada, el sistema operativo toma en consideración los requisitos de
memoria en cada proceso y la cantidad de memoria disponible a la hora
de determinar a qué procesos se le asigna la memoria. Cuando
asignamos espacio a un proceso, se carga en la memoria y puede
comenzar a competir por el uso de la CPU. Cuando un proceso termina,
libera su memoria, que el sistema operativo podrá rellenar a
continuación con otro proceso extraído de la cola de entrada.
El sistema puede tener que comprobar si hay procesos esperando a
que se le asigne memoria y si esta nueva memoria liberada y
combinada permite satisfacer las demandas de algunos de los procesos
en espera.
Este procedimiento constituye un caso concreto del problema general
de asignación dinámica de espacio de almacenamiento, que ocupa de
cómo satisfacer una solicitud de tamaño a partir de una lista de agujeros
libres. Hay muchas soluciones a este problema, y las estrategias más
comúnmente utilizadas para seleccionar un agujero libre entre el
conjunto de agujeros disponibles son las de primer juste, mejor ajuste y
peor ajuste.
Primer ajuste: Se asigna el primer agujero que se lo
suficientemente grandes. Podemos detener la exploración en
cuanto encontremos un agujero libre que sea lo suficientemente
grande.
Mejor ajuste: Se asigna el agujero más pequeño que tenga el
tamaño suficiente. Esto hace que se genere el agujero más
pequeño posible con la memoria que sobre del agujero original.
51
Sistemas Operativos UNMSM - FISI
Peor ajuste: Se asigna el agujero de mayor tamaño. Esto genera
el agujero más grande posible con la memoria sobrante del
agujero original.
Las simulaciones muestran que tanto la estrategia del primer ajuste
como la del mejor ajuste son mejores que la de peor ajuste en términos
del tiempo necesario y de la utilización del espacio de almacenamiento.
6.1.3. Fragmentación
Tanto la estrategia del primer ajuste como la de mejor ajuste para la
asignación de memoria sufren del problema denominado fragmentación
externa. A medida que se cargan procesos en memoria y se los elimina,
el espacio de memoria libre se descompone en una serie de fragmentos
de pequeño tamaños. El problema de la fragmentación externa aparecer
cuando hay un espacio de memoria total suficiente como para satisfacer
una solicitud, pero estos espacios disponibles no son contiguos; el
espacio de almacenamiento está fragmentado puede llegar a ser muy
grave. En el peor de los casos, estos pequeños fragmentos de memoria
estuvieran en un único bloque libre de gran tamaño. Podríamos ser
capaces de ejecutar varios procesos más.
Una solución al problema de la fragmentación externa consiste en la
compactación. El objetivo es mover el contenido de la memoria con el
fin de situar toda la memoria libre de manera contigua, para formar un
único bloque de gran tamaño. Otra posible solución al problema
consiste en permitir que el espacio de direcciones lógicas de los
procesos no sea contiguo, lo que hace que podamos asignar memoria
física un proceso con independencia de donde esté situada dicha
memoria. Hay dos técnicas complementarias que se pueden utilizar que
son la paginación y la segmentación.
6.1.4. Paginación
La paginación es un esquema de gestión de memoria que permite que el
espacio de direcciones físicas de un proceso no sea contiguo. La
paginación evita el considerable problema de encajar fragmentos de
memoria de tamaño variable en el almacén de respaldo; la mayoría de los
52
Sistemas Operativos UNMSM - FISI
esquemas de gestión de memoria utilizados antes de la introducción de la
paginación sufrían de este problema, que surgía debido a que, cuando era
necesario proceder a la descarga de algunos datos o fragmentos de código
que residieran en la memoria principal, tenía que encontrarse el espacio
necesario en el almacén de respaldo. El almacén de respaldo también
sufre problemas de fragmentación con relación a la memoria principal, con
la excepción que el acceso es más lento, lo que hace que la compactación
sea imposible. Debido a sus ventajas con los métodos anteriores, la
mayoría de los sistemas operativos utilizan comúnmente mecanismos de
paginación de diversos tipos.
Tradicionalmente, el soporte para la paginación se gestionaba mediante
hardware. Sin embargo, algunos diseños recientes implementan los
mecanismos de paginación integrado estrechamente el hardware y el
sistema operativo, especialmente en los microprocesadores de 64 bytes.
6.1.5. Segmentación
Un aspecto importante de la gestión de memoria que se volvió inevitable
con los mecanismos de paginación es la separación existente entre la vista
que el usuario tiene de la memoria y la memoria física real. La vista que del
usuario tiene de la memoria no es la misma que la memoria física real, sino
que es vista del usuario se mapea sobe la memoria física. Este mapeo
permite la diferenciación entre la memoria lógica y memoria física.
6.2.Memoria Virtual
Los beneficios de la memoria virtual son atractivos ¿Pero el esquema es
verdaderamente práctico? La experiencia de numerosos sistemas operativos
ha demostrado que la memoria virtual realmente funciona. La memoria virtual,
basada en la paginación o paginación más segmentación, se ha convertido, en
actualidad, en una componente esencial de todos los sistemas operativos
contemporáneos.
6.2.1. Hardware y estructura de control:
Comparando la paginación sencilla y la segmentación sencilla, tenemos
una distinción entre particionamiento estático y dinámico, y por otro,
53
Sistemas Operativos UNMSM - FISI
tenemos los fundamentos de comienzo de la gestión de memoria. Las dos
características de la paginación y la segmentación son las siguientes:
a. Todas las referencias a la memoria dentro un proceso se realizan a
direcciones lógicas, que se traducen dinámicamente en direcciones
físicas durante la ejecución. Esto significa que un proceso puede ser
llevado y traído a memoria de forma que ocupe diferentes regiones de
la memoria principal en distintos instantes de tiempo durante la
ejecución.
b. Un proceso puede dividirse en varias porciones (páginas o segmentos)
y estas porciones no tienen que estar localizadas en la memoria de
forma contigua durante la ejecución. La combinación de la traducción de
direcciones dinámicas en ejecución y el uso de una tabla de páginas o
segmentos lo permite.
Consideremos ahora como se puede realizar esto. Usaremos el término
porción para referirnos o bien a una página o un segmento, dependiendo si
estamos empleando paginación o segmentación. Supongamos que se tiene
que traer un nuevo proceso de memoria. El sistema operativo comienza
trayendo únicamente una o dos porciones, que incluye la porción inicial del
programa y la porción inicial de datos sobre la cual acceden las primeras
instrucciones. Esta parte del proceso que se encuentra realmente en la
memoria principal se denomina conjunto residente del proceso. Cuando el
proceso está ejecutándose, las cosas ocurren de forma suave mientras que
todas las referencias a la memoria se encuentren dentro del conjunto
residente. Usando una tabla de segmentos o páginas, el procesador
siempre es capaz de determinar si esto es así o no. Si el procesador
encuentra una dirección lógica que no se encuentra en la memoria
principal, generará una interrupción indicando un fallo de acceso a la
memoria. El sistema operativo coloca al proceso interrumpido en un estado
de bloqueado y toma el control. Para que la ejecución de este proceso
pueda reanudarse más adelante, el sistema operativo necesita traer a la
memoria principal la porción del proceso que contiene la dirección lógica
que ha causado el fallo de acceso. Con este fin, el sistema operativo
realiza una petición de E/S, una lectura a disco. Después de realizar la
54
Sistemas Operativos UNMSM - FISI
petición de E/S, el sistema operativo puede activar otro proceso que se
ejecute mientras el disco realiza la operación de E/S. Una vez que la
porción solicitada se ha traído a la memoria principal, una nueva
interrupción de E/S se lanza, dando control de nuevo al sistema operativo,
que coloca al proceso afectado de nuevo en el estado listo.
Ahora, para entender por qué la memoria virtual es tan importante,
examinaremos de nuevo las tareas del sistema operativo relacionadas con
la memoria virtual. Se va a considerar un proceso de gran tamaño,
consistente en un programa largo más un gran número de vectores de
datos. A lo largo de un corto periodo de tiempo, la ejecución se puede
acotar a una pequeña sección del programa y el acceso a uno o dos
vectores de datos únicamente. Si es así, sería verdaderamente un
desperdicio cargar docenas de porciones de dicho proceso cuando sólo
unas pocas porciones se usarán antes de que el programa se suspenda o
se mande a zona de intercambio o swap. Se puede hacer un mejor uso de
la memoria cargando únicamente unas pocas porciones. Entonces, si el
programa salta a una destrucción o hace referencia a un dato que se
encuentra en una porción de memoria que no está en la memoria principal,
entonces se dispara un fallo. Éste indica al sistema operativo que debe
conseguir la porción deseada.
Así solo unas pocas porciones de cada proceso se encuentran en
memoria, y por tanto se pueden mantener más procesos alojados en la
misma. Además, se ahorra tiempo porque las porciones del proceso no
usadas no se expulsarán de la memoria a swap y de swap a la memoria.
Sin embargo, el sistema operativo debe ser inteligente a la hora de manejar
este esquema. En estado estable, prácticamente toda la memoria principal
se encontrará ocupada con porciones de procesos, de forma que el
procesador y el sistema operativo tengan acceso directo al mayor número
posible de procesos. Así, cuando el sistema operativo traiga una porción a
la memoria, debe expulsar otra. Si elimina una porción justo antes de que
vaya a ser utilizada, deberá recuperar dicha porción de nuevo casi de
forma inmediata.
55
Sistemas Operativos UNMSM - FISI
6.2.2. Paginación
El término memoria virtual se asocia habitualmente con sistemas que
emplean paginación, a pesar de que la memoria virtual basada en
segmentación también se utiliza y será tratada más adelante. El uso de la
paginación para conseguir memoria virtual fue utilizado por primera vez en
el computador Atlas y pronto se convirtió en una estrategia usada en
general de forma comercial.
En la presentación de paginación sencilla, indicamos que cada proceso
dispone de su propia tabla de páginas, y que todas las páginas se
encuentran localizadas en la memoria principal. Cada entrada en la tabla
de páginas consiste en un número de marco de la correspondiente página
en la memoria principal. Para la memoria virtual basada en el esquema de
paginación también se necesita una tabla de páginas. De nuevo,
normalmente se asocia una única tabla de páginas a cada proceso. En
este caso, sin embargo, las entradas de la tabla de páginas son más
complejas. Debido a que solo algunas de las páginas de proceso se
encuentran en la memoria principal, se necesita que cada entrada de la
tabla de páginas indique si la correspondiente página está presente en la
memoria principal o no. Si el bit indica que la página está en la memoria, la
entrada también debe indicar el número de marco de dicha página.
6.2.2.1. Estructura de la tabla de páginas
El mecanismo básico de la lectura de una palabra de la memoria
implica la traducción de la dirección virtual, o lógica, consistente en un
número de página y un desplazamiento, a la dirección física,
consistente en un número de marco y un desplazamiento, usando para
ello la tabla de páginas. Debido a que la tabla de páginas es de longitud
variable dependiendo del tamaño del proceso, no podemos suponer
que se encuentra almacenada en los registros. En lugar de eso, debe
encontrarse en la memoria principal para poder ser accedida. El número
de página de la dirección virtual se utiliza para indexar esa tabla y
buscar el correspondiente marco de página. Este, combinado con la
parte de desplazamiento de la dirección virtual genera la dirección real
deseada. Normalmente, el campo correspondiente al número de página
56
Sistemas Operativos UNMSM - FISI
es mayor que el campo correspondiente al número de marco de página
(n>m).
En la mayoría de sistemas, existe una única tabla de página por
proceso. Pero cada proceso puede ocupar una gran cantidad de
memoria virtual. Por ejemplo, en la arquitectura VAX, cada proceso
puede tener hasta 2^31 = 2 Gbytes de memoria virtual. Usando páginas
de 2^9 = 512 bytes, que representan un total de 2^22 entradas de cada
página por cada proceso. Evidentemente, la cantidad de memoria
demandada por las tablas de página únicamente puede ser
inaceptablemente grande. Para resolver este problema, la mayoría de
esquemas de memoria virtual almacena las tablas de páginas en la
memoria virtual, en lugar de en la memoria real. Esto representa que las
tablas de páginas están sujetas a paginación igual que cualquier otra
página.
6.2.2.2. Tabla de páginas invertidas
Una desventaja del tipo de tablas de páginas que hemos visto es que
su tamaño es proporcional al espacio de direcciones virtuales.
Una estrategia alternativa al uso de tablas de páginas de uno o varios
niveles es el uso de la estructura de tabla de páginas invertidas.
Variaciones de esta estrategia se han usado en arquitecturas como
PowerPC, UltraSPARC, e IA-64. La implementación del sistema
operativo Mach sobre RT-PC también la usa.
57
Figura 5 Esquema de Memoria virtual
Sistemas Operativos UNMSM - FISI
En esta estrategia, la parte correspondiente al número de página de la
dirección virtual se referencia por medio de un valor hash usando una
función hash sencilla. El valor hash es un punteo par la tabla de páginas
invertida, que contiene las entradas de tablas de página. Hay una
entrada en la tabla de páginas invertidas por cada marco de página
siempre es una proporción fija de memoria real, independientemente
del número de procesos o de las páginas virtuales soportadas. Debido a
que más de una dirección virtual puede traducirse en la misma entrada
de la tabla hash, una técnica de encadenamiento se utiliza para
gestionar el desbordamiento. Las técnicas de hashing proporcionan
habitualmente cadenas que no son excesivamente largas entre una y
dos entradas. La estructura de la tabla de páginas se denomina
invertida debido a que se indexan sus entradas de la tabla de páginas
por el número de marco en lugar de por el número de página virtual.
6.2.2.3. Buffer de traducción identificada
En principio, toda referencia a la memoria virtual puede causar dos
accesos a memoria física: uno para buscar la entrada a la tabla de
páginas apropiada y otro para buscar los datos solicitados. De esa
forma, un esquema de memoria virtual básico causaría el efecto de
duplicar el tiempo de acceso a la memoria. Para solventar este
problema, la mayoría de esquemas de la memoria virtual utilizan una
cache especial de alta velocidad para las entradas de la tabla de
página, habitualmente denominada buffers de traducción anticipada.
Esta cache funciona de forma similar a una memoria cache general y
contiene aquellas entradas de la tabla de páginas que han sido usadas
de forma más reciente.
6.2.2.4. Tamaño de página
Una decisión de diseño de hardware importante es el tamaño de página
a usar. Hay varios factores a considerar. Por un lado, está la
fragmentación interna. Evidentemente, cuanto mayor es el tamaño de la
página, menor cantidad de fragmentación interna. Por otro lado, cuanto
menor es la página, mayor número de páginas son necesarias para
cada proceso. Un mayor número de páginas por proceso significa
58
Sistemas Operativos UNMSM - FISI
también mayores tablas de páginas. Para programas grandes en un
entorno altamente multiprogramado, esto significa que determinadas
partes de las tablas de página de los procesos activos deben
encontrarse en la memoria virtual, no en la memoria principal. Por tanto,
puede haber un fallo de página doble para una referencia sencilla a
memoria: el primero para atraer la tabla de página de la parte solicitada
y el segundo para atraer la página del propio proceso. Otro factor
importante son las características físicas de la mayoría de los
dispositivos de la memoria secundaria, que son de tipo giratorio,
favoreciendo tamaños de página grandes para mejorar la eficiencia de
transferencia de bloques de datos.
6.2.3. Segmentación
La segmentación permite al programador ver la memoria como si se tratase
de diferentes espacios de direcciones o segmentos. Los segmentos
pueden ser de tamaños diferentes, en realidad de tamaño dinámico.
Esta organización tiene un gran número de ventajas para el programador
sobre los espacios de direcciones no segmentados:
a. Simplifica el tratamiento de estructuras de datos que pueden
crecer. Si el programador no conoce a priori el tamaño que una
estructura de datos en particular puede alcanzar es necesario hacer una
estimación salvo que se utilicen tamaños de segmentos dinámicos. Con
la memoria virtual segmentada, a una estructura de datos se le puede
asignar su propio segmento, y el sistema operativo expandirá o reducirá
el segmento bajo demanda.
b. Permite programas que se modifican o recopilan de forma
independiente, sin requerir que el conjunto completo de programas se
re-enlacen y se vuelvan a cargar. De nuevo, esta posibilidad se puede
articular por medio de la utilización de múltiples segmentos.
c. Da soporte a la compartición entre procesos. El programador puede
situar un programa de utilidad o una tabla de datos que resulte útil en un
segmento al que puede hacerse referencias desde otros procesos.
59
Sistemas Operativos UNMSM - FISI
d. Soporta los mecanismos de protección. Esto es debido a que un
segmento puede definirse para contener un conjunto de programas o
datos bien descritos, el programador o el administrador de sistemas
puede asignar privilegios de acceso de una forma apropiada.
6.2.4. Pa
gin
aci
ón
y
segmentación combinadas
La paginación es transparente al programador y elimina la fragmentación
externa, y por tanto proporciona un uso eficiente de la memoria principal.
Adicionalmente, debido a que los fragmentos que se mueven entre la
memoria y el disco son de un tamaño igual y prefijado, es posible
desarrollar algoritmos de gestión de la memoria más sofisticados que
exploten el comportamiento de los programas, como veremos más
adelante. La segmentación sí es visible al programador y tiene los
beneficios que hemos visto anteriormente. La segmentación sí es visible al
programador y tiene los beneficios que hemos visto anteriormente,
incluyendo la posibilidad de manejar estructuras de datos que crecen,
modularidad, y dar soporte a la compartición y a la protección. Para
combinar las ventajas de ambos, algunos sistemas por medio del hardware
del procesador y del soporte del sistema operativo son capaces de
proporcionar ambos.
60
Figura 6 Esquema de Segmentación
Sistemas Operativos UNMSM - FISI
7. Gestión de archivos
Es el aspecto más visible de un sistema operativo proporciona los mecanismos
para el almacenamiento en línea en datos y programas del propio sistema
operativo y para todos los usuarios del sistema informático, así como el acceso a
esos datos y programas
7.1.¿Qué es un archivo?
Las computadoras pueden almacenar información en varios soportes de
almacenamiento como: discos magnéticos, cintas magnéticas y discos ópticos.
Los archivos son una colección de información relacionada, con un
nombre, que se graba en el almacenamiento secundario
Comúnmente los archivos representan programas y datos, los archivos
de datos pueden ser numéricos, alfabéticos, alfanuméricos o binarios
Un archivo es una secuencia de bits, bytes, líneas o registros
7.2.Atributos de un archivo
Los atributos varían según sistema operativo, generalmente son:
Nombre: Es aquel que el usuario le asigna
Tipo: Es necesario para los sistemas que soporten diferentes tipos de
archivos
Ubicación: Nos hace referencia a la dirección que podemos encontrar
Tamaño: atributo que puede ser medido en (bytes, palabras o bloques)
Protección: información de control de acceso que determina quién
puede leer el archivo, escribir, ejecutarlo, etc.
61
Sistemas Operativos UNMSM - FISI
7.3.Operación con los archivos
Crear un archivo: Consta de dos pasos, el primero es encontrar el
espacio para el archivo dentro del sistema de archivos y el segundo es
incluir en el directorio una entrada para el nuevo archivo
Escritura de un archivo: El sistema debe mantener el puntero de
escritura que haga referencia a la ubicación dentro del archivo en la que
debe tener lugar la siguiente escritura
Lectura de un archivo: Para leer desde un archivo, utilizamos una
llamada al sistema que especifique tanto al nombre del archivo como la
información que hay que escribir y donde debe colocarse el siguiente
bloque del archivo
Reposicionamiento dentro de un archivo: Se explora el directorio
para hallar la correspondiente entrada y se reposiciona el punto de
posición actual dentro de un archivo, asignándole un nuevo valor. Se le
conoce a esta operación con el nombre de búsqueda en el archivo
Borrado de un archivo: Para borrar un archivo, exploramos el
directorio en busca del archivo indicado. Habiendo hallado la entrada de
directorio asociada, liberamos todo el espacio del archivo, de modo que
pueda ser reutilizado por otros archivos, y borramos también la propia
entrada del directorio.
Truncado de un archivo: El usuario puede querer borrar el contenido
de un archivo, pero manteniendo sus atributos. En lugar de forzar al
usuario a borrar el archivo y volverlo a crear, esta función permite que
los atributos no se vean modificados (excepto la longitud del archivo),
mientras que el archivo se reinicializa asignándole una longitud de igual
a cero y liberando el espacio que tuviera asignado.
7.4.Tipos de archivos
Una técnica común para implementar los archivos consiste en incluir el tipo
como parte del nombre del archivo
El nombre se divide en dos partes: un nombre y una extensión, usualmente
separadas por un carácter punto, de esta manera el usuario y el sistema
62
Sistemas Operativos UNMSM - FISI
operativo pueden determinar, con solo analizar el nombre, cual es el tipo de
archivo.
Tipo de archivo Extensión usual Función
Ejecutable
Exe, com, bin Programas en lenguaje
maquina listos para
ejecutarse
ObjetoObj, o Lenguaje maquina
compilado y no montado
Código fuenteC, cc, java, pas, asm Códigos fuentes en
diversos lenguajes
Procesamiento por
lotes
Bat, sh Comandos para
interprete de comandos
TextoTxt, doc Datos textuales,
documentos
Procesador de textos
Wp, tex, rtf, doc Diversos formatos de
procesamientos de
textos
bibliotecaLib, a ,so, dll Biblioteca de rutina para
los programadores
Impresión o
visualización
Ps, pdf, jpg Archivo ASCII o binario
en un formato adecuado
para su impresión o
visualización
Archivado
Arc, zip, tar Archivos relacionados
agrupados en un único
archivo, algunas veces
comprimido, para su
archivado definitivo o
almacenamiento
Multimedia
Mpeg, mov, rm, mp3, avi Archive binario que
contiene información de
audio
63
Sistemas Operativos UNMSM - FISI
7.5.Estructura de archivos
Los tipos de archivo también pueden usarse para indicar la estructura interna
del archivo.
Los archivos fuente y objeto tiene estructura que se corresponden con las
expectativas de los programas que se van a encargar de leerlos. Además
ciertos archivos deben adaptarse a una estructura requerida, comprensible por
parte del sistema operativo
Ejemplo: El sistema operativo requiere de archivos ejecutables tengan una
estructura concreta para poder determinar en qué parte de la memoria cargar
el archivo y donde está ubicada la primera instrucción. Algunos sistemas
operativos amplían esa idea y utilizan un conjunto de estructura de archivos
soportadas por el sistema, con una serie de operaciones especiales para
manipular los archivos que tengan dicha estructuras. Por ejemplo el sistema
operativo VMS de DEC tiene un sistema de archivos que soporta tres
estructura de archivos definidos.
7.6.Introducción de directorios
El directorio puede considerarse como una tabla de símbolos que traduce los
nombres de archivos a sus correspondientes entradas de directorios.
Queremos poder insertar entradas, borrar entradas, buscar entrada
conociendo su nombre y enumerar todas las entradas del directorio.
7.6.1. Operaciones para directorios
Búsqueda de archivos: Tenemos que poder explorar la estructura del
directorio para encontrar la entrada correspondiente a un archivo
concreto. Puesto que los archivos tienen nombres simbólicos y los
nombres similares pueden indicar que existe una relación entre los
archivos, también queremos poder encontrar todos los archivos cuyos
nombres se corresponden con un patrón concreto
Crear un archivo: Es necesario poder crear archivos y añadirlos al
directorio
Borrar un archivo: Cuando un archivo ya no es necesario, queremos
poder eliminarlo del directorio
64
Sistemas Operativos UNMSM - FISI
Listar un directorio: Tenemos que poder enumerar los archivos
contenidos en un directorio y el contenido de la entrada de directorio
correspondiente a cada uno de los archivos de la lista
Renombrar un archivo: Puesto que el nombre de un archivo
representa el contenido para los usuarios, debemos poder cambiar el
nombre cuando el contenido o el uso del archivo varíen. Renombrar un
archivo puede también significar que se modifique su posición dentro de
la estructura de directorio.
Recorrer el sistema de archivos: Puede que queramos acceder a
todos los directorios y a todos los archivos contenidos dentro de una
estructura de directorios. Para conseguir una mayor fiabilidad, resulta
conveniente guardar el contenido y la estructura de todo el sistema de
archivos a intervalos regulares. A menudo, esto se suele hacer
copiando todos los archivos en una cinta magnética. Esta técnica
proporciona una copia de seguridad para el caso que se produzca fallo
del sistema
Compartición de archivos: La compartición de archivos es muy
deseable para aquellos usuarios que quieran colaborar y reducir el
esfuerzo requerido para conseguir desarrollar un programa. Por tanto,
los sistemas operativos orientados al usuario deben satisfacer la
necesidad de compartir archivos a pesar de las dificultades inherentes a
este mecanismo
Protección: Cuando se almacena la información en un sistema
informático, necesitamos protegerla frente a los daños físicos (fiabilidad)
y frente a los accesos incorrectos (protección). La fiabilidad se
proporciona, generalmente, mediante copias duplicadas de los archivos.
La mayoría de las computadoras tienen programas del sistema que
copian automáticamente(o mediante intervención del operador) los
archivos del disco en una cinta a intervalos regulares (una vez al día, o
a la semana o al mes), para mantener una copia por si acaso resultara
destruido accidentalmente el sistema de archivos
65
Sistemas Operativos UNMSM - FISI
7.7.Técnica de protección más usual
7.7.1. Tipos de acceso
La necesidad de proteger los archivos es consecuencia directa de la
posibilidad de acceder a esos archivos. Los sistemas que no permiten el
acceso a los sistemas de otros usuarios no necesitan ninguna protección.
Así, podríamos proporcionar una protección completa simplemente
prohibiendo el acceso. Alternativamente, podríamos proporcionaron acceso
libre sin ninguna protección.
Ambas técnicas son demasiado extremas para poder utilizarlas de forma
general; lo que necesitamos, en su lugar, es un acceso controlado
Los mecanismos de protección proporcionan un acceso controlado
limitando los tipos de accesos a archivo que puedan realizarse. El acceso
se permite o se deniega dependiendo de varios factores, uno de los cuales
es el tipo de acceso solicitado. Podemos controlar varios tipos de
operaciones diferentes
Lectura: Lectura de un archivo
Escritura: Escritura o reescritura de un archivo
Ejecución: Carga del archivo en memoria y ejecución del mismo
Audición: Carga del archivo en memoria y ejecución del mismo
Adición: Estructura de nueva información al final del archivo
Borrado: Borrado del archivo y liberación del espacio para su
posible reutilización
Listado: Listado del nombre y atributos del archivo
7.7.2. Recuperación
Los archivos y directorios se mantienen al tanto en la memoria principal
como en disco, y debe tenerse cuidado para que los fallos del sistema no
provoquen una pérdida de datos o una incoherencia en los mismos
7.7.3. Comprobación de coherencia
Parte de la información de directorios se almacena en la memoria principal
(o en cache) para acelerar el acceso. La información de directorios en la
memoria principal esta, generalmente, más actualizada que la
66
Sistemas Operativos UNMSM - FISI
correspondiente información en el disco, porque la información de
directorios almacenada en cache no se escribe necesariamente en el disco
nada más producirse la actualización
Considere, entonces, el posible ejemplo de un fallo de la computadora. El
contenido de la cache y de los búferes, así como de las operaciones de
E/S que se estuvieran realizando en ese momento, pueden perderse, y con
el perderán los cambios realizados en los directorios correspondientes los
archivos abiertos. Dicho suceso puede dejar al sistema en un estado
incoherente. El estado real de los archivos no serán los que describe en la
estructura de directorios. Con frecuencia suelen ejecutarse un programa
especial durante el reinicio para comprobar las posibles incoherencias del
disco y corregirlas
El comprobador de incoherencia (un programa del sistema tal como fsck en
UNIX o chkdsken MS-DOS), compara los datos de la estructura de
directorios con los bloques de datos de disco y trata de corregir todas la
incoherencias que detecte los algoritmos de asignación y de gestión del
espacio libre dictan los tipos de problemas que el comprobador puede
tener en esta tarea
7.7.4. Copia de seguridad y restauración
Los discos magnéticos fallan en ocasiones y es necesario tener cuidado
para garantizar que los datos perdido debido a esos fallos no se pierdan
para siempre. Con este fin, pueden utilizarse programas del sistema para
realizar una copia de seguridad de los datos del disco en otro dispositivo de
almacenamiento, como por ejemplo un disquete, una cinta magnética, un
disco óptico incluso otro disco duro. La recuperación de la pérdida de un
archivo individual o de un disco completo puede ser entonces,
simplemente, una cuestión de restaurar los datos a partir de la copia de
seguridad para minimizar la cantidad de datos que haya que copiar,
podemos utilizar la información contenida en la entrada de directorios de a
cada archivo. Por ejemplo, si el programa de copia de seguridad sabe
cuando se realizo la última copia de seguridad de un archivo y la fecha de
la última modificación del archivo contenida en el directorio indica que el
67
Sistemas Operativos UNMSM - FISI
archivo ha cambiado desde esa fecha, no será necesario para poder copiar
el archivo. Así, un plan típico de copia de seguridad podría ser el siguiente
a. Día 1: Copiar el soporte de copia de seguridad todos los archivos del
disco .Esto se denomina Copia de seguridad completa
b. Dia2: Copiar en otro soporte físico todos los archivos que se hayan
modificado desde el día 1. Esta es una copia de seguridad incremental
c. Día 3: Copiar en otro soporte físico todos los archivos que se hayan
modificado desde el día 2
d. Día N: Copiar en otro soporte físico todos los archivos que se hayan
modificado desde el día N-1. Después, volver al día 1
Podemos escribir las copias de seguridad correspondientes al nuevo ciclo
sobre el conjunto anterior de soportes físicos o en un nuevo conjunto de
soportes de copia de seguridad. De esta forma, Podemos restaurar un
disco completo comenzando la restauración de la copia de seguridad
completa y continuando con cada una de las copias de seguridad
incrementales. Por su puesto; cuanto mayor sea el valor de N, mas cintas o
discos habrá que leer para efectuar una restauración completa. Una
ventaja adicional a este ciclo de copia de seguridad es que podemos el
archivo borrado de la copia de seguridad del día anterior. La longitud del
ciclo será un compromiso entre la cantidad de soportes físicos de copia de
seguridad requeridos y el número de días pasados a partir de los cuales
podemos realizar una restauración. Para reducir el número de cintas que
haya que leer para efectuar una restauración, una opción consiste en
realizar una copia de seguridad completa y luego copiar cada día todos los
archivos que hayan cambiado desde la última copia de seguridad
completa. De esta forma, puede realizarse la restauración utilizando solo
copias de seguridad incrementadas reciente y la copia de seguridad
completa, no necesitándose ninguna otra copia de seguridad incremental
68
Sistemas Operativos UNMSM - FISI
7.8.Gestión del disco
El sistema operativo es responsable también de varios otros aspectos de la
gestión de disco. Aquí trataremos sobre la inicialización del disco, del arranque
del disco y recuperación de bloques defectuosos
7.8.1. Formateo del disco
Un disco magnético nuevo es una pizarra en blanco: se trata simplemente
de una placa de material magnético para grabación. Antes de poder
almacenar datos en el disco, es necesario dividir este en sectores que la
controladora de disco pueda leer y escribir. Este proceso se denomina
formateo de bajo nivel o formateo físico.
El formateo de bajo nivel llena el disco con una estructura de datos
especial para cada sector. La estructura de datos para un sector consta
típicamente de una cabecera, un área de datos (que inicialmente tiene 512
bytes de tamaño) y una cola.
La cabecera y la cola contienen información utilizada por la controladora de
disco, como el número de sector y un código de corrección de errores.
Cuando la controladora escribe un sector de datos durante la E/S normal,
el código de corrección de errores se actualizara con un valor que se
calculaba a partir de todos los bytes contenidos en el área de datos.
Cuando se lee el sector, se recalcula el código de corrección de errores y
se lo comprar con el valor almacenado. Si los valores almacenados y
calculado son diferentes, esa diferencia indica que el área de datos del
sector se ha corrompido y que el sector de disco puede ser defectuoso.
El código de corrección de errores contiene suficiente información como
para que, en caso de que solo unos bits de datos se haya corrompido, la
controladora puede identificar que bits han sido modificados y calcular
cuales deberían ser sus valores correctos. En este caso, la controladora
informara de que se ha producido un error blando recuperable. La
controladora realizara automáticamente el procesamiento del código de
corrección de errores cada vez que se lee o se escribe un sector
69
Sistemas Operativos UNMSM - FISI
La mayoría de discos duros se formatean a bajo nivel en la fábrica como
parte del proceso de fabricación. Este formateo permite al fabricante probar
el disco e inicializar el mapeo entre los numero de bloque lógicos y
sectores libres de defectos en el disco. En muchos discos duros, cuando se
ordena la controladora de discos realizar un formateo de bajo nivel del
disco, también se la puede decir cuántos bytes de datos debe dejar entre la
cabecera y la cola de cada sector.
Normalmente, es posible elegir entre unos cuantos tamaños, como ejemplo
256, 512 y 1024 bytes. Formatear un disco con un tamaño de sector más
grande implica que en cada pista cabrán menos sectores, pero también se
escribirán menos cabeceras y colas en cada pista y que habrá más espacio
disponible para los datos del usuario. De todos modos, algunos sistemas
operativos solo pueden admitir un tamaño de sector igual a 512 bytes.
Para utilizar un disco para almacenar a5rchivos, el sistema operativo sigue
necesitando poder grabar sus propias estructuras de datos en el disco y
para ello sigue un proceso en dos pasos. El primer paso consiste en
particionar el disco en uno o más grupos de cilindros. El sistema operativo
puede tratar cada partición como si fuera un disco distinto.
Ejemplo: Una partición puede albergar una copia de código ejecutable del
sistema operativo, mientras que la otra pueden almacenar los archivos del
usuario.
Después del particionamiento, el segundo paso es el formateo lógico
(creación de un sistema de archivos). En este paso, el sistema operativo
almacena estructura de datos iniciales del sistema de archivos en el disco.
Estas estructuras de datos pueden incluir mapas despacio libre y asignado
(una tabla FAT o una serie de inodos) y un directorio inicial vacio
7.8.2. Bloque de arranque
Para que una computadora comience a operar (por ejemplo cuando se
enciende o cuando se la reinicia) debe tener una programa inicial que
ejecutar. Este programa inicial de arranque tiende a ser muy simple. Se
encarga de iniciar todos los aspectos del sistema, desde los registro del
70
Sistemas Operativos UNMSM - FISI
CPU hasta las controladoras de dispositivos y el contenido de la memoria
principal, y luego arranca el sistema operativo. Para llevar a cabo su tarea,
el programa de arranque localiza el kernel del sistema operativo en el
disco, carga dicho kernel en memoria y salta hasta una dirección inicial con
el fin de comenzar la ejecución del sistema operativo.
Para la mayoría de las computadoras, el arranque está almacenado en la
memoria solo de lectura (ROM). Esta ubicación resulta muy adecuada,
porque la ROM no necesita ser inicializada y se encuentra en una dirección
fija en la que el procesador puede comenzar la ejecución al encender o
reiniciar. Además, puesto que la ROM es solo de lectura, no puede verse
afectada por virus informáticos. El problema es que cambiar este código de
arranque requiere cambiar los chips hardware de la ROM. Por esta razón,
la mayoría de los sistemas almacenan un programa cargador de arranque
muy pequeño tamaño en la ROM de arranque, cuya única tarea consiste en
cargar un programa de arranque completo desde el disco.
El programa de arranque completo puede cambiarse fácilmente. Cada
nueva versión puede simplemente escribirse en el disco. El programa
cargador completo se almacena en los “bloques de arranque”, en una
ubicación fija del disco. Un disco que tengo una partición de arranque se
denomina disco de arranque o disco del sistema
El código de la ROM de arranque ordena a la controladora del disco que
lea los bloques de arranque en memoria (todavía no hay ningún controlador
de dispositivo cargado en ese punto) y luego comienza a ejecutar dicho
código. El programa de arranque completo es capaz de cargar todo el
sistema operativo desde una ubicación no fija dentro del disco y luego
iniciar la ejecución del sistema operativo. A pesar de ello, el código del
programa de arranque completo puede ser pequeño
7.8.3. Bloqueos defectuosos
Puesto que los discos tiene partes móviles y tolerancias muy pequeñas
(recuerde que el cabezal del disco vuela justo por encima de la superficie
del disco) son bastante propenso a los fallos
71
Sistemas Operativos UNMSM - FISI
Algunas veces, el fallo se produce por completo, en cuyo caso será
necesario cambiar de disco y restaurar su contenido en el nuevo disco a
partir a partir de un soporte de copia de seguridad. Los más frecuentes que
uno de los sectores pasen a ser defectuosos se gestionan de forma
manual. Por ejemplo, el comando format de MS- DOS realiza el formateo
lógico y, como parte de dicho proceso, analiza el disco para localizar los
bloques defectuoso. Si format encuentra un bloque defectuoso, escribe un
valor especial en la entrada correspondiente de la FAT para informar las
rutinas de asignación de que no debe utilizar dicho bloque. Si los bloques
pasan a ser defectuosos durante la operación normal, es necesario
ejecutar manualmente un programa especial (como por ejemplo chkdsk)
para buscar los bloques defectuosos y prohibir su utilización, de la misma
forma que antes. Los datos que estuvieran almacenados en los que
estuvieran almacenados en los bloques defectuosos usualmente se
pierden.
El disco más sofisticado, como los discos SCSI utilizados en las
computadoras PC de gama alta y en la mayoría de las estaciones de
trabajo y servidores, tiene unos mecanismos más inteligentes de
recuperación de bloques defectuosos. La controladora mantiene una lista
de bloques defectuosos en el disco. La lista se inicializa durante el
formateo de bajo nivel en la fábrica y se actualiza a todo lo largo de la vida
del disco. El formateo a bajo nivel también reserva una serie de sectores
adicionales que no son visibles para el sistema operativo. Se puede
ordenara la controladora que sustituya lógicamente cada vector defectuoso
por uno de los sectores adicionales reservados. Este esquema se
denomina reserva de sectores o sustitución de sectores
Una transacción típica relativa a un sector defectuoso seria lo siguiente:
a. El sistema operativo trata de leer el bloque lógico 87
b. La controladora calcula el Código de corrección de errores y comprueba
que el sector es defectuoso, por lo que informa a la controladora SCSI
de que el sector es defectuoso por unos de los sectores reservados
72
Sistemas Operativos UNMSM - FISI
c. La siguiente vez que se reinicie el sistema, se ejecuta un comando
especial para informar a la controladora SCSI de que debe sustituir el
sector defectuoso por uno de los sectores reservados.
d. A partir de ahí, siempre que el sistema solicite el bloque lógico 87, la
solicitud será traducida por la controladora, que sustituirá dicha
dirección por la del sector sustituto.
A este tipo de redirección efectuado por la controladora podría invalidar las
optimizaciones realizadas por el algoritmo de planificación del disco del
sistema operativo. Por esta razón, la mayoría de discos se formatean de
modo que se proporcionen unos cuantos sectores reservados en cada
cilindro y también en un cilindro reservado. Cuando se remapea un bloque
defectuoso, la controladora utiliza un sector reservado del mismo cilindro,
siempre que sea posible.
Como alternativa al mecanismo de reserva de sectores, alguna
controladora ofrece la posibilidad de sustituir un bloque defectuoso por el
procedimiento de deslizamiento de sectores.
Ejemplo: Suponga que el bloque lógico 17 pasara a estar defectuoso y que
el primer sector reservado disponible es tuviera situado después del sector
201. Entonces, el procedimiento de deslizamiento de sectores se remapea
todos los sectores comprendidos entre el 17 y el 201, moviéndolos una
posición. En otras palabras, el sector 202 se copia en sector reservado,
luego el sector 201 se copia en el sector 202, el sector 200, en el 201, etc.
La sustitución de un bloque defectuoso no es, generalmente, del todo
automático por que los datos del bloque defectuoso suele perderse.
Diversos errores blandos podrían hacer que se desencadenara un proceso
en que se realiza una copia de los datos del bloque y dicho bloque se
marcara como no valido, empleándose a continuación los procedimientos
de sustitución o deslizamiento de bloques. Sin embargo, los errores duros
no recuperables provocan la perdida de datos. En ese caso, será necesario
reparar el archivo que estuviera utilizando dicho bloque (por ejemplo,
realizando una restauración a partir de una cinta de seguridad) y ese
proceso requiere una intervención manual.
73
Sistemas Operativos UNMSM - FISI
8. Sistemas distribuidos
Un sistema distribuido es un sistema de información en el cual las funciones se
reparten por áreas de trabajo diferentes que trabajan de forma coordinada para
asumir los objetivos que la organización asigna a ese sistema de información.
Pero no olvidemos que detrás del sistema operativo hay personas que lo usan y
los gestionan. El factor humano será fundamental como nos cuidaremos de
recordar a lo largo del todo el diseño. Los sistemas distribuidos se encuentran
conformados por siete puntos:
Los objetivos de la empresa. Debemos saber que estos son la
justificación de que exista la informática.
La plataforma del proceso. Elemento encargado de proporcionar los
recursos físicos y el software de base para ejecutarlo. Está formado por los
mainframe, PC’S, PDA’S.
Los elementos de la conectividad. Son los encargados se proporcionar
el transporte para comunicar e integrar los elementos de la plataforma de
proceso. Son básicamente las redes y las comunicaciones.
El almacenamiento de datos, formado por los datos en sí y los gestores
donde se localizan.
Los elementos de software donde se incluyen las aplicaciones, los
servicios que ayudan a crearlas y las interfaces que ayudan a usarlas. En
este componente se integran las arquitecturas posibles para crearlas:
74
Sistemas Operativos UNMSM - FISI
centralizada, batch, transaccional, cliente / servidor basado en sistema
operativo, cliente / servidor basada en internet y aplicaciones web internet.
Sistema de seguridad. Conformado por los programas y/o software que
ayudan a proteger al sistema de posibles amenazas.
Gestión del sistema como un conjunto integrado y coordinado a
través de los recursos de dirección y administración. La gestión del
sistema debe permitir la coexistencia de varios centros de gestión
diferentes.
8.1.Características de los sistemas distribuidos
Concurrencia: cuando existen varios procesos en una única maquina
decimos que se están ejecutando concurrentemente. Si el ordenador está
equipado con un único procesador central, la concurrencia tiene lugar
entrelazando la ejecución de los distintos procesos. Si la computadora
tiene n procesadores, entonces se pueden estar ejecutando estrictamente
a la vez hasta n procesos.
En los sistemas distribuidos hay muchas maquinas: Cada una con uno
o más procesadores centrales. Es decir, si hay m ordenadores en un
sistema distribuido con un procesador central cada una entonces hasta m
procesos estar ejecutándose en paralelo.
Escalabilidad: Los sistemas distribuidos operan de manera efectiva y
eficiente a muchas escalas diferentes. Tanto el software de sistema como
el de aplicación no deberían cambiar cuando la escala del sistema se
incrementa. La necesidad de escalabilidad no es solo un problema de
prestaciones de red o de hardware, sino que está íntimamente ligada con
todos los aspectos del diseño de los sistemas distribuidos. El diseño del
sistema debe reconocer explícitamente la necesidad de escalabilidad o de
lo contrario aparecerán serias limitaciones.
Tolerancia a fallos: Los sistemas informáticos a veces fallan. Cuando se
producen fallos en el software o en el hardware, los programas podrían
producir resultados incorrectos o podrían pararse antes de terminar la
computación que estaban realizando. El diseño de sistemas tolerantes a
fallos se basa en dos cuestiones, complementarias entre sí: redundancia
75
Sistemas Operativos UNMSM - FISI
hardware (uso de componentes redundantes) y recuperación del software
(diseño de programas que sean capaces de recuperarse de los fallos).
En los sistemas distribuidos la redundancia puede establecerse en un
plano más frágil que en el hardware: Pueden replicarse los servidores
individuales que son esenciales para la operación continuada de
aplicaciones críticas.
Trasparencia: Se define como la ocultación al usuario y al programador de
aplicaciones de la separación de los componentes de un sistema
distribuido, de manera que el sistema se percibe como un todo, en vez de
una colección de componentes independientes. La transparencia ejerce
una gran influencia en el diseño del software de sistema.
8.2.Sistemas operativos distribuidos
Mencionada la definición de que vienen a ser los sistemas distribuidos,
pasamos a ver como estos ayudan a los sistemas operativos en las diferentes
funciones que realizan dentro del ordenador.
Un sistema operativo distribuido es un conjunto de computadoras
independientes que se presenta a los usuarios como sistema único. El objetivo
de los sistemas operativos distribuidos es integrar en un único sistema los
recursos y servicios distribuidos en distintos equipos, además debe gestionar
recursos de forma global: procesadores, memorias, sistema de ficheros,
dispositivos de e/s, etc.
Esta definición tiene dos aspectos el primero se refiere al hardware las
máquinas son autónomas el segundo se refiere al software los usuarios
piensan que el sistema es como una única computadora ambos son
esenciales regresaremos a este punto en una sección posterior de este
capítulo después de revisar algunos conceptos básicos del hardware y el
software.
Esta definición puede ser un poco complicada al entenderla, por ello
mencionaremos un ejemplo. Considere una fábrica de robots cada uno de los
cuales contiene una poderosa computadora para el manejo de visión
planeación comunicación y otras tareas. Cuando un robot de esa línea de
ensamble nota que una parte por instalar es defectuosa le pide al robot del
76
Sistemas Operativos UNMSM - FISI
departamento de partes que le traiga una refacción. Si todos los robots actúan
como dispositivos periféricos unidos a la misma computadora central y el
sistema se puede programar de esta manera también se considera como un
sistema distribuido.
8.3.Ventajas de los sistemas distribuidos con respecto de las PC
independientes
Puesto que los microprocesadores constituyen una forma económica de
trabajo ¿por qué no se ofrece a cada persona su propia pc y se le deja trabajar
de manera independiente? El asunto aquí es que muchos usuarios necesitan
compartir ciertos datos. Por ejemplo los empleados de reservaciones en las
líneas aéreas necesitan tener acceso a la base de datos maestra de los vuelos
y reservaciones existentes. Si se le diera a cada empleado una copia particular
de toda la base de datos eso no funcionaría puesto que nadie conocería los
asientos vendidos por los demás empleados. Los datos compartidos son
absolutamente esenciales para ésta y otras aplicaciones de modo que las
máquinas deben estar conectadas entre sí la conexión de las máquinas
conduce a un sistema distribuido. Los datos no son los únicos elementos que
se pueden compartir. Otros candidatos son también los periféricos catos como
las impresoras láser de color equipos de fotocomposición y los dispositivos de
almacenamiento masivo (por ejemplo las cajas ópticas). Una tercera razón
pala la conexión de un grupo de computadoras aisladas en un sistema
distribuido es lograr una mejor comunicación entre las personas.
8.4.Desventajas de los sistemas distribuidos
Aunque los sistemas distribuidos tienen sus aspectos fuertes también tienen
sus debilidades. En esta sección señalaremos algunas de ellas. Ya hemos
señalado el peor de los problemas el software. Con el actual estado de las
cosas no tenemos mucha experiencia en el diseño implantación y uso del
software distribuido ¿qué tipo de sistemas operativos lenguajes de
programación y aplicaciones son adecuados para estos sistemas? ¿Cuánto
deben saber los usuarios de la distribución? ¿Qué tanto debe hacer el sistema
y qué tanto deben hacer los usuarios? Los expertos tienen sus diferencias.
77
Sistemas Operativos UNMSM - FISI
Mientras se realice más investigaciones a este problema, disminuirá pero por
el momento no puede subestimarse.
Un segundo problema potencial es el debido a las redes de comunicación.
Estas pueden perder mensajes lo cual requiere un software especial para su
manejo y puede verse sobrecargado. Al saturarse la red ésta debe
remplazarse o añadir una segunda. En ambos casos hay que tender cables en
una parte de uno o más edificios con gran costo o bien hay que remplazar las
tarjetas de interfaz de la red (por ejemplo por fibras ópticas). Una vez que el
sistema llega a depender de la red la pérdida o saturación de ésta puede
negar algunas de las ventajas que el sistema distribuido debía conseguir. Por
último el hecho ya descrito de que los datos sean fácil de compartir es una
ventaja pero se puede convertir en un arma de dos filos si las personas
pueden tener acceso a los datos en todo el sistema entonces también pueden
tener acceso a datos con los que no tienen nada que ver. En otras palabras, la
seguridad es con frecuencia un problema. Para que los datos se mantengan
en secreto a toda costa es preferible tener una computadora personal aislada
sin conexiones de red con las demás máquinas y mantenerla en un cuarto
cerrado con un mueble seguro donde guardar todos los discos flexibles.
A pesar de estos problemas potenciales muchas personas sienten que las
ventajas tienen mayor peso que las desventajas y se espera que los sistemas
distribuidos tengan cada vez mayor importancia en los años venideros. De
hecho es probable que en unos cuantos años gran parte de las organizaciones
conecten la mayoría de sus computadoras a extensos sistemas distribuidos
para proporcionar un servicio mejor más barato y conveniente a sus usuarios.
78
Sistemas Operativos UNMSM - FISI
9. Sistemas de propósito general
Hasta ahora hemos definido muchos conceptos como sistemas distribuidos,
memoria virtual, sistemas operativos e informáticos de propósito general, entre
otros. Sin embargo, existen diferentes clases de sistemas informáticos cuyas
funciones son más limitadas y cuyo objetivo es tratar con dominios de
procesamiento limitados.
9.1.Sistemas embebidos en tiempo real
Las computadoras embebidas son las computadoras predominantes hoy en
día. Estos dispositivos se encuentran por todas partes, desde los motores de
automóviles y los robots para fabricación, hasta los magnetoscopios y los
hornos de microondas. Estos sistemas suelen tener tareas muy específicas.
Los sistemas en los que operan usualmente son primitivos, por lo que los
sistemas operativos proporcionan funcionalidades limitadas. Usualmente,
disponen de una interfaz de usuario muy limitada o no disponen de ella en
absoluto, prefiriendo invertir su tiempo en monitorizar y gestionar dispositivos
hardware, como por ejemplo motores de automóvil y brazos robóticos.
Estos sistemas embebidos varían considerablemente. Algunos son
computadoras de propósito general que ejecutan sistemas operativos
estándar, como UNIX, con aplicaciones de propósito especial para
implementar la funcionalidad. Otros son sistemas hardware con sistemas
operativos embebidos de propósito especial que solo proporcionan la
funcionalidad deseada. Otros son dispositivos hardware con circuitos
79
Sistemas Operativos UNMSM - FISI
integrados específicos de la aplicación, que realizan sus tareas sin ningún
sistema operativo.
9.2.Sistemas multimedia
Una tendencia innovadora sobre los sistemas informáticos son los sistemas
multimedia, en los cuales se utilizan los datos multimedia. Los datos
multimedia abarcan tanto archivos de audio y vídeo, como archivos
convencionales. Estos datos difieren de los convencionales en que los datos
multimedia deben suministrarse cumpliendo ciertas restricciones de tiempo.
La palabra multimedia describe un amplio rango de aplicaciones que hoy en
día son de uso popular. Incluye los archivos de audio, las películas de DVD, la
videoconferencia y las secuencias de vídeo con anuncios de películas o
noticias que los usuarios descargan a través de Internet. Las aplicaciones
multimedia también pueden incluir webcast en directo de conferencias o
eventos deportivos, e incluso cámaras web que permiten a un observador que
esté en Manhattan ver a los clientes de un café en París.
9.3.Sistemas de mano
Los sistemas de mano incluyen los ADP (asistente digital personal), tales
como los Palm y Pocket-PC, y los teléfonos móviles, muchos de los cuales
usan sistemas operativos embebidos de propósito especial. Los
desarrolladores de aplicaciones y sistemas de mano se enfrentan a muchos
retos, la mayoría de ellos debidos al tamaño limitado de dichos dispositivos.
Problemas que presentan los sistemas de manos:
Tamaño: Debido a su tamaño, la mayoría de los dispositivos de mano
tienen muy poca memoria, procesadores lentos y pantallas de visualización
pequeñas.
Velocidad: Otra dificultad que presentan los sistemas de manos es la
velocidad del procesador usado en los dispositivos. Los procesadores de la
mayor parte de los dispositivos de mano funcionan a una fracción de la
velocidad de un procesador típico para PC. Los procesadores requieren
mayor cantidad de energía cuanto más rápidos son. Para incluir un
procesador más rápido en un dispositivo de mano sería necesaria una
80
Sistemas Operativos UNMSM - FISI
batería mayor, que ocuparía más espacio y tendría que ser recargada
constantemente.
Problemas E/S: La falta de espacio físico limita los métodos de entrada a
pequeños teclados, sistemas de reconocimiento de escritura manual o
pequeños teclados basados en pantalla. Tareas tan familiares como leer un
correo electrónico o navegador por diversas páginas web se tienen que
condensar en pantallas muy pequeñas.
10. Protección y seguridad
Un sistema informático tiene múltiples usuarios y permite la ejecución de
concurrente de múltiples procesos, por lo que el acceso debe regularse. Con este
fin se crean mecanismos que aseguren que solo los usuarios autorizados utilicen
los recursos.
Protección es cualquier mecanismo que controle el acceso de procesos y
usuarios a los recursos definidos por un sistema informático. Este mecanismo
debe proporcionar los medios para la especificación de los controles que hay que
imponer y para la aplicación de dichos controles.
Estos mecanismos mejoran la fiabilidad permitiendo detectar errores latentes en
las interfaces de los subsistemas componentes. La detección temprana de errores
permite evitar la contaminación de un subsistema que funciona perfectamente por
parte de otro subsistema que funcione mal. Un sistema enfocado a protección
proporciona un medio para distinguir entre un usuario autorizado o no.
Un sistema puede tener la protección adecuada pero aun así estar expuestos a
fallos y permitir accesos inapropiados (como en el caso de un usuario al que se le
ha robado la informacion y sus datos pueden estar siendo borrados o copiados).
Es la responsabilidad de los mecanismos de defensa defender al sistema frente
ataques internos y externos. Algunos sistemas incorporan sus mecanismos de
defensa, aunque otros dejan esta responsabilidad a programas de terceros.
La protección y seguridad requieren que el sistema distinga a todos los usuarios.
La mayoría tiene una lista de nombres de usuario y sus identificaciones de
usuario o ID (que son uno por usuario). Cuando un ID necesita ser leído, se utiliza
una lista de nombres de usuario para poder traducir el ID al nombre
81
Sistemas Operativos UNMSM - FISI
correspondiente. En algunos casos, es necesario diferenciar entre conjuntos de
usuarios, lo que se consigue al definir un nombre de grupo y especificar los
usuarios que pertenecen a los mismos (asignando identificadores de usuarios).
Durante el uso normal del sistema el ID de usuario y el ID de grupo, pero el
usuario en ocasiones necesita escalar sus privilegios para obtener permisos
adicionales para una actividad.
Bibliografía
Silberschatz A., Galvin P. & Gagne G. (2006) Fundamentos de sistemas
operativos, 7ma edición. Madrid: Mc Graw Hill.
Satallings W. (2005) Sistemas operativos, Aspectos internos y principios de
diseño. Madrid: Pearson Prentice Hall.
82
top related