Sistemas Operativos 2.0(BETA)

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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;


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

Sistemas Operativos 2.0(BETA)

Documents

Transcript of Sistemas Operativos 2.0(BETA)