VisualOS

Descripcin del proyecto

Manuel Estrada Sainz

  ranty@atdot.org
  ranty@soon.com

Copyright  2000 por Manuel Estrada Sainz

-------------------------------------------------------------------------------

Tabla de contenidos
1. Introduccin
2. Objetivos
3. Conceptos tericos

    Asignacin del procesador
    Utilizacin de la memoria: (Algoritmos de seleccin de vctima)
    Planificacin de accesos a memoria secundaria

4. Tcnicas y herramientas
5. Aspectos relevantes del desarrollo
6. Trabajos relacionados

-------------------------------------------------------------------------------

Captulo 1. Introduccin

El propsito de este proyecto es desarrollar una herramienta grfica que
permita el estudio y comprensin del funcionamiento real de un sistema
operativo moderno.

El programa que se presenta permite observar los aspectos ms relevantes de un
sistema operativo en funcionamiento. Tambin permite ver cmo funcionan y cmo
interactan los tres sistemas mas importantes: planificacin de procesos,
gestin de memoria y Entrada/Salida. Las representaciones son dinmicas
pudiendo capturarse algunas de las grficas, para su posterior estudio, mostrar
el funcionamiento del sistema en "vivo" o experimentar directamente con l.

Un sistema operativo consta de muchas partes ntimamente relacionadas, de
manera que su buen funcionamiento depende tanto del correcto funcionamiento de
cada una de ellas como de su correcta interaccin. Este programa permite tanto
su estudio global como el estudio concreto de alguna de sus partes.

Tradicionalmente cada parte de un sistema operativo se estudia por separado,
siendo muy difcil ofrecer una visin global e integrada de todas ellas, as
como de los problemas de la concurrencia, debido a la difcil representacin
del sistema en funcionamiento.

Hasta ahora la nica manera de comprender realmente estos conceptos era
escribiendo y modificando el cdigo de un sistema operativo real para luego
analizar su funcionamiento. Con este propsito se escribieron sistemas
operativos como MINIX, NACHOS o TUNIX. El problema que tiene este mtodo es que
requiere mucho tiempo, y para ser realmente til se necesita un gran dominio
del lenguaje de programacin utilizado, que permita centrarse en la lgica del
problema. Esta nueva herramienta permitir la realizacin de laboratorios en
los cuales se podr, en poco tiempo, comprender conceptos fundamentales del
funcionamiento real de los sistemas operativos.

En el mbito docente, el presente programa convierte en ms sencillas las
tareas anteriores. Facilita al profesor el trabajo de realizar grficas y otras
representaciones que expliquen los conceptos importantes del sistema operativo,
y permite que el alumno los vea ms claramente, porque podr realmente ver, por
ejemplo, cmo los distintos procesos se disputan el procesador y la memoria a
la vez que pretenden ser los primeros en leer del disco y cmo es el sistema el
que gestiona estos recursos. Todo lo vern en conjunto y no fragmentado como se
puede explicar en una clase tradicional. Por supuesto tambin se pueden
desactivar algunas de las partes para poder ver ms claramente el
funcionamiento de las dems. Incluso se pueden mostrar los distintos
subsistemas en mquinas diferentes para realizar prcticas en las que distintos
alumnos se hagan cargo de cada uno, eligiendo el algoritmo que quiere utilizar
o incluso tomando las decisiones manualmente.

[VisualOS-0]

Por otro lado, tambin se podr utilizar como banco de pruebas, haciendo ms
fcil y flexible el mtodo de modificar y escribir cdigo, ya que la aplicacin
est escrita de forma modular y tomando especial inters en hacer lo mas
sencillo posible la adicin de nuevos algoritmos o modificacin de los ya
existentes. Para poder hacer esto no ser necesaria la comprensin del resto
del cdigo, solamente ser necesario aprender el interfaz que los algoritmos en
cuestin utilizan, una estructura de datos y algunas funciones. Incluso se han
escrito funciones para ocultar al implementador de los algoritmos la
utilizacin de GTK+ como librera de elementos grficos.

Para hacer lo ms fcil posible el mantenimiento de la documentacin interna y
asegurar as la calidad de esta, se ha utilizado un sistema que genera cdigo
DocBook (SGML) a partir de comentarios estructurados en el cdigo fuente del
programa denominado "gtk-doc". DocBook, es un estndar en la industria (SUN
MicroSystems, Hewlett Packard, O'Reilly ...), y por su carcter semntico
permite escribir los documentos una sola vez y de forma automtica obtenerlos
en diferentes formatos: HTML, PostScript, PDF, DVI, Braille ...

El sistema de control de versiones utilizado ha sido CVS (Concurrent Version
System), que es el estndar de facto en el mbito del software libre. El CVS
permite gestionar los cambios de colecciones completas de archivos.

Gracias a las herramientas "automake" y "autoconf" la compilacin del programa
es muy sencilla, ya que se detectan las peculiaridades del entorno de forma
automtica y sin intervencin del usuario.

Se ha considerado importante la utilizacin de estndares abiertos y
herramientas libremente disponibles para facilitar la colaboracin en el futuro
por parte de los propios estudiantes o de cualquier otra persona que lo desee a
lo largo de todo el mundo (mediante Internet). Para lograr estos objetivos se
han utilizado herramientas como DocBook (SGML) como formato de documentacin,
el API de programacin GNOME/GTK+, el compilador GCC (GNU C COMPILER) y el
sistema de control de versiones CVS (Concurrent Version System).

-------------------------------------------------------------------------------

Captulo 2. Objetivos

El propsito de este proyecto, es crear un entorno visual en el cual se pueda
experimentar fcilmente con un sistema operativo.

Deber cumplir los siguientes requisitos:

  * Tendr que ser un entorno visual e intuitivo que resulte amigable al
    usuario.

  * Las estructuras de datos mas importantes de dicho sistema operativo se
    representarn grficamente para su mejor comprensin.

  * Tendr que permitir la observacin de las interacciones del sistema
    completo, as como de cada una de sus partes por separado.

  * Tendr que ser modular y fcilmente modificable, en especial tendr que ser
    sencillo aadir nuevos algoritmos.

  * La aplicacin ser software libre, y tendr que ser desarrollada utilizando
    tan solo software libre y estndares abiertos.

Teniendo en cuenta los requisitos anteriores, se debern representar los
siguientes mecanismos:

  * Planificacin de procesos.

  * Planificacin de memoria.

  * Planificacin de disco.

-------------------------------------------------------------------------------

Captulo 3. Conceptos tericos

Los conceptos tericos utilizados para la realizacin propia del sistema son
los conceptos bsicos de programacin que no es necesario comentar, pero los
conceptos que se pretenden ilustrar s que merecen mencin.

El sistema operativo est hecho para dar vida a los procesos, as que comenzar
por ellos. Un proceso, no es ms que una lista de instrucciones que estn en
ejecucin y se aplican a datos en memoria principal y secundaria. Adems, en
los sistemas informticos actuales, las propias instrucciones tambin se
guardan en memoria secundaria para su almacenamiento y en memoria principal
para su ejecucin.

La vida de un proceso comienza con la carga de sus instrucciones en memoria
principal desde la memoria secundaria y el inicio de su ejecucin a partir de
su primera instruccin. A lo largo de su vida tpicamente necesitar datos de
memoria secundaria que almacenar en memoria principal para su procesamiento y
posteriormente escribir los datos resultantes en memoria secundaria y se
terminar.

En los primeros tiempos de los ordenadores de arquitectura Von Newmann era
directamente el hardware el que cargaba las instrucciones del proceso en
memoria e iniciaba su ejecucin, el procesador se dedicada enteramente a la
ejecucin de este nico proceso y este dispona de toda la memoria principal y
poda utilizar la memoria secundaria libremente.

Actualmente el problema es que pretendemos que varios procesos convivan en la
misma mquina, de manera que se aproveche ms el hardware disponible (ej. un
proceso puede hacer clculos mientras otro intenta leer de memoria secundaria)
y se puedan realizar varias tareas simultneamente en el tiempo (multitarea) e
incluso que varios usuarios puedan compartir la misma mquina (multiusuario).
Sin aadir elementos nuevos al sistema, la complejidad a la hora de programar
crecera exponencialmente con el numero de procesos, para poder compartir
recursos y el fallo de uno solo de los procesos podra afectar gravemente a los
dems. Es necesario, pues, una coordinacin.

La figura del sistema operativo se introduce inicialmente para realizar la
tarea de intermediario entre los distintos procesos. Ser cargado en memoria
principal y ejecutado por el hardware y ser el sistema operativo el que se
ocupe de dar vida a los procesos y de repartir los recursos disponibles entre
ellos. Al menos tendr que realizar las siguientes labores:

  * Cargar en memoria principal los distintos procesos.

  * Decidir cul de los procesos es asignado al procesador para ser ejecutado
    en cada momento.

  * Cuando alguno de los procesos solicite memoria ser l quien decida qu
    memoria utilizar, incluso podr decidir quitrsela a otro proceso. De
    hecho, utilizar memoria libre es sencillo, el problema surge cuando es
    necesario "robar" memoria a otro proceso, en cuyo caso el contenido ser
    escrito en memoria secundaria, y entregada al que la necesita. As que son
    los algoritmos de seleccin de "vctima" los que se estudian.

  * Cuando alguno de los procesos solicite leer de memoria secundaria ser l
    quien lo haga, coordinando y ordenando las lecturas de los distintos
    procesos para mejorar el rendimiento. Siendo lo ms importante en este caso
    el orden en que se leen los datos.

Este programa ilustra los distintos algoritmos utilizados para estas tareas.
Concretamente los algoritmos actualmente implementados son:

-------------------------------------------------------------------------------

Asignacin del procesador

First Come First Served: (Primero en llegar, primero en ser servido)

    El primer proceso en condiciones de ejecutarse ser el asignado al
    procesador y permanece asignado hasta no poder ejecutarse ms por tener que
    esperar a algn evento o por haber terminado.

Round Robin

    Se establece un tiempo mximo de ejecucin o cuanto y se ejecuta cada
    proceso hasta que exceda su cuanto o no quiera ejecutarse ms, entonces se
    asigna otro y as sucesivamente. Los procesos en espera de ejecucin forman
    una cola circular.

Shortest Process Next: (El proceso ms corto el prximo)

    Se ejecuta el proceso ms breve de los que estn preparados, y permanece
    asignado hasta no poder ejecutarse ms, momento en el cual se volver a
    elegir el proceso ms corto.

Shortest Remaining Time: (El tiempo restante ms corto)

    Se ejecuta el proceso ms corto de los que estn preparados, pero a
    diferencia del SPN el esquema es apropiativo, de manera que siempre que
    surja otro proceso listo para ejecutarse se comprobar si va a tardar menos
    en ejecutarse que el actual y si es as ser el nuevo proceso el que se
    asigne y el actual tendr que esperar.

Highest Response Ratio Next: (El de mayor tasa de respuesta el prximo)

    Para cada proceso, basado en el tiempo que va a ocupar el procesador(s) y
    el tiempo que lleva esperando para ocuparlo (w), Se calcula w+s/s, una vez
    echo esto el proceso que tenga un valor mayor ser asignado al procesador.
    Este algoritmo es bastante bueno, por que adems de dar preferencia a los
    procesos cortos tambin tiene en cuenta el envejecimiento de los procesos
    para evitar as la "inanicin".

-------------------------------------------------------------------------------

Utilizacin de la memoria: (Algoritmos de seleccin de vctima)

First In First Out: (Primero en entrar primero en salir)

    Se "roban" los fragmentos de memoria de forma cclica sin tener en cuenta a
    quin pertenecen o su frecuencia de utilizacin.

Second Chance: (Segunda oportunidad)

    Siempre que un proceso utiliza un fragmento de memoria, ste se seala como
    utilizado. Al mismo tiempo, para elegir un fragmento se busca uno que no
    est sealado y se elimina esta en los que la tienen.

    De esta manera se les da una "segunda oportunidad" a los procesos. Si
    utilizan el fragmento de memoria enseguida, no lo perdern.

Clock: (reloj)

    Es similar al "Second Chance" pero en este caso tambin tiene en cuenta si
    los datos de los fragmentos han sido modificados desde que fueron cargados
    en memoria principal. Si no es as, podrn ser descartados evitando un
    acceso a memoria secundaria. Por lo tanto, intenta evitar el "robo" de
    fragmentos modificados.

-------------------------------------------------------------------------------

Planificacin de accesos a memoria secundaria

First Come First Served (Primero en llegar primero en ser servido)

    Se realizan los accesos en el mismo orden en que son solicitados.

Shortest Seek Time First (El desplazamiento de cabezal ms corto el primero)

    Se ordenan los accesos minimizando el movimiento del cabezal lector, puesto
    que es la accin ms costosa.

Scan

    Se ordenan los accesos de manera que el cabezal lector se desplace de un
    extremo a otro de la superficie del disco, evitando cambiar de sentido
    mientras haya una peticin referente a una zona ms adelante.

N-Step-Scan

    Se ordenan los accesos igual que en el caso anterior, pero slo teniendo en
    cuenta un determinado nmero de ellos, y por lo tanto nunca se realizar un
    acceso posterior a ese nmero aunque se encuentre en el camino del cabezal.

-------------------------------------------------------------------------------

Captulo 4. Tcnicas y herramientas

Sistema de Documentacin: SGML(DocBook v3.1)/gtk-doc-tools v0.3

    He utilizado SGML (Standard Generalized Markup Language) por su
    flexibilidad, este sistema permite dar significado a las distintas partes
    de un documento de manera que posteriormente se pueden mecanizar muchas de
    las tareas de elaboracin. Ya que el documento no tiene formato sino
    significado, se pueden asignar distintos estilos de formato segn sea el
    soporte de destino: Papel, Paginas web, PostScript, Portable Document
    Format, Braille... etc.

    Concretamente he elegido el DTD (Document Type Definition) DocBook ya que
    parece ser el estndar de facto en la documentacin de productos software,
    utilizado por empresas como Hewelt Packart, SUN MicroSystems u O'Reilly.

    Por ser un estndar internacional (ISO 8879) es totalmente independiente
    del software utilizado y totalmente portable, al contrario que otros
    formatos propietarios como Word, WordPerfect, QuarkXpress...

    Como ventaja adicional, es un formato basado en texto, y no en caracteres
    binarios no imprimibles, lo que permite un control de cambios ms fcil,
    especialmente con herramientas como CVS (Concurrent Version System).

    Tambin he utilizado gtk-doc-tools, un sistema de generacin de
    documentacin SGML a partir de comentarios estructurados dentro del cdigo
    fuente del programa. Es el sistema utilizado en GTK+ y GNOME para la
    creacin del manual de referencia del API.

API de programacin: GNOME v1.2.4/GTK+ v1.2.8/Xwindow v3.3.6

    GTK+, una biblioteca de elementos grficos inicialmente apoyada en Xwindow,
    que est siendo portada a Win32, fue originalmente desarrollada para
    satisfacer las necesidades del magnfico programa de tratamiento
    fotogrfico GIMP (GNU Image Manipulation Program) y progresivamente se ha
    convertido en el estndar de facto para la programacin de aplicaciones
    grficas en el mundo del software libre, desplazando a la todopoderosa
    Motif. Posteriormente surgi la iniciativa, de manos de Miguel de Icaza de
    crear un entorno de programacin ms cmodo y flexible que denomin GNOME
    (GNU Network Object Model Environment) que utilizo GTK+ para dibujar
    ventanas, botones y dems elementos grficos.

    Este entorno, goza de toda la flexibilidad del sistema Xwindow ( ejecucin
    remota, independencia del gestor de ventanas ...) y adems est libremente
    disponible, incluido todo su cdigo fuente y proporciona documentacin
    gratuita en mltiples formatos (la editan en SGML).

    Adems estas herramientas estn hechas para ser portables, por supuesto a
    travs de la mayora de los sistemas de tipo UN*X y muy pronto Win32
    (Microsoft Windows 95/98/NT).

Editor: vi/emacs

    Para la mayor parte del programa he utilizado una versin mejorada del
    clsico VI (Visual Interactive:) denominada VIM (VI iMproved).

    Posteriormente para la edicin de la memoria a partir de las notas he
    utilizado emacs, con un paquete de extensin para documentos SGML.

Compilador: GCC v2.95.2 (GNU C Compiler)

    Es un compilador muy portable, tambin de libre distribucin que es capaz
    de compilar C, C++, Java, Pascal y Fortran. Est disponible para casi todas
    las plataformas UN*X, Win32, Beos, DOS, y puede que otras.

Depurador: gdb v4.18 (GNU Debuger)/DDD v3.2.1(Data Display Debuger)

    Para la depuracin he utilizado el programa de consola gdb y a menudo su
    "front end" grfico DDD.

Control de Versiones: CVS v1.20.8 (Concurrent Version System)

    Este es el sistema de control de versiones "estndar" en el mundo del
    software libre. Permite registrar los cambios de colecciones completas de
    archivos, pudiendo sealar momentos importantes del desarrollo para su
    posterior examen, y el mantenimiento de distintas ramas de desarrollo.
    Tambin permite acceso remoto a las colecciones de archivos para facilitar
    la colaboracin a travs de Internet.

Sistema de compilacin: automake v1.4/autoconf v2.13

    "Automake" genera de forma semiautomtica todo el sistema de compilacin
    (archivos Makefile) ricos en funcionalidad y de acuerdo con los estndares
    de GNU.

    "Autoconf" es capaz de detectar las distintas peculiaridades el entorno de
    desarrollo permitiendo una compilacin fcil a todo tipo de usuarios en
    todas las plataformas soportadas.

-------------------------------------------------------------------------------

Captulo 5. Aspectos relevantes del desarrollo

El ciclo de vida elegido ha sido el incremental. En primer lugar se ha
realizado la infraestructura del sistema para luego disear e implementar cada
uno de los subsistemas: procesador, memoria y entrada/salida.

En todo momento se ha tenido en cuenta la genericidad del cdigo. Siempre que
ha sido implementada alguna funcionalidad se ha realizado de manera que pudiera
ser utilizada en otras circunstancias similares y por otros subsistemas.

Para minimizar los posibles efectos secundarios y dada la caracterstica
concurrente del proyecto, cada subsistema se ejecuta en un proceso diferente y
se comunica mediante paso de mensajes (actualmente mediante sockets).

El Reloj (CLOCK) es el encargado de dar una referencia de tiempo comn a los
dems subsistemas. El tiempo se expresa en "Unidades de tiempo" que representan
el tiempo mnimo que puede transcurrir entre dos eventos consecutivos. Esto
quiere decir que se pueden ejecutan varias instrucciones en cada "unidad de
tiempo". En el caso de la memoria secundaria la cabeza lectora tarda en volar
por encima de una pista una "unidad de tiempo" y otra en cada acceso lo que no
es muy realista, pues tendra que ser ms lento. Esto, sin embargo, no quita
generalidad y resulta ms didctico.

-------------------------------------------------------------------------------

Captulo 6. Trabajos relacionados

Este podra ser el primer entorno visual concebido para facilitar la
comprensin de un sistema operativo moderno.

