You are on page 1of 20

Universidad Privada Antenor Orrego

Sistemas Operativos
Centralizados y Distribuidos
Curso: Sistemas Operativos

Nombre:
 Cueva Chamorro, Diego Alonso

Ingeniería de Computación y Sistemas

2009
Índice de contenido
1) Sistemas Operativos Centralizados.............................................................................................. 4
1.1) Concepto ............................................................................................................................... 4
1.2) Gestión de procesos.............................................................................................................. 5
1.3) Gestión de memoria .............................................................................................................. 5
1.4) Gestión de dispositivos.......................................................................................................... 6
1.5) Gestión de archivos ............................................................................................................... 6
2) Sistemas Operativos Distribuidos................................................................................................. 7
2.1) Concepto ............................................................................................................................... 7
2.2) Ventajas y Desventajas ......................................................................................................... 7
2.3) Aspectos del Diseño .............................................................................................................. 8
2.3.1) Transparencia................................................................................................................. 8
2.3.2) Flexibilidad...................................................................................................................... 9
2.3.3) Confiabilidad ................................................................................................................... 9
2.3.4) Desempeño .................................................................................................................... 9
2.3.5) Escalabilidad................................................................................................................... 9
2.4) Comunicación en los sistemas distribuidos ......................................................................... 10
2.5) Sincronización en sistemas distribuidos .............................................................................. 10
2.6) Procesos y procesadores .................................................................................................... 10
2.7) Sistemas distribuidos de archivos ....................................................................................... 11
2.8) Memoria compartida distribuida........................................................................................... 11
2.9) Modelos de Sistemas Distribuidos....................................................................................... 12
2.9.1) Grupos de Procesadores.............................................................................................. 12
2.9.2) Cliente Servidor ............................................................................................................ 12
3) Comparación entre Sistemas Operativos Centralizados y Distribuido ....................................... 13
4) Ejemplos ..................................................................................................................................... 14
4.1) Ejemplos de Sistemas Operativos Centralizados ................................................................ 14
4.1.1) DOS .............................................................................................................................. 14
4.1.2) UNIX ............................................................................................................................. 15
4.1.3) Mac OS......................................................................................................................... 15
4.2) Ejemplos de Sistemas Operativos Distribuidos ................................................................... 16
4.2.1) Amoeba ........................................................................................................................ 16
4.2.2) Mach ............................................................................................................................. 17
4.2.3) Chorus .......................................................................................................................... 18
4.2.4) DCE .............................................................................................................................. 18
Bibliografía ...................................................................................................................................... 21
Conclusiones .................................................................................................................................. 20
Sistemas Operativos Centralizados y Distribuidos

1) Sistemas Operativos Centralizados

1.1) Concepto

Si queremos dar una definición simple de lo que es un sistema operativo centralizado, diremos que
se trata de de aquel que utiliza los recursos de una sola computadora, es decir, su memoria, CPU,
disco y periféricos.

Respecto al hardware podemos decir que se suele tratar de un computador caro y de gran potencia,
con terminales alfanuméricos directamente conectados. Suele tratarse de una computadora de tipo
desktop, en las cuales es común encontrar un monitor grande con un teclado y un mouse; además de
un case para albergar la unidad de procesamiento y los demás componentes.

Podemos encontrar este tipo de sistemas operativos en un entorno de empresa, en el cual puede
haber un soporte multiusuario. Las empresas, en especial las antiguas, utilizan una mainframe
potente para dar capacidad de cómputo a muchos terminales, o también se puede encontrar
empresas con abundantes minicomputadores para los empleados que las necesiten en sus
actividades. Uno de los primeros modelos de ordenadores interconectados fue el centralizado,
donde todo el procesamiento de la organización se llevaba a cabo en una sola computadora,
normalmente un Mainframe, y los usuarios empleaban sencillos ordenadores personales.

Los problemas de este modelo son que cuando la carga de procesamiento aumentaba se tenía que
cambiar el hardware del Mainframe, lo cual es más costoso que añadir más computadores
personales clientes o servidores que aumenten las capacidades. El otro problema que surgió son las
modernas interfases gráficas de usuario, las cuales podían conllevar a un gran aumento de tráfico en
los medios de comunicación y por consiguiente podían colapsar.

Otro entorno donde se encuentran sistemas operativos de arquitectura centralizada es en los


entornos científicos. En ellos se busca la ejecución eficiente de aplicaciones y el uso de
supercomputadores, que son computadoras con capacidades de cálculo muy superiores a las
comúnmente disponibles de las máquinas de escritorio. Se suele usar este tipo de máquinas para
cálculos en los que intervienen una gran cantidad de operaciones complejas y muchos factores.

En un entorno familiar se puede encontrar una computadora. Estas tienen un sistema operativo
centralizado porque el ordenador es único y no necesita trabajar en paralelo con ninguna otra
computadora, ya que no se encuentra conectado a ninguna. Normalmente estos ordenadores tienen
uno o dos procesadores potentes y caros que satisfacen las necesidades de cómputo del usuario.

En estos sistemas hay un uso ocasional de la red, como para transferir ficheros o logins remotos.
Actualmente prácticamente todos (por no decir todos) los sistemas operativos permiten la
transferencia de ficheros. Uno puede conectarse con una máquina en la misma red y acceder a los
documentos que ésta esté dispuesta a compartir por orden del usuario o viceversa. Pero no se trata
de una transferencia realmente transparente pues el usuario está consciente de que está accediendo a
archivos almacenados en un disco diferente al que le pertenece, al que forma parte de su
computadora. Asimismo es posible conectarse de forma remota a otra computadora como en el caso
de la asistencia remota, pero son más que nada utilidades o funciones agregadas que permite
realizar el sistema operativo centralizado, sin llegar a ser lo que buscaba como objetivo principal el
sistema al ser diseñado.

Son muy conocidos los sistemas centralizados con los que contamos en la actualidad, basta con
empezar por los que tenemos instalados en nuestras propias computadoras como Windows, Linux,
Mac OS, Unix, etc.

1.2) Gestión de procesos

Respecto al manejo de procesos podemos cubrir 3 cosas: la comunicación entre procesos, la


sincronización y la planificación.

Para ejecutar un proceso, se le asigna memoria y se ejecuta sobre el (normalmente) único


procesador del sistema. Es más simple que en un sistema distribuido pues siempre se va a elegir el
procesador local, así que el tema pasa más por buscar el funcionamiento óptimo del procesador que
se posea y en buscar en qué procesador ejecutar un proceso para aprovechar las posibilidades de
cómputo.

La gestión de procesos en un sistema operativo centralizado se ocupa de los mecanismos y políticas


para compartir o repartir un procesador entre diversos procesos de usuario.

Los procesos pueden comunicarse entre sí a través de memoria compartida, ya sean variables
compartidas o buffers, o a través de las herramientas provistas por las rutinas de IPC (Interprocess
Communication). 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.

Hay varios modelos de sincronización de procesos tales como el de exclusión mutua, semáforos y
mensaje. En el caso de un sistema operativo centralizado se puede usar la memoria compartida para
facilitar la sincronización.

El sistema operativo debe decidir qué proceso ejecutar de aquellos que están listos para ejecución.
El planificador es la parte del sistema operativo que realiza la decisión mediante el algoritmo de
planificación. Los objetivos son mejorar la equidad, eficiencia, tiempo de respuesta, minimizar el
tiempo de proceso global y maximizar el número de trabajos procesados. El problema es que el
comportamiento de los procesos es único e impredecible. Se puede usar diferentes algoritmos de
planificación

1.3) Gestión de memoria

El manejo de memoria tiene que ver con la asignación de memoria, el mapeo lógico y físico, la
memoria virtual y los mecanismos de protección. En el sistema centralizado se maneja sólo la
memoria con la que cuenta la computadora en la que está instalado el sistema.

Es la parte del sistema encargada de asignar memoria a los procesos, tratará de repartir de forma
eficiente la memoria para introducir tantos procesos como sea posible.

La asignación de memoria consiste en el proceso de asignar memoria para propósitos específicos,


ya sea en tiempo de compilación o de ejecución. Si es en tiempo de compilación es estática, si es en
tiempo de ejecución es dinámica y si son variables locales a un grupo de sentencias se denomina
automática. Generalmente se divide la memoria en dos particiones, una para el SO residente y otra
para los procesos de usuario. La asignación de memoria es exclusiva para el proceso que la
requiere, es decir, ésta es lógicamente separada de la de cualquier otro proceso del sistema.

El manejo de la memoria virtual consiste en hace creer a los programas que existe una memoria
principal de gran tamaño y explota localidad de acceso a través de la jerarquía de memoria. Además
la gestión de memoria debe cumplir algunos requisitos de protección como que el código de un
proceso no debe hacer referencia a posiciones de otros procesos sin permiso.

1.4) Gestión de dispositivos

Sobre el manejo de dispositivos podemos tratar los driver de los dispositivos, el buffering y el
spooling. Para que sea un sistema centralizado la gestión de dispositivos debe encargarse sólo de los
dispositivos que le pertenecen a una sola computadora.

La gestión de dispositivos tiene que ver con los drivers y con los controladores. Los drivers o
manejadores son programas que se encargan de detalles que son dependientes de los dispositivos.
Los controladores son elementos electrónicos de la unidad E/S, los cuales brindan una abstracción
de lo que hace el dispositivo pues uno le envía la función al controlador y él se encarga de ver que
el dispositivo realice las acciones necesarias.

En un sistema centralizado, la asignación de los recursos disponibles está gestionada, como ya


sabemos, por el sistema operativo. También se encarga de aplicar las técnicas de buffering y
spooling. Para desacoplar las velocidades de funcionamiento de los dispositivos con las de otros
elementos del sistema y, por lo tanto, aumentar el rendimiento, es habitual la utilización de
almacenamiento intermedio o buffering tanto de entrada como de salida. El uso del spooling
consiste en tener un buffer que almacena datos a enviar a un dispositivo que no admite operaciones
de diferentes orígenes intercaladas.

1.5) Gestión de archivos

Para el manejo de archivos hay que tener en cuenta el acceso a archivos, la compartición de
archivos, el control de concurrencia y la replicación de datos. Es la parte del sistema operativo
centralizado que se encarga de proporcionar a los usuarios y aplicaciones servicios de para el uso,
acceso y control de accesos, tanto de archivos como a directorios.

Los objetivos básicos de la gestión de archivos son: garantizar que la información del archivo sea
valida, optimizar el acceso a los archivos, proveer soporte E/S a gran variedad de dispositivos de
almacenamiento, entregar los datos que el usuario pide, minimizar o eliminar una potencial perdida
de datos, proveer un conjunto estándar de rutinas E/S, proveer soporte de E/S a múltiples usuarios.

Las funciones básicas que debe cubrir son las de crear un archivo, borrar un archivo abrir un
archivo y cerrar un archivo.
2) Sistemas Operativos Distribuidos

2.1) Concepto

Según Tanenbaum, un sistema distribuido es "una colección de computadoras independientes que


aparecen ante los usuarios del sistema como una única computadora.

De eso podemos entender que las máquinas son autónomas y los usuarios siempre piensan que el
sistema es como una única computadora. Un sistema distribuido se caracteriza por comportarse
frente al usuario como una sola máquina; el usuario desconoce sobre qué procesador se está
ejecutando sus procesos y dónde residen sus ficheros.

Vamos a dar un ejemplo. Primero consideremos una red de estaciones de trabajo en un


departamento de una compañía. Además de cada estación de trabajo podría existir una pila de
procesadores en el cuarto de máquinas que no estén asignados a usuarios específicos sino que se
utilicen de manera dinámica conforme sea necesario. Tal vez el sistema podría tener un sistema de
archivos único con todos los archivos accesibles desde todas las máquinas de la misma forma y con
el mismo nombre de ruta de acceso. Además, cuando el usuario escriba un comando el sistema
podría buscar el mejor lugar para ejecutarlo, tal vez en la propia estación de trabajo de usuario o en
una estación de trabajo inactiva que pertenezca a otra persona o en uno de los procesadores no
asignados en el cuarto de máquinas. Si el sistema se ve como un todo y actúa como un sistema de
tiempo compartido clásico con un único procesador pondría considerarse como un sistema
distribuido.

Otro ejemplo es el de un enorme banco con cientos de sucursales por todo el mundo. Cada oficina
tiene una computadora maestra para guardar las cuentas locales y el manejo de las transacciones
locales. Además cada computadora tiene la capacidad de comunicarse con las otras sucursales y con
una computadora central en las oficinas centrales. Si las transacciones se pueden realizar sin
importar dónde se encuentre el cliente o la cuenta y los usuarios no observan diferencia alguna entre
este sistema y el antiguo centralizado que ha reemplazado también se podría considerar como un
sistema distribuido.

Los sistemas operativos de red están formados por un software débilmente acoplado en un hardware
débilmente acoplado. De no ser por el sistema compartido de archivos a los usuarios les parecería
que el sistema consta de varias computadoras. Puede ejecutar su propio sistema operativo y hacer lo
que quiera. El siguiente paso en la evolución es el del software fuertemente acoplado en hardware
débilmente acoplado, esta es la aparición de los sistemas distribuidos. El objetivo es crear la ilusión
en las mentes de los usuarios que toda la red de computadoras es un sistema de tiempo compartido,
en vez de máquinas diversas.

Debe haber un mecanismo de comunicación global entre los procesos, de forma que cualquier
proceso pueda comunicarse con cualquier otro. También un sistema global de protección. La
administración de procesos debe ser la misma en todas partes. La forma en que se crean, destruyen
y detienen los procesos no debe variar de una máquina a otra. También el sistema de archivos debe
tener la misma apariencia en todas partes. Como consecuencia lógica de hecho de tener una misma
interfaz de llamadas al sistema en todas partes, es normal que se ejecuten núcleos idénticos en todos
los CPU de sistema. Eso facilita la coordinación de las actividades globales. Por ejemplo, cuando se
inicie un proceso, todos los núcleos deben cooperar en la búsqueda del mejor lugar para ejecutarlo.
Los sistemas distribuidos se basan en la utilización de sistemas de transmisión fiables, eficaces,
rápidos que permitan integrar sistemas de distintos fabricantes.

2.2) Ventajas y Desventajas


Entre las ventajas tenemos:

La descentralización económica. Por ejemplo, en el caso de los CPU, si uno está dispuesto a pagar
el doble so obtiene el mismo CPU sólo que con una velocidad un poco mayor. De tal forma, es más
cómodo limitarse a un gran número de CPU baratos reunidos en un mismo sistema. Los sistemas
distribuidos tienen en potencia una proporción precio/desempeño mucho mejor que la de un sistema
centralizado.

Además ciertas aplicaciones son distribuidas en forma inherente. Una cadena de supermercados
podría tener muchas tiendas las cuales reciben los artículos de manera local realiza ventas locales y
toma decisiones locales acerca de las verduras que están viejas o podridas y qué debe hacerse. Por
lo tanto, tiene sentido mantener un inventario de cada tienda dentro de una computadora local a la
vez de tenerlo de manera central en las oficinas de la compañía. Después de todo, la mayoría de las
solicitudes y actualizaciones se harían en forma local. Sin embargo de vez en cuando la
administración central podría tratar de determinar la cantidad de nabos que posee en cierto
momento. Una forma de lograr este objetivo es hacer que todo el sistema se vea como una
computadora para los programas de aplicación pero implementado de manera descentralizada en
una computadora por tienda como ya se ha descrito. Éste sería entonces un sistema distribuido
comercial.

Otra ventaja sobre los sistemas centralizados es la confiabilidad. Al distribuir la carga de un trabajo
en muchas máquinas la falla de un circuito descompondría a lo más una máquina y el resto seguiría
intacto. También está el crecimiento por incrementos, ya que no es necesario comprar una nueva
mainframe carísima cuando la empresa necesita más poder de cómputo.

Entre las desventajas tenemos:

El peor de los problemas es el software: qué lenguajes de programación utilizar, que aplicaciones
son adecuadas.

El problema de las redes de comunicación. Se pueden perder mensajes, lo cual requiere un software
especial para su manejo y puede verse sobrecargado. Al saturarse la red ésta debe reemplazarse o
añadir una segunda. De cualquier forma, es un gran costo.

El hecho que los datos se puedan compartir puede ser un arma de doble filo, pues también pueden
acceder a datos que no les corresponde ver. La seguridad es con frecuencia un problema.

2.3) Aspectos del Diseño

2.3.1) Transparencia

Tal vez sea el aspecto más importante. Consiste en engañar a todas las personas para que piensen
que la colección de máquinas es tan solo un sistema de tiempo compartido de un procesador, a la
manera antigua.

La transparencia se puede lograr en dos niveles distintos. Lo más fácil es ocultar la distribución a
los usuarios. Para ellos lo único poco usual es que el desempeño del sistema tiene un cambio
decente. En un nivel inferior también es posible que el sistema sea transparente para los programas.
Se puede diseñar la interfaz de llamadas al sistema de modo que no sea visible la existencia de
varios procesadores.
Hay varios tipos de transparencia:
 Transparencia de localización: Los usuarios no pueden indicar la localización de los
recursos.
 Transparencia de migración: Los recursos se pueden mover a voluntad sin cambiar sus
nombres.
 Transparencia de réplica: Los usuarios no pueden indicar el número de copias existentes.
 Transparencia de concurrencia: Varios usuarios pueden compartir recursos de manera
automática.
 Transparencia de paralelismo: Las actividades pueden ocurrir en paralelo sin el
conocimiento de los usuarios.

2.3.2) Flexibilidad

Es importante que el sistema sea flexible. Junto con la transparencia son fundamentales. Es bueno
mantener las opciones abiertas. Existen dos escuelas de pensamiento en cuanto a la estructura de los
sistemas distribuidos. Una escuela mantiene que cada máquina debe ejecutar un núcleo tradicional
que proporcione la mayoría de los servicios. La otra consiste que el núcleo proporcione lo menos
posible y que el grueso de los servicios del sistema operativo se obtenga a partir de los servidores a
nivel de usuario. Estos dos modos son conocidos como el núcleo monolítico y micronúcleo.

2.3.3) Confiabilidad

La idea es que si una máquina falle, otra se encargue del trabajo. Los sistemas distribuidos actuales
cuentan con que un número de ciertos servidores sirvan para que el todo funcione.

La disponibilidad se refiere a la fracción de tiempo en que se puede utilizar el sistema. Esta se


puede mejorar mediante un diseño que no exija el funcionamiento simultáneo de un número
sustancial de componentes críticos. Otra herramienta es la redundancia, se puede duplicar piezas
clave del hardware y de software, de modo que si una de ellas falla, las otras pueden llenar su
hueco. Otro aspecto es la tolerancia a fallos. Supongamos que un servidor falla y vuelve a arrancar
de manera súbita. Si el servidor tiene tablas con importante información acerca de las actividades en
proceso, lo menos que ocurrirá es que la recuperación será difícil.

2.3.4) Desempeño

La construcción de un sistema distribuido transparente, flexible y confiable no servirá si el sistema


es lento. Se puede utilizar diversas métricas del desempeño. El tiempo de respuesta es una, poro
también lo son el rendimiento, uso de sistema y cantidad consumida de capacidad de red.

El problema del desempeño se complica por el hecho de la comunicación, factor esencial en un


sistema distribuido. El envío y obtención de una respuesta en una LAN es lento. Para ello hay que
minimizar el número de mensajes. La dificultad con esta estrategia es que la mejor forma de
mejorar el desempeño es tener muchas actividades en ejecución paralela en distintos procesadores,
pero esto requiere el envío de muchos mensajes.

Una posibilidad es prestar atención al grano de todos los cálculos. En general, los trabajos que
implican gran número de pequeños cálculos, en particular aquellos que interactúan en gran medida
con otros, pueden ser la causa de algunos problemas en los sistemas distribuidos con una
comunicación lenta.

2.3.5) Escalabilidad
La mayor parte de los sistemas distribuidos están diseñados para trabajar con unos cuantos cientos
de CPU. Un sistema distribuid puede empezar con una cantidad manejable de usuarios, pero cuando
pasa el tiempo puede que se tenga un sistema distribuido con decenas de millones de usuarios. La
cuestión es si los métodos que se desarrollan en la actualidad podrán escalarse hacia tales grandes
sistemas.

Lo que queda claro es que se debe evitar los componentes, tablas y algoritmos centralizados, pues
no es una buena idea tener un solo servidor de correo para 50 millones de usuarios. Además, el
servidor no toleraría bien las fallas.

2.4) Comunicación en los sistemas distribuidos

La diferencia principal entre un sistema distribuido y un sistema con un procesador es la


comunicación entre procesos. En un sistema con un procesador la mayor parte de la comunicación
entre procesos supone de manera implícita la existencia de memoria compartida. Un proceso escribe
en un buffer compartido y otro proceso lee de él. En un sistema distribuido no existe tal memoria
compartida, por lo que toda la naturaleza de la comunicación entre procesos debe replantearse desde
cero.

Para los sistemas distribuidos de área amplia relativamente lentos, se utilizan los protocolos de
capas orientadas hacia la conexión como OSI y TCP/IP, puesto que el problema principal por
resolver es el transporte confiable de los bits a través de líneas físicas pobres. Para los basados en
LAN, los protocolos con capas se utilizan muy pocos. En vez de ellos, se adopta por lo general un
modelo mucho más sencillo donde el cliente envía un mensaje al servidor y éste envía de regreso
una respuesta al cliente. También se utiliza mucho la llamada a procedimientos remotos (RPC).
Con ella un proceso cliente que se ejecuta en una máquina llama a un procedimiento que se ejecuta
en otra máquina.

2.5) Sincronización en sistemas distribuidos

Es importante la forma en que los procesos cooperan y se sincronizan entre sí. Por ejemplo, la
forma de implantar las regiones críticas o asignar recursos en un sistema distribuido.

En los sistemas con un CPU, los problemas relativos a regiones críticas, la exclusión mutua y la
sincronización se resuelven en general mediante métodos tales como los semáforos y monitores.
Pero estos no son adecuados para sistemas distribuidos, puesto que siempre se basan en la
existencia de memoria compartida, por lo que se necesitan otras técnicas. La mayoría de sistemas
operativos distribuidos tienen un paquete de hilos.

La sincronización de procesos en los sistemas distribuidos resulta más compleja que en los
centralizados, debido a que la información y el procesamiento se mantienen en diferentes nodos. Un
sistema distribuido debe mantener vistas parciales y consistentes de todos los procesos cooperativos
y de cómputo. Tales vistas pueden ser provistas por los mecanismos de sincronización. La
sincronización no tiene por qué ser exacta, y bastará con que sea aproximadamente igual en todos
los ordenadores. Hay que tener en cuenta, eso sí, el modo de actualizar la hora de un reloj en
particular.

2.6) Procesos y procesadores

Se utilizan por lo común dos modelos de organización de los procesadores: el modelo de estación
de trabajo y el modelo de la pila de procesadores. En el primero, cada usuario tiene su propia
estación de trabajo y a veces puede ejecutar procesos en las estaciones de trabajo inactivas. En el
segundo, todas las instalaciones de cómputo son un recurso compartido. Los procesadores se
asignan de manera dinámica a los usuarios conforme sea necesario y se regresan a la pila al
terminar el trabajo.

Dada una colección de procesadores, se necesita un algoritmo para asignar los procesos a los
procesadores. Tales algoritmos pueden ser deterministas o heurísticos, centralizados o distribuidos,
óptimos o subóptimos, locales o globales, iniciados por el emisor o por el receptor.

Aunque los procesos se planifican por lo general de manera independiente, se puede mejorar el
desempeño mediante la co planificación, para garantizar que los procesos que deben comunicarse se
ejecutan al mismo tiempo. Sobre la planificación en los sistemas distribuidos podemos decir que
por lo general cada procesador hace su planificación local sin preocuparse por lo que hacen los
demás procesadores. También hay varios algoritmos de coplanificación, que toman en cuenta los
patrones de comunicación entre los proceso durante la planificación para garantizar que todos los
miembros de un grupo se ejecuten al mismo tiempo.

2.7) Sistemas distribuidos de archivos

Un componente fundamental es el sistema de archivos, es el corazón de cualquier sistema


distribuido. La tarea del sistema de archivos es almacenar los programas y los datos y tenerlos
disponibles cuando sea necesario.

El servicio de archivos es la especificación de los servicios que el sistema de archivos ofrece a los
clientes. El servidor de archivos es un proceso que se ejecuta en alguna máquina y ayuda a
implantar el servicio de archivos. Puede haber uno o varios servidores de archivos pero los clientes
no deben conocer cuántos hay ni su posición o función. Todo lo que saben es llamar a los
procedimientos especificados en el servicio de archivos y el trabajo se hace en alguna parte. Lo
ideal es que se vea como un sistema de archivos normal de un procesador. Puede haber varios
servidores de archivos, por ejemplo uno UNIX y uno en MS-DOS.

Hay varios modelos de semántica, como la semántica UNIX, la semántica de sesión, los archivos
inmutables y la semántica de transacción. La semántica UNIX es intuitiva y familiar para la
mayoría de los programadores pero su implantación es cara. La semántica de sesión es menos
determinística pero más eficiente. Los archivos inmutables no son familias para la mayoría de
personas y las transacciones suelen ser redundantes. NFS ilustra como construir un sistema
distribuido de archivos.

2.8) Memoria compartida distribuida

Existen dos tipos de sistema con varios procesadores: multiprocesadores y multicomputadoreas. En


un multriprocesador varias CPU comparten una memoria principal común. En el caso de una
multicomputadora cada CPU tiene su memoria particular, nada se comparte.

No se puede utilizar muchos procesadores con una sola memoria compartida porque se origina un
cuello de botella. En el caso de las multicomputadoras, como no hay memoria compartida se tiene
que utilizar la transferencia de mensajes, haciendo que la entrada/salida sea la abstracción central.
La transferencia de mensajes trae consigo varios aspectos delicados como el flujo de control, la
pérdida de mensajes, el uso de buffer y el bloqueo. Aunque se han propuesto varias soluciones, la
programación con transferencia de mensajes es todavía difícil.

También se propuso las llamadas a procesamientos remotos. Para utilizar un servicio remoto, un
proceso solo llama al procedimiento de la biblioteca adecuada, el cual empaqueta el código de la
operación y los parámetros del mensaje, enviándolo por la red y esperando la respuesta.

Se utilizan tres técnicas generales para proporcionar memoria compartida. La primera estimula el
modelo de memoria de multiprocesador, dando a cada proceso una memoria paginada lineal. Las
páginas se mueven de una máquina a otra según sea necesario. La segunda utiliza los lenguajes de
programación ordinarios con variables compartidas anotadas. La tercera se basa en los modelos de
programación de alto nivel, como las n-adas y los objetos.

En un sistema operativo distribuido, la memoria pasa a ser físicamente privada pero lógicamente
compartida. Es decir, un computador ejecuta los programas en su memoria propia, pero en caso de
necesitar mas memoria utilizara los recursos disponibles de otra computadora que este capacitada y
preparada dentro de la red para compartir su memoria.

2.9) Modelos de Sistemas Distribuidos

Hay distintas topologías en que se basan los sistemas distribuidos. Son las siguientes:

2.9.1) Grupos de Procesadores

En este modo, al abrir una sesión, el sistema asigna al usuario un procesador, pudiendo hacerlo en
función a la sobrecarga, la proximidad o cualesquiera otros parámetros que fije el diseñador. Un
método más sencillo y menos comprometido es hacer que el usuario elija el nodo al que quiere
conectarse, pero se pierde en transparencia y puede dar lugar a fuertes desequilibrios en el sistema.

La topología se basa en varios ordenadores unidos a través de una red de comunicaciones la cual se
pueden conectar los usuarios a través de sus ordenadores personales. Es un paso en la evolución de
los sistemas distribuidos pero falta un sistema de ficheros transparente y global desapareciendo la
idea de nodos.

2.9.2) Cliente Servidor

En este se cuenta con clientes que dan acceso a usuarios a los servicios y servidores que contienen
la información, servicios, etc. Una máquina puede ser cliente en un servicio y servidor en otro.

Es el modelo más conocido y más ampliamente adoptado en la actualidad. Hay un conjunto de


procesos servidores, cada uno actuando como un gestor de recursos para una colección de recursos
de un tipo, y una colección de procesos clientes, cada uno llevando a cabo una tarea que requiere
acceso a algunos recursos hardware y software compartidos. Los gestores de recursos a su vez
podrían necesitar acceder a recursos compartidos manejados por otros procesos, así que algunos
procesos son ambos clientes y servidores. En el modelo, cliente-servidor, todos los recursos
compartidos son mantenidos y manejados por los procesos servidores.

El modelo cliente-servidor nos da un enfoque efectivo y de propósito general para la comparición


de información y de recursos en los sistemas distribuidos. El modelo puede ser implementado en
una gran variedad de entornos software y hardware. Las computadoras que ejecuten los programas
clientes y servidores pueden ser de muchos tipos y no existe la necesidad de distinguir entre ellas.

El modelo cliente-servidor se ha extendido y utilizado en los sistemas actuales con servicios


manejando muchos diferentes tipos de recursos compartidos. Pero no es posible que todos los
recursos que existen en un sistema distribuido sean manejados y compartidos de esta manera;
algunos tipos de recursos deben permanecer locales a cada computadora de cara a una mayor
eficiencia como RAM, procesador, interfaz de red local. Estos recursos clave son manejados
separadamente por un sistema operativo en cada maquina.

Aunque el modelo cliente-servidor no satisface todos los requisitos necesarios para todas las
aplicaciones distribuidos, es adecuado para muchas de las aplicaciones actuales y provee una base
efectiva para los sistemas operativos distribuidos de propósito general.

3) Comparación entre Sistemas Operativos Centralizados y Distribuido

Sistema Operativo Centralizado Sistema Operativo Distribuido


Permite utilizar los recursos de una sola Permite utilizar los recursos (memoria, CPU,
computadora. disco, periféricos) de más de una computadora
al mismo tiempo.
La computadora suele tener gran potencia pero un Ofrecen una mejor proporción
alto precio. precio/rendimiento que los mainframes
Poder de cómputo limitado. Se puede tener un poder de cómputo mayor si
se juntan varias máquinas.
Si se estropea la máquina no se puede seguir Si una máquina se estropea el sistema puede
trabajando. seguir funcionando como un todo
Los incrementos de poder de cómputo significan Se puede añadir poder de cómputo en pequeños
comprar una mainframe más grande, lo que es incrementos.
bastante costoso para la empresa o universidad.
La carga de trabajo se tiene que realizar con los Difunde la carga de trabajo entre las máquinas
recursos con los que cuente el sistema disponibles en la forma más eficaz en cuando a
centralizado. coste en tiempo y en almacenamiento.
Hay una inmensa cantidad de software para los El software es escaso, es difícil encontrar
sistemas centralizados, ya que son los más usados software asequible para los sistemas
por la gente. distribuidos.
No necesita obligatoriamente de una red, pues es La red que permite la interconexión entre
un sistema independiente. máquinas se puede saturar, con la consiguiente
lentitud en el procesamiento o la pérdida de
información.
Hay bastante privacidad pues cada uno es dueño Mayor dificultad para mantener la privacidad
de los datos que tiene en su sistema. de la información ya que muchos usuarios
pueden tener acceso a los datos que se
almacenan.
No necesita crear una visión de una sola máquina Busca crear una transparencia, una visión de
porque realmente sólo hay una máquina. una sóla máquina cuando en realidad hay varias
máquinas.
Se cuenta con unos pocos CPU con una gran Se cuenta con muchos CPU de no tanta
capacidad. capacidad que trabajan juntos.
Los sistemas operativos centralizados aparecieron Los sistemas operativos distribuidos son un
primero. siguiente escalón en la evolución de los
sistemas operativos.
No hay un paralelismo real, es más una ilusión de Hay un paralelismo real, ya que varios procesos
paralelismo, con la excepción de las máquinas que podrían estar llevándose a cabo en diferentes
cuentan con varios procesadores como suelen procesadores pertenecientes a diferentes
fabricarse en los últimos tiempos. máquinas.
Son sistemas más fáciles de desarrollar y ya hay Son una clase de sistemas operativos más
décadas de experiencia en ellos. difícil de desarrollar debido a su complejidad.
En un sistema operativo centralizado el nodo No hay cuellos de botella pues todo se
principal debe soportar una gran carga y ese encuentra descentralizado.
generador de cuellos de botella.
Cuando se accesa a archivos que pertenecen a otra Cuando el usuario accesa a archivos de otra
máquina, el usuario se da cuenta claramente que máquina, él piensa que se trata de archivos
está ingresando a otra máquina. ubicados en su propia máquina cuando en
realidad no es así.
El kernel suele ser monolítico. El kernel suele ser micronúcleo.
El sistema centralizado maneja algoritmos El sistema distribuido maneja algoritmos
centralizados. distribuidos.
El usuario debe tener poder de cómputo en su Puede que el usuario no tenga poder de
máquina. cómputo en su máquina, en vez de eso haya
una colección de procesadores en un lugar.
Para la comunicación entre procesos se utiliza la Para la comunicación entre procesos se suele
memoria compartida. usar protocolos de capas o llamadas a
procedimientos remotos.
La sincronización de relojes no es importante Debe haber sincronización entre los relojes de
las diferentes máquinas.
La interfases gráficas deben ser malas para no Las interfases gráficas pueden ser más
saturar la máquina central. detalladas y vistosas.

4) Ejemplos

4.1) Ejemplos de Sistemas Operativos Centralizados

4.1.1) DOS

El MS-DOS se desarrollo para operar computadoras individuales de


escritorio para un solo usuario. Cuando el mercado de las
computadoras personales hizo explosión en los 80, fue el sistema
operativo estándar para millones de máquinas.

Es uno de los sistemas operativos más sencillos de comprender. En


muchas formas es un ejemplo de los primeros sistemas operativos
porque maneja los trabajos en secuencia a partir de un solo usuario.
Sus ventajas son su operación fundamental y sus comandos claros para
el usuario. Tiene dos desventajas. La primera es su falta de flexibilidad
y su limitada capacidad para llenar las necesidades de programadores y usuarios expertos. La
segunda proviene de sus raices; se escribió para una familia de microprocesadores. Cuando estos
microprocesadores dominaron el mercado de las computadoras personales, MS-DOS también lo
hizo. Pero con el avance de nuevos chips, el DOS perdió su ventaja de mercado en relación con los
sistemas operativos más elavorados.

Su apoyo de entradas y salidas estándares incluyen un teclado, monitor, impresora y unidad de


almacenamiento secundario. En el nivel inferior del MS-DOS está BIOS, que hace la interfaz con
los diversos dispositivos de entrada y salida como las impresoras, teclados y monitores. Este
sistema tiene requerimientos del sistema bajos y poco Soporte de hardware

Trabaja con comandos en modo texto formados por órdenes difíciles de recordar. Sólo se puede
ejecutar un programa en cada momento. La capacidad de aumentar el espacio de su disco duro, un
antivirus, una nueva versión del programa de apoyo y recuperación de datos, que por años no fue
mejorado, capacidad de intercambiar datos entre computadoras por medio de un cable, optimización
del uso de la memoria RAM y otras interesantes opciones. El DOS no es ni multiusuario ni
multitarea. No puede trabajar con más de un usuario ni en más de un proceso a la vez.

4.1.2) UNIX

Unix es un sistema interactivo diseñado para manejar múltiples procesos


y múltiples usuarios al mismo tiempo. Fue el primer sistema operativo
escrito en el lenguaje de programación C. Fue dieñado por programadores
y para programadores, para utilizarse en un entorno en el que la mayoría
de usuarios tienen conocimientos relativamente avanzados y se dedica a
proyectos de software que suelen ser complejos. Unix cuenta con
extensos recursos para trabajar en colaboración y compartir información
de formas controladas.

Es un sistema universal, válido para toda clase de ordenadores, grandes y pequeños. Para el Unix
todo es un archivo. Permite crear archivos con nombres hasta de 255 caracteres de largo. Tiene
algunas características de sistema distribuido, ya que existe un nombre único para todos los ficheros
disponibles en la red, y que es independiente de la máquina, o más específicamente, en ese nombre
no se incluye el nombre de la máquina en el que el fichero está almacenado.

El núcleo es un programa escrito casi en su totalidad en lenguaje C, con excepción de una parte del
manejo de interrupciones, expresada en el lenguaje ensamblador del procesador en el que opera.

El kernel hace que la computadora funcione bajo Unix y que los usuarios puedan compartir
eficientemente todos los recursos. Cada usuario puede interactuar con el Sistema Operativo con el
Interpretador de Comandos (Shell) de su agrado entre los que se destacan: El Bourne Shell , el C
Shell , El Korn Shell , el Bourne Again Shell.

El Unix utiliza y administra muy eficientemente la memoria. En la memoria libre atiende a los
procesos. A cada proceso le da la cantidad exacta de memoria que aquél necesite, desde pocos
kilobytes hasta varios megabytes. Cuando se acaba la memoria, utiliza el Area de Swap que es una
memoria virtual. Esto permite que se pueda ejecutar un programa que sea más grande que la
memoria RAM total que tenga un servidor de Unix.

Tiene capacidad de interconexión de procesos. Además permite comunicación entre procesos. Unix
emplea un sistema jerárquico de archivos, con facilidades de protección de archivos, cuentas y
procesos.

4.1.3) Mac OS
MacOS es abreviatura de Macintosh Operating System (Sistema Operativo
de Macintosh). El Mac OS original fue el primer sistema operativo con una
interfaz gráfica de usuario en tener éxito. El equipo de Macintosh incluía a
Bill Atkinson, Jef Raskin y Andy Hertzfeld.

Apple quitó importancia de forma deliberada a la existencia del sistema


operativo en los primeros años de Macintosh para ayudar a hacer que la
máquina pareciera más agradable al usuario y a distanciarla de otros sistemas
como MS-DOS, que eran un desafío técnico. Apple quería que Macintosh
fuera visto como un sistema que trabajara nada más con encenderlo. La interfaz grafica desarrollada
por Apple que se llama Aqua.

Este sistema operativo tiene un nucleo de la familia unix mas especificamente deriva de nexstep que
era un sistema operativo cuyo nucleo tenia codigo del kernel Mach y del de BSD. Mac OS utiliza
como gestor de ventanas x11 caracteristica que comparte con otros sistemas Unix

La arquitectura para la que fue diseñado originalmente eran para las Power PC es decir
computadoras de tipoRisc desarrolladas por IBM,Motorola y Apple. Es decir que esta ultima hizo
un sistema operativo especifico para un hardware que ellos tambien desarrollaron lo que le dio una
gran estabilidad y eficacia al sistema en su conjunto.

A partir del 2006 comenzaron a migrar a procesadores Intel utilizando los llamados binarios
universales, es decir, aplicaciones que contienen el código binario de ambas plataformas para su
ejecución transparente.

Existen varias versiones 10.1 Puma,10.2 Jaguar,10.3 Panther , 10.4 Tiger y 10.5 Leopard y 10.6
Snow Leopard y cada una ha ido incorporando mejoras.

4.2) Ejemplos de Sistemas Operativos Distribuidos

4.2.1) Amoeba

Es un sistema distribuido, permite que una coleción de CPU y


equipo de E/S se comporten como una computadora. También
proporciona elementos para la programación en paralelo si se desea.

Se originón en Vrije Universiteit en Amsterdam, Holanda, en 1981


como proyecto de investigación en cómputo distribuido y paralelo.
Fue diseñado en un principio por Tanenbaum y tres estudiantes de
doctorado. En 1983 un prototipo tenía un nuvel operacional. El
sistema evolucionó durante algunos años, adquiriendo características
como la emulación parcial de UNIX, la comunicación en grupo y un
nuevo protocolo de bajo nivel.

Para evitar el enorme trabajo de escribir grandes cantidades de software de aplicación se añadió un
paquete de emulación de UNIX. El objetivo principal del proyecto era construir un sistema
operativo distribuido y transparente. Para un usuario normal, funciona igual que un sist. tradicional.

Amoeba no tiene el concepto de máquina de origen. Cuando un usuario entra al sistema entra a éste
como un todo y no a una máquina específica. El shell inicial se ejecuta en cierta máquina arbitraria,
y los comando en otra máquina en general no la misma que la del shell. El sistema busca la
máquina con la menor carga para ejecutar el nuevo comando. Amoeba es muy transparente respecto
a la ubicación. Todos los recursos pertenecen al sistema como un todo y son controlados por él.

Amoeba busca proporcionar un colchón de prueba para la realización de una programación


distribuida y paralela. Los usuarios están interesados en la experimentación con algoritmos,
lenguajes, herramientas y aplicaciones distribuidas y paralelas. Ofrece soporte a estos usuarios al
hacer que el paralelismo subyacente esté disponible para los que quieran aprovecharlo.

Se diseñó con dos hipótesis respecto al hardware: los sistemas tienen un número muy grande de
CPU y cada CPU tendrá decenas de megabytes de memoria. Se basa en el modelo de pila de
procesadores. Este consta de varios CPU, cada uno con su propia memoria local y conexión a la red.
No se necesita la memoria compartida, pero si está presente se utiliza para optimizar la transferencia
de mensajes al hacer el copiad de una memoria a otra, en vez de enviar mensajes a través de la red.

Cuando un usuario escribe un comando, el sistema operativo asigna en forma dinámica uno o más
procesadores para ejecutar ese comando. Al terminar el comando, se terminan los procesos y los
recursos regresan a la pila, en espera de siguiente comando. El usuario tiene acceso al sistema a
través de un terminal. También puede tratarse de una computadora personal o estación de trabajo.
La idea es proporcionar terminales baratos y concentrar los ciclos de cómputo en una pila común
para utilizarlos con mayor eficiencia.

Amoeba consta de dos partes fundamentales, un micronúcleo que se ejecuta en cada procesador y
una colección de servidores que proporcionan la mayor parte de la funcionalidad de un sistema
operativo tradicional. Se soportan tres mecanismos de comunicación: RPC y FLIP simple para la
comunicación puntual y la comunicación confiable en un grupo par ala comunicación entre partes.
El sistema de archivos de Amoeba consta de tres servidores: el servidor de archivos para el
almacenamiento de éstos, el de directorios para otorgar nombres y el de réplicas para la réplica de
archivos.

4.2.2) Mach

Este sistema distribuido se basa en un micronúcleo. Es un proyecto de diseño de sistemas


operativos iniciado en la Universidad Carnegie Mellon en 1985. Se hizo que Mach fuese compatible
con UNIX, esperando poder utilizar el enorme volumen disponible de software para UNIX. La
primera versión apareció en 1986.

Los objetivos de este proyecto han ido variando con el tiempo. Los objetivos se pueden resumir en:
 Proporcionar una base para la construcción de otros sistemas operativos
 Soporte de un espacio de direcciones ralo y de gran tamaño
 Permitir el acceso transparente a los recursos de la red
 Explorar el paralelismo tanto en el sistema como en las aplicaciones
 Hacer que Mach se pueda transportar a una colección más grande de máquinas.

La idea es explorar los multiprocesadores y los sistemas distribuidos, a la vez que se puedan emular
los sistemas ya existentes como UNIX, MS-DOS y Macintosh.

El micronúcleo de Mach se diseñó para emular a UNIX y otros sistemas operativos. Esto se lleva a
cabo mediante una capa del software que se ejecuta fuera del núcleo, en el espacio del usuario.
Cada emulador consta de una parte que está presente en el espacio de direcciones de los programas
de aplicación, así como uno o más servidores que se ejecutan de manera independiente a los
programas de aplicación. Se pueden ejecutar varios emuladores al mismo tiempo.

El núcleo de Mach, al igual que otros micronúcleos, proporciona la administración de procesos, la


administración de la memoria, la comunicación y los servicios de E/S. Los archivos, directorios y
demás funciones tradicionales de sistema operativo se controlan en el espacio del usuario. La idea
del núcleo es proporcionar los mecanismos necesarios para que el sistema funcione, pero dejando la
política a los procesos a nivel de usuario.

Mach se basa en los conceptos de procesos, hilos, puertos y mensajes. Mach tiene un sistema de
memoria virtual muy elaborado con objetivos de memoria que se pueden asociar o desasociar de los
espacios de direcciones, respaldado por administradores de memoria externos a nivel de usuario. De
esta forma se puede escribir o leer de los archivos en forma directa.
4.2.3) Chorus

Chorus surgió en el instituto francés de investigación INRIA en 1980 como proyecto de


investigación en sistemas distribuidos. Desde entonces han aparecido 4 versiones, de la 0 a la 3.

La versión 0 era quería modelar aplicaciones distribuidas como colección de actores, en esencia
procesos estructurados, cada uno de los cuales alternaban entre la realización de una transacción
atómica y la ejecución de un paso de comunicación. La versión 1 se centró en la investigación de
multiprocesador. Fue escrita en Pascal compilado en vez de interpretado y se distribuyó en una
docena de universidades y compañías. La versión 2 fue una reescritura fundamental en C. Se diseñó
de modo que las llamadas al sistema fuesen compatibles con UNIX en el nivel del código fuente. La
versión 3 marcó la transición de un sistema de investigación a un producto comercial. Se introdujo
la llamada a procedimientos remotos como el modelo de comunicación usual.

Para que sea un producto viable se aumentó la capacidad de emulación de UNIX, de modo que los
programas en UNIX se ejecutaran sin compilarse de nuevo.

Los objetivos de Chorus son:


 Emulación de UNIX de alto rendimiento
 Uso de sistemas distribuidos
 Aplicaciones de tiempo real
 Integración de la programación orientada a objetos en Chorus

Está estructurado en capas. En la parte inferior está el micronúcleo que proporciona la mínima
administración de los nombres, procesos, hilos, memoria y comunicación. Se tiene acceso a estos
servicios mediante llamadas al micronúcleo. Los procesos de las capas superiores proporcionan el
resto del sistema operativo.

Por arriba de micronúcleo pero operando también en el modo núcleo están los procesos del núcelo.
Estos se cargan y eliminan de manera dinámica durante la ejecución del sistema y proporcionan una
forma de extender la funcionalidad del micronúcleo sin que aumente de manera permanente su
tamaño y complejidad.

El micronúcleo y los subsistemas proporcionan juntos tres construcciones adicionales: las


posibilidades, los identificadores de protección y los segmentos. Los primeros dos se utilizan para
nombrar y proteger los recursos del subsistema. La tercera es la base para la asignación de memoria,
tanto dentro de un proceso en ejecución como en el disco.

4.2.4) DCE

Se trata de un punto de vista diferente. DCE significa ambiente de administración distribuido. A


diferencia de los anteriores, este ambiente se construye sobre los sistemas operativos existentes.

El ambiente ofrecido por DCE consta de un número grande de herramientas y servicios, más de una
infraestructura para que éstos operen. Las herramientas y servicios han sido elegidos de modo que
funcionen juntos de manera integrada y faciliten el desarrollo de aplicaciones distribuidas. Por
ejemplo, DCE proporciona un mecanismo para sincronizar los relojes de máquinas diferentes y
obtener el concepto global de tiempo.

DCE se ejecuta en muchos tipos distintos de computadoras, sistemas operativos y redes. De esta
forma los desarrolladores de aplicaciones producen con facilidad software portable en varias
plataformas, amortizando los costos de desarrollo e incrementando el tamaño del mercado
potencial.

El modelo de programación subyacente en todo DCE es el modelo cliente/servidor. Los procesos


usuario actúan como clientes para tener acceso a los servicios remotos proporcionados por los
procesos servidor. DCE soporta dos facilidades que se utilizan intensamente, tanto dentro del propio
DCE como en los programas usuario: hilos y RPC. Los hilos permiten la existencia de varios flujos
de control dentro de un proceso. RPC es el mecanismo básico de comunicación dentro de DCE.
Permite que un proceso cliente llame a un procedimiento en una máquina remota.

DCE soporta cuatro servicios principales a los que tienen acceso los clientes: los servicios de
tiempo, directorios, seguridad y archivos. El servicio de directorios guarda los nombres y
posiciones de todos tipos de recursos y permite que los clientes los busquen. El servicio de
seguridad permite que los clientes y servidores se autentiquen entre si y realicen una RPC
autentificada. El sistema de archivos proporciona un espacio de nombres para todos los archivos del
sistema.
Conclusiones

Después de la elaboración del presente trabajo sobre los sistemas operativos centralizados y
distribuidos se ha llegado a las siguientes conclusiones:

 La diferencia entre estos dos tipos de sistemas operativos está en base a los recursos que
maneja cada uno. Los sistemas operativos centralizados utilizan los recursos de una sóla
computadora, mientras que los sistemas operativos distribuidos gestionan los recursos de
múltiples computadoras.

 Los sistemas operativos centralizados aparecieron primero y los distribuidos están unos
escalones adelante en la evolución de los sistemas operativos. Hay mucha experiencia en los
sistemas centralizados pero en los distribuidos hay aún temas que requieren más
investigación.

 Los sistemas operativos que usamos normalmente en nuestras casas o en la universidad son
centralizados, con capacidad para conectarse en red, pues en estos ambientes sólo nos
interesa usar la máquina que ocupamos, pero en otros lugares, ya sea empresas u otras
universidades puede interesarles tener las computadoras bajo un sistema distribuido y
proporcionar por ejemplo un uso transparente de una gran capacidad de disco o capacidad de
procesamiento.

 Es mucho más compleja la implementación de un sistema operativo distribuido pues al tener


que gestionarse varias máquinas cambian los algoritmos, la forma de planificación, la
manera en la que se comunican los procesos, la sincronización, ya que en este nuevo entorno
no se puede tener toda la información sobre todos los nodos así que hay que buscar la
manera posible de sobrellevar esta situación.

 El verdadero paralelismo se alcanza con los sistemas operativos distribuidos, pues tienen la
característica de poder ejecutar varios procesos en diferentes nodos al mismo tiempo, con lo
que se mejora el performance del sistema en general. Con un sistema con un sólo procesador
el paralelismo era falso, ya que la técnica de la multiprogramación brinda sólo la ilusión de
que varios procesos se ejecutan a la vez, claro que también se puede lograr paralelismo con
los nuevos procesadores de varios núcleo.

 Mientras que el objetivo del sistema operativo centralizado radica en llevar una buena
gestión de los recursos con los que cuenta la máquina, el objetivo del sistema distribuido es
crear una transparencia para el usuario, de forma que vea al conjunto de computadoras como
una sóla y no se de cuenta donde esta el límite entre su máquina y cualquier otro nodo.

 Los sistemas distribuidos tienen varias ventajas frente a los centralizados como la economía,
la velocidad, la confiabilidad, la flexibilidad, la comunicación y el crecimiento por
incrementos.
Bibliografía

 Cabello, Díaz y Martínez. (1997). Sistemas Operativos, Teoría y Práctica. Madrid: Díaz de
Santos.

 Flynn, Ida y Mclver, Ann. (2001). Sistemas Operativos (3a ed.). México: Thomson.

 Rojo, Oscar. (2003). Introducción a los sistemas distribuidos. Obtenido el 6 de Junio de


2009, de http://www.augcyl.org/

 Tanenbaum, Andrew. (1996). Sistemas Operativos Distribuidos. Mexico: Prentice Hall.

 Morera Pascual, Juan y Perez-Campanero, Juan. (2002). Conceptos de Sistemas Operativos.


Madrid: Universidad Pontificia de Comillas.