1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS DISTRIBUIDOS. .....................................................................

3
1.1. INTRODUCCIÓN A LOS SISTEMAS DISTRIBUIDOS. ........................................................................................................ 3
1.2. ESTRUCTURA DE UN SISTEMA OPERATIVO DISTRIBUIDO. .............................................................................................. 3
1.2.1. Funciones. .............................................................................................................................................. 3
1.2.2. Características de un sistema operativo distribuido. ............................................................................. 3
1.3. TIPOS DE SISTEMAS OPERATIVOS DISTRIBUIDOS. ........................................................................................................ 5
2. SISTEMA OPERATIVOS MULTIPROCESADOR. .................................................................................................. 5
2.1. CONCEPTO Y ARQUITECTURA DE UN SISTEMA OPERATIVO MULTIPROCESADOR. ................................................................ 5
2.1.1. Clasificación. .......................................................................................................................................... 6
2.1.2. Interconexión de los procesadores. ....................................................................................................... 7
2.2. GESTIÓN DEL PROCESADOR................................................................................................................................... 7
2.2.1. Asignación de procesadores. ................................................................................................................. 7
2.2.2. Planificación del procesador. ................................................................................................................. 7
2.3. SINCRONIZACIÓN Y GESTIÓN DE LA MEMORIA. .......................................................................................................... 8
2.3.1. Algoritmos de sincronización................................................................................................................. 8
3. COMPONENTES DE UN SISTEMA OPERATIVO DISTRIBUIDO. .......................................................................... 9
3.1. INTRODUCCIÓN. ................................................................................................................................................. 9
3.2. ARQUITECTURA CLIENTE SERVIDOR......................................................................................................................... 9
3.2.1. Arquitectura cliente servidor de 3 niveles. ............................................................................................ 9
3.2.2. Comunicaciones en una arquitectura cliente servidor de 3 niveles. .................................................... 10
3.2.3. Difusión de la información................................................................................................................... 12
3.2.4. Modelo de comunicación en un mismo grupo..................................................................................... 13
3.3. FUNCIONES EN ARQUITECTURAS DISTRIBUIDAS. ...................................................................................................... 13
3.3.1. SERVICIO DE NOMBRES ....................................................................................................................... 14
3.3.2. Migración de procesos. ....................................................................................................................... 14
3.3.3. Ejecución remota de procesos. ............................................................................................................ 15
4. SERVICIOS DE TIEMPO. .................................................................................................................................16
4.1. EL TIEMPO EN LOS SISTEMAS OPERATIVOS DISTRIBUIDOS. .......................................................................................... 16
4.2. SISTEMAS BASADOS EN RELOJES FÍSICOS. ............................................................................................................... 16
4.2.1. ALGORITMO DE CRISTIAN .............................................................................................................. 17
4.2.2. ALGORITMO DE BERKELEY ............................................................................................................ 17
4.2.3. PROTOCOLO DE TIEMPO DE RED ......................................................................................................... 17
4.3. SISTEMAS BASADO EN RELOJES LÓGICOS. ............................................................................................................... 18
4.3.1. ALGORITMO DE LAMPORT ............................................................................................................. 18
4.3.2. RELOJES VECTORIALES DE MATTERN Y DE FIDGE ................................................................... 19
4.3.3. PROTOCOLO BSS (BIRMAN, SCHIPER, STEPHENSON) ............................................................... 19
4.3.4. RELOJES MATRICIALES ......................................................................................................................... 19
5. SINCRONIZACIÓN DISTRIBUIDA. ...................................................................................................................20
5.1. LA SINCRONIZACIÓN EN LOS SISTEMAS DISTRIBUIDOS ............................................................................................... 22
5.2. ALGORÍTMOS DE ELECCIÓN Y COOPERACIÓN........................................................................................................... 22
5.2.1. Algoritmo del matón. .......................................................................................................................... 22
5.2.2. Algoritmo del anillo. ............................................................................................................................ 22
5.2.3. ALGORITMO DE INVITACIÓN. ........................................................................................................ 23
5.3. ALGORITMOS DE SINCRONIZACIÓN. ...................................................................................................................... 23
5.3.1. Exclusión mutua centralizada. ............................................................................................................. 23
5.3.2. Algoritmo del testigo o token. ............................................................................................................. 24
5.3.3. ALGORITMO DE RICART Y AGRAWALA ......................................................................................... 24
5.3.4. ALGORITMO DE LAMPORT ............................................................................................................. 24
5.3.5. ALGORITMO DE MAEKAWA. ........................................................................................................... 24
5.3.6. ALGORITMO DESCENTRALIZADO ......................................................................................................... 24
6. SISTEMA DE FICHEROS REPLICACIÓN Y BASE DE DATOS. ...............................................................................26
6.1. NECESIDAD DE LOS SISTEMAS DE BASE DE DATOS DISTRIBUIDOS. ................................................................................. 26
6.2. SISTEMA DE ARCHIVOS DISTRIBUIDOS. .................................................................................................................. 26
Pág. 1 de 50
 6.2.1. Esquema de nombres. ......................................................................................................................... 27
6.2.2. Acceso a los ficheros. ........................................................................................................................... 27
6.3. TRANSACCIONES. ............................................................................................................................................. 27
6.3.1. Mecanismos de control de transacciones. ........................................................................................... 27
6.3.2. propiedades de las transacciones. ACID .............................................................................................. 28
6.3.3. Protocolos de concurrencia. ................................................................................................................ 28
6.3.4. Transacciones distribuidas................................................................................................................... 28
6.4. REPLICACIÓN Y COHERENCIA. .............................................................................................................................. 29
6.4.1. Modelos ce coherencia. ....................................................................................................................... 29
7. SISTEMAS OPERATIVOS DE TIEMPO REAL. ....................................................................................................30
7.1. CARACTERÍSTICAS DE LOS SISTEMA OPERATIVOS DE TIEMPO REAL. ............................................................................... 30
7.1.1. Gestión de tiempo. .............................................................................................................................. 30
7.2. ADMINISTRACIÓN DE RECURSOS EN UN SISTEMA DE TIEMPO REAL............................................................................... 31
7.2.1. Planificación del procesador. ............................................................................................................... 31
7.2.2. Asignación de recursos. ....................................................................................................................... 32
7.3. SISTEMAS OPERATIVOS COMERCIALES EN TIEMPO REAL. ............................................................................................ 32
7.3.1. Posix. ................................................................................................................................................... 32
7.3.2. Real time java. ..................................................................................................................................... 33
7.3.3. Real time Linux. ................................................................................................................................... 33
7.3.4. Free RTOS. ........................................................................................................................................... 33
8. ARQUITECTURA MULTICOMPUTADOR. .........................................................................................................33
8.1.1. Antecedentes de la multiprogramación. ............................................................................................. 34
8.2. CLUSTER COMPUTING. ................................................................................................................................ 35
8.2.1. Arquitectura y diseño de un cluster. .................................................................................................... 36
8.2.2. Cluster de google. ................................................................................................................................ 38
8.3. SISTEMA GRID. ............................................................................................................................................... 39
8.3.1. Arquitectura de un grid. ...................................................................................................................... 39
9. TEST ..............................................................................................................................................................41
9.1. TEMA 1 .......................................................................................................................................................... 41
9.2. TEMA 2. ......................................................................................................................................................... 42
9.3. TEMA 3. ......................................................................................................................................................... 43
9.4. TEMA 4 .......................................................................................................................................................... 45
9.5. TEMA 5 .......................................................................................................................................................... 46
9.6. TEMA 6 .......................................................................................................................................................... 47
9.7. TEMA 7. ......................................................................................................................................................... 48
9.8. TEMA8 .......................................................................................................................................................... 49

Pág. 2 de 50
1. Introducción a los sistemas operativos distribuidos.
1.1. Introducción a los sistemas distribuidos.

Un sistema distribuido es un sistema coordinado cuyos componentes se comunican a través de una red mediante
mensajes, y que resulta totalmente transparente para el usuario.

Al igual que un sistema operativo convencional, un sistema operativo distribuido es una colección de componentes
de software que facilitan las tareas de programación y soportan un rango muy extenso de aplicaciones. La diferencia
está en que un sistema operativo distribuido debe ser extensible y modular.

Características:
Recursos compartidos,
Concurrencia,
Escalabilidad,
Tolerancia a fallos ,
Transparencia.
Modularidad.

1.2. Estructura de un sistema operativo distribuido.

1.2.1. Funciones.

Tareas que afecta a gestión de recursos.

 Gestión de tiempo: se encarga de funciones como el planificador del procesador y la temporización y gestión
de las interrupciones.
 Gestión del espacio: tiene como función la asignación de la memoria principal, y la asignación y gestión del
espacio en disco.
 Sincronización y cooperación: se encarga de coordinar la sincronización entre procesos a través de
semáforos, monitores, señales, llamadas de procedimiento remoto (RPC), y mensajes principalmente.

Tareas del entorno de usuario

 Entorno de ejecución: fundamentalmente lleva a cabo la gestión de procesos, manipulación de ficheros,
operaciones de E/S (entrada/salida), interfaz humana, etc.
 Detección y manejo de errores: controla el qué hacer cuando se produce un error, se encarga de las
excepciones y la recuperación y tolerancia a fallos.
 Protección y seguridad: controla el acceso y la recuperación de información.

Aplicaciones:
 Identificación remota (o login remoto). telnet.
 Transferencia de ficheros: ftp o rcp
 Paso de mensajes. EDI, mail (Ente ellos SMTP y POP)
 Navegación en red. www
 Ejecución remota.

Tareas Entorno usuario aplicaciones

Gestión de tiempo Entorno de ejecución Telnet
Gestión de espacio Detección y mapeo de errores Ftp rcp
Sincronización y coorperación Protección y seguridad Mensajes Edi mail
www
ejecución remota

1.2.2. Características de un sistema operativo distribuido.

1.- Recursos compartidos. Recurso es un elemento que se puede compartir : hw impresora, sw ddbb
Ventajas:
 Se reducen costes. Se comparten recursos caros
 Compartición de datos: es un requisito imprescindible en muchas aplicaciones.
Pág. 3 de 50
 El modelo que permite esta gestión y distribución de recursos, lo que se
llama un modelo cliente-servidor.

Un mismo equipo o aplicación puede ser cliente y servidor a la Vez.

Cada recurso gestionado por un servidor por un programa

Se referencia con utilizar un esquema de nombres específico para el recurso

que gestiona.

Los clientes tienen recursos locales; procesador, memoria, interfaz de red.

Objetos compartidos Otro modelo es el modelo basado en objetos (Wegner, 1984). En este
modelo, cada recurso compartido es visto como un objeto.

Los recursos se referencian de una manera uniforme, independientemente

del tipo de recurso

2.- Modularidad. Capacidad que tenga para añadir nuevos recursos compartidos sin interrupción o duplicación de
los servicios existentes. Los sistemas que están diseñados para soportar la gestión de recursos compartidos, son
sistemas distribuidos abiertos.

3.- Concurrencia. Ejecución simultánea de varios programas. Si un procesador serialización, si varios ejecución en
paralelo.
Puede ser de información o de recursos.
La ejecución de aplicaciones de forma simultánea es fundamental por dos razones:
 Muchos usuarios de forma simultánea ejecutan o invocan procesos que se encuentran en máquinas remotas.
 Muchos servidores actúan de forma concurrente solicitando ejecuciones de procesos y ejecutando algunos
para otras máquinas.

Concurrencia puede ser de información o de recursos. La concurrencia requiere sincronización.

4.- Escalabiliad. Los recursos y las aplicaciones software no deberían cambiar cuando la escala del sistema
cambia. La escalabilidad es uno de los parámetros más complicados de predecir dentro de un sistema distribuido,
ya que no se sabe a priori la evolución que tendrá en el futuro.

5.- Tolerancia a fallos. El diseño de un sistema distribuido tolerante a fallos está basado en dos premisas:
 Redundancia hardware: se utilizan componentes críticos duplicados para que el sistema no sufra una
parada.
 Recuperación del software: los programas están diseñados para tomar distintas alternativas en función del
tipo de fallo.
En sistemas cliente servidor las aplicaciones críticas están instaladas en varios servidores aunque no estén activas
Tipos de fallos
 Leve si los datos de ese momento se pueden recuperar
 Grave si los datos se pierden de forma permanente.

Disponibilidad cantidad de tiempo que el sistema está disponible.

6.- Transparencia. La transparencia de un sistema se define como la capacidad de éste para parecer como un ente
único a cualquier usuario. De manera estándar se identifican ocho formas de transparencia:
Acceso: permite acceder a recursos locales y remotos con las mismas operaciones.
Localización: se acceden a los componentes y recursos sin saber dónde están.
Concurrencia: varios procesos se ejecutan a la vez, compartiendo recursos y sin interferir unos con otros.
Replicación: se actualizan simultáneamente varias copias de datos clave sin intervención del usuario
(puede existir el problema de la coherencia de los datos).
Reubicación: los objetos se pueden mover dentro del sistema mientras se están utilizando.
Fallos: los procesos pueden terminar sin que el usuario sea consciente de que ha habido fallos en el
sistema.
Migración: los objetos se pueden mover dentro del sistema sin afectar a la operación de los procesos.
Prestaciones: permite que el sistema pueda reconfigurarse para mejorar las prestaciones cuando varía la
carga.
Escala: se puede ampliar el sistema sin tener que cambiar ni su estructura, ni los algoritmos de las
aplicaciones.
Persistencia: oculta si un recurso de software se localiza en memoria o en disco.
Pág. 4 de 50
 Las más importantes son de ACCESO LOCALIZACIÓN

1.3. Tipos de sistemas operativos distribuidos.

Complicación en el diseño.

Nomenclatura: los nombres asignados deben tener significado global.

Deben ser independientes de la localización de los recursos respectivos para permitir su movilidad.
Comunicación entre máquinas: esencial en un sistema distribuido, de ellas dependen las prestaciones del sistema y
el buen funcionamiento global.
Estructura del software: debe estar modulado y abierto para permitir nuevas extensiones y funcionalidades.
Balanceo de carga: debe existir un control en el reparto de carga de los servidores para que no haya unos muy
saturados y otros libres.
Mantenimiento de la coherencia: fundamental que los datos sean estables, sobre todo en transacciones importantes
como operaciones bancarias, o actualizaciones en bases de datos.

Seis tipos de sistemas:

1.- Sistema operativo distribuido: a nivel de gestión se encarga de controlar y gestionar recursos en una red de
ordenadores autónomos se comporta como un sistema operativo monolítico.

2.- Sistema operativo multiprocesador: controlan y gestionan los recursos hardware y software de un ordenador,
comportándose como un equipo monoprocesador.

3.- Sistema operativo multicomputador: es una alternativa a los multiprocesadores. Generalmente agrupan varios
ordenadores y se unen mediante una red de comunicaciones de alta velocidad. Se comportan como un ordenador
único, agrupándose como cluster o como GRID.

4.- Sistema operativo de base de datos: controlan y gestionan los recursos hardware y software de un ordenador,
comportándose como un equipo monoprocesador. lleva a cabo transacciones, maneja grandes cantidades de datos. En
estos sistemas es muy importante el control de la concurrencia para mantener los datos actualizados y fiables

5.- Sistema operativo de tiempo real: opera igual que el sistema operativo anterior en cuanto al control y a la gestión.
El diseño es idéntico al de los sistemas tradicionales, pero requiere funciones más eficientes. En cuanto a sus
principales características, suelen ser aplicaciones diseñadas para entornos específicos con requisitos específicos
especiales.

6.- Sistema operativo móvil: controla y gestiona los recursos en una red de ordenadores autónomos como en los
sistemas distribuidos. Se comporta como un sistema monolítico donde los nodos son móviles y se conectan y
desconectan con frecuencia.

2. Sistema operativos multiprocesador.

2.1. Concepto y arquitectura de un sistema operativo multiprocesador.

Tienen varios procesadores y una memoria. El SO común gestiona la memoria entre los procesadores.
Tienen mayor productividad ya que pueden hacer más tareas en menor tiempo, mayor velocidad de aplicación y menor
tiempo de espera de los procesos.
Los primeros funcionaban en modo asimétrico: un procesador controlaba al resto, cuellos de botella.

Ventajas:

 Rendimiento y potencia de cálculo. El hecho de tener varios procesadores trabajando a la vez aumenta la
productividad de la máquina, incrementando el número de procesos capaz de soportar a la vez.
 Tolerancia a fallos. Al contar con varios procesadores, si uno falla se puede seguir contando con el resto, lo
que no provocaría una parada de todo el sistema.
 Flexibilidad. El sistema puede hacer un reparto de carga equilibrada entre todos los procesadores de los que
dispone, por lo que el nivel de saturación entre todos ellos debe estar repartido.
 Coste / Rendimiento. Varios procesadores de menores características más barato que uno potente.

Pág. 5 de 50
 2.1.1. Clasificación.

Modo asimétrico. Funcionan en modo maestro-esclavo, el procesador maestro gestiona y distribuye la carga de
trabajo de los procesadores esclavos. No se usa

A nivel lógico se usa en los sistemas que tiene procesadores especializados, e/s, video.
 Gestión sencilla.
 Cada vez que acaba una tarea interrumpe al maestro y esto genera cuellos de botella.
 Fallo en el maestro es muy grave.

Modo simétrico. Todos son similares.

Cada procesador accede a toda la RAM con el mismo nivel de prioridad
Cada procesador reparte tareas entre el resto
Todos pueden cooperar en un misma tarea.
También se producen colas.
Mayor tolerancia si un procesador falla.

Clasificación según el modo de ejecución de las instrucciones.

SISD (Single Instruction Stream, Single Data Stream) un procesador procesa secuencialmente instrucciones, y cada
instrucción lleva un dato asociado. Son los sistemas menos efectivos.
SIMD (Single Instruction Stream, Multiple Data Stream), el procesador ejecuta una instrucción que puede llevar
asociada varios datos.
Es útil cuando los programas pueden dividir los datos en unidades de procesamiento.
Los programas deben de estar preparados específicamente: compilador de fortran

MISD (Multiple Instruction stream, Single Data stream) tienen como ventaja fundamental la tolerancia a los fallos.
La redundancia de varias unidades de proceso trabajando sobre los mismos datos aumenta la fiabilidad del sistema.
Son más caros sin mejora proporcional del rendimiento.
MIMD (Multiple Instruction stream, Multiple Data stream) son los más utilizados en equipos multiprocesador.
Hilos de ejecución que se asocian a los procesadore
 Modelos fuertemente acoplados: en este modelo de conexión los procesadores comparten memoria entre
si. Dentro del tipo de acceso a memoria, existen dos tipo, UMA o acceso uniforme a memoria, y NUMA o
acceso no uniforme a memoria, donde la velocidad de acceso a distintas zonas de memoria puede ser distinta.
 Modelos débilmente acoplados: en este modelo cada procesador gestiona su propia memoria, teniendo
como norma el acceso no remoto a memoria (siendo local).

Pág. 6 de 50
 2.1.2. Interconexión de los procesadores.

Conexión con bus compartido. Todos los procesadores conectados a un

mismo bus. Dependientes de la velocidad del bus. No es lo más eficiente.
Cuellos de botella.

Sistema de barras cruzadas. Todos los procesadores acceden toda la

memoria. Costosa n2 procesadores y compleja.

Conexión mediante hipercubos. Conexión mediante hipercubos Modelo

más complejo que los anteriores donde los procesadores y las
memorias están conectados formando hipercubos. La máxima instancia
entre nodos es log2N, y cada nodo a su vez está conectado con log2N
nodos, de tal manera que cada hipercubo contiene hipercubos de menor
dimensión. Escalable
Conexión mediante conmutadores multietapa. Está formado por log2N
etapas, donde cada etapa consta de un conjunto de N enlaces conectando a
N/2 cajas de intercambio.
Escalable

2.2. Gestión del procesador.

2.2.1. Asignación de procesadores.

Procesador trabajando como gestor. Gestiona el estado y la actividad de otros. Jerarquía de niveles.
Planificación por oleadas. El gestor recibe oleadas de órdenes que reparte. Si no lo puede repartir lo intenta
ejecutar el si no lo los sube al nivel superior.
Problemas y dificultades. El gestor tiene que saber cuando cada uno queda libre.

2.2.2. Planificación del procesador.

Monoprogramado. Las tareas asignadas son independientes del resto de procesadores.
Multiprogramado. Las tareas se ejecutan en colaboración con otros procesadores. Se necesita sincronización y
estimación

2.2.2.1. Tipos de planificación.

Coplanificación. Planificación coordinada. Tareas afines de varias aplicaciones. Operan ejecutando hilos de varias
aplicaciones.
Compartición de cargas. Igual pero con una cola global de hilos.
Asignación dedicada de procesadores. Más ineficiente. Cada proceso tantos procesadores como hilos.
Planificación dinámica. El más usado. Cambia los hilos de un proceso para ajustar a la carga. Permite explusión de
procesos en curso.

2.2.2.2. Algorítmos de planificación.

Algoritmo de tiempo compartido. Distribución equilibrada de tareas. Estructura de datos.

Algoritmo de espacio compartido. Este algoritmo divide el conjunto de procesadores en grupos que ejecutarán
tareas similares. Para planificarlos se utiliza la coplanificación o planificación coordinada entre procesos para que

Pág. 7 de 50
se ejecuten al mismo tiempo. La planificación de varios hilos relacionados al mismo tiempo sobre múltiples CPU’s
se llama space sharing.
Algoritmo de planificación por grupos. Este algoritmo se encarga de planificar conjuntos de hilos que por su
funcionalidad están relacionados entre si. Se planifican como una sola unidad (lo que se denomina un Gang)

el tiempo se divide en quantums quantums no son una medida estándar de tiempo, depende del sistema

Asignación de Planificación del Tipos de planificación Algorítmos de

procesadores procesador planificación
Gestor Monoprogamado Coplanificación Tiempo compartido
Por oleadas Multiprogramado Compartición de cargas Espacio compartido
Asignación dedicada Por grupos quantum
Planificación dinámica

2.3. Sincronización y gestión de la memoria.

Para acceder a una zona compartida de memoria, se deben ejecutar

tres pasos básicos:
 Bloquear el bus para que las otras CPU’s no puedan acceder a
él (lock).
 Ejecuta la instrucción TSL (Test and Set Lock) para bloquear
el bus.
 Desbloquear el bus.

Cuando un procesador libera la memoria, debe avisar a aquellos

procesos que se hayan quedado esperando para entrar. Este
proceso de espera activa por parte de las CPU’s que no hayan
podido entrar se llama spinning, y es el proceso por el cual un
procesador se encuentra bloqueado (lock) con un trabajo
pendiente para entrar en zona de memoria compartida

2.3.1. Algoritmos de sincronización.

Algoritmo de sincronización a través de átomos. Un átomo se define como un objeto accesible (se puede leer y
escribir) con la propiedad de que sólo puede ser accedido a la vez por un procesador.
Sincronización por cerrojo. Existe un elemento que indica si el átomo está ocupado o está libre, de tal manera que
el proceso que accede al átomo bloquea el cerrojo (o lo cierra), y no lo abre hasta que no ha terminado sus
operaciones en el átomo.
Sincronización optimista. El átomo mantiene dos versiones de la información, una local y otra global. El
proceso que accede al átomo modifica la versión local del mismo. Una vez ha terminado, actualiza la versión global.
El resto de procesos pueden acceder a la versión global del átomo (para leer información). Este método puede
provocar inconsistencia en los datos.
Sincronización por servidor. Se controla el acceso a los átomos de forma centralizada desde un servidor
designado.

Protocolos de espera.
 En la espera ocupada, cuando un proceso no puede acceder a un átomo, el proceso sigue ocupando el
procesador, esperando a que ese átomo que solicita sea liberado. El protocolo de servicio completo aviso a
toso los procesadores que se ha liberado el átomo.
 En la espera suspendida, el procesador ‘echa’ al proceso que no puede acceder al átomo en ese momento,
metiéndolo en una cola de espera. Este método puede generar cuellos de botella si el acceso a los átomos es
muy prolongado por parte de algunos procesos.

Pág. 8 de 50
3. Componentes de un sistema operativo distribuido.
3.1. Introducción.
Modelo de 3 capas.
 Capa de presentación : es aquella capa que recibe o envía los datos y se encarga de mostrarlos. Es la capa
que interactúa con el usuario.
 Capa de negocio: se encarga de la gestión de la información y solicitud de recursos en caso necesario. Puede
estar en la misma máquina que la capa de presentación o distribuida en varias máquinas.
 Capa de datos. Es aquella que se encarga del trasvase de información, tanto de entrada como de salida.

Cuanto más separadas estén estas tres capas en un

sistema, mayor será su grado de distribución, y
mayor la necesidad de cooperación y comunicación
entre las máquinas.

Características:
1. Falta de memoria compartida. Necesidad de muchos mensajes. Solución único servidor de datos o
servidores con replicación.
2. Falta de reloj común. Necesidad de mecanismo de serialización de eventos.
3. Comunicación y sincronización por mensajes. La coordinación y sincronización de procesos se realiza a
través de mensajes.
4. Retardos considerables
5. Estado global del sistema. Imposible conocer.

3.2. Arquitectura cliente servidor.

Una arquitectura se define como cada uno de los niveles apilados en el que cada uno de ellos asignada una tarea
específica.

El cliente solicita un servicio mediante el protocolo de solicitud-respuesta (mediante mensajes), mientras que el
servidor ejecuta el servicio solicitado, devolviendo la respuesta al cliente.

Elementos.
1. Cliente, máquina o proceso que solicita servicios de algún tipo a otra máquina o proceso mediante un
protocolo de comunicaciones.
2. Servidor, es el proceso que ofrece servicios y acepta solicitudes de otros procesos.
3. Servicio, ejecución suministrada por uno o varios servidores.
4. Plataforma, sustrato de hardware, sistema operativo local y comunicaciones.
5. Protocolo de solicitud-respuesta, el cliente envía una solicitud (a través de mensajes), y el servidor ejecuta
el servicio solicitado y devuelve la respuesta (también a través de mensajes).
6. Middleware, es una capa de software que se encarga de enmascarar la heterogeneidad de la plataforma
cliente-servidor, y suministra un entorno de programación. Corresponde a los niveles OSI de presentación y
sesión.

3.2.1. Arquitectura cliente servidor de 3 niveles.

En una arquitectura de tres niveles, el cliente es más ligero que el servidor, ya que soporta menos procesos lógicos

Ventajas

Pág. 9 de 50
 El cliente puede ser una máquina de poca potencia.

El cliente está aislado de las operaciones de red y de base de datos.

Nivel de transparencia alto.

Separación entre interfaz de usuario y lógica de la aplicación

Red de banda estrecha para comunicar clientes y servidor de nivel

medio

Nivel de acceso de datos. Permite que la aplicación pueda acceder a

datos almacenados en distintos gestores de bases de datos.

La lógica de la aplicación. Al no ser dependiente, se puede diseñar

en el lenguaje de programación que más convenga. Las
actualizaciones no se tiene que hacer en todas las máquinas.

3.2.2. Comunicaciones en una arquitectura cliente servidor de 3 niveles.

Una de las formas utilizadas para la comunicación entre clientes y servidores, es a través de sockets
Un socket es un elemento de comunicación entre procesos. Se referencian mediante descriptores.

Los sockets disponen de varios métodos que permiten establecer una conexión estable entre clientes, o
entre cliente servidor: connect, , send (o write), receive o read, y close,

Pág. 10 de 50
 Sockets con TCP (Transmission Control Protocol).
Orientado a conexión

Protocolo previo de conexión durante el proceso.

Transmisión full-duplex bidireccional

Mecanismos de detección de errores.

Pueden controlar caudal y flujo de datos.

Se pueden recuperar paquetes mediante

retransmisión.

Pág. 11 de 50
 Sockets con UDP (User Datagram Protocol) sin
conexión.

Tienen menos complejidad que los implementados

bajo TCP, aunque con notables desventajas.

Una de ellas es que no requieren establecimiento de

conexión. Comunicación uno a uno o uno a varios.

Por otro lado las comunicaciones se realizan a través

de paquetes o datagramas de 64 bytes de longitud,
por lo que ya no existe un flujo continuo de datos.

No hay control de errores ni mensaje de recepción

3.2.3. Difusión de la información.

El método más utilizado para la solicitud de recursos es el broadcast o difusión de mensajes.

Los procesos y máquinas de un sistema distribuido están diferenciados por grupos, de tal manera que un mensaje
broadcast le llegará a todos los miembros de un mismo grupo.

3.2.3.1. Difusión fiable.

La difusión fiable permite mediante la implementación de algún método de control, para que los mensajes lleguen a
sus destinatarios. Para ello se deben cumplir tres propiedades básicas:

1. Que todos los procesos involucrados reciban el mismo mensaje

2. Que todos los mensajes que se difunden a los procesos involucrados, son entregados
3. Que los mensajes erróneos, no son entregados, o son rechazados.

En algunos casos se necesita controlar además el orden de entrega de los mensajes, por lo que la difusión necesita
mecanismos adicionales de control.

Además en estos procesos se debe controlar el flujo de los mensajes para que no se inunde la red (número de
retransmisiones), así como el tamaño máximo de mensaje (fragmentando los mensajes en el caso de que fuera
necesario).

Difusión FIFO (First In, First Out). P es el proceso que difunde un mensaje m (cada mensaje consta de dos
campos, el emisor, y el número de secuencia del mensaje). Se deben cumplir:
 Si un proceso P, difunde un mensaje m, todos los procesos relacionados con p entregarán el mensaje m.
 Para cualquier mensaje m, cada proceso debe entregarlo una vez como máximo, y sólo si algunos procesos
difunden m, es decir, que debe entregar el mensaje si otros procesos a su vez hacen lo mismo.
 Se debe respetar el orden de envío, de tal manera que cada mensaje está dentro de un contexto, fuera del cual
pierde su sentido (tiene que llegar antes que su predecesor para que tenga sentido).
 Los mensajes pueden no ser entregados a un proceso si no conoce su contexto, de tal manera que si un proceso
difunde m antes que un mensaje m’ , entonces los procesos encargados de difundir esos mensajes no
entregarán m’ antes que m (aunque llegue antes, porque no están dentro del orden correcto).

Difusión Casual. Es una ampliación del modelo FIFO, y se produce cuando un mensaje depende de los entregados
anteriormente. Este algoritmo asegura que un mensaje no sea entregado hasta que los mensajes que dependen de él
hayan sido entregados.
 Se debe establecer un orden causal; si la difusión de m, precede causalmente a la difusión de m’, entonces
los procesos no deben entregar m’ hasta entregar antes m.
 Cada ejecución de una entrega (broadcast (m), por ejemplo), se llama evento.
 Si se tienen dos mensajes, m1 y m2, donde m1m2, se deben establecer cuatro principios para su entrega:

o Orden FIFO: Un proceso Pi debe difundir el mensaje m1 antes que m2 (respetando el orden establecido m1m2).
o Orden local: un proceso P i, recibe un mensaje (m1 en este caso), y difunde otro (m2), por este orden de
ejecución.
o Transitividad: puede existir un mensaje m3, tal que m1m3, y m3m2 (por este orden).
o Orden causal: si un proceso Pi, recibe un mensaje m2, entonces ese mismo proceso Pi debe haber recibido antes
Pág. 12 de 50
 m1 (m1m2), o de lo contrario no podrá difundir m2.

Difusión Atómica. Mediante este algoritmo, se garantiza que o reciben todos los procesos el mismo mensaje, o
ninguno. Garantiza que todos los procesos tengan la misma perspectiva del sistema. Es un método de difusión fiable
que debe satisfacer un orden total: Es decir, si dos procesos p y q tienen que entregar dos mensajes, m1 y m2,
entonces p entregará m1 antes que m2 si y sólo si q entrega m1 antes que m2.

Difusión limitada por tiempo. Procesos requieren que la entrega en un tiempo limitado de tiempo (caducidad de
los mensajes). Esta propiedad se denomina µTimeless, y puede ser utilizada teniendo en cuenta el tiempo real o el
local.
 Para el tiempo real, existe una constante µ, tal que los procesos no van a entregar un mensaje m si se ha
sobrepasado un tiempo t+µ
 Para el tiempo local, se tiene en cuenta el reloj del sistema, de tal manera que un proceso P, no entrega un
mensaje m si según su reloj ha transcurrido un tiempo local mayor al tiempo indicado en el mensaje (ts(m)),
más la constante establecida µ, es decir, si el tiempo ts(m)+ µ se ha sobrepasado.

3.2.4. Modelo de comunicación en un mismo grupo.

Un grupo se define como un conjunto de procesos que participan juntos en alguna actividad, o que de alguna manera
lógica y física están interconectados.

Existen dos tipos de grupos,:

 Los grupos cerrados se usan para procesamiento en paralelo, y una vez definidos los componentes del grupo,
sólo los miembros del grupo pueden comunicarse entre sí.
 En los grupos abiertos, el envío de mensajes es más libre. Cualquier proceso del sistema puede enviar un
mensaje a cualquier grupo.
También se pueden clasificar por la importancia
 De compañeros, donde todos los procesos tienen la misma importancia y no hay uno que lleve el control de
las comunicaciones.
 Jerárquicos, donde un proceso asume el control de las transmisiones

Debe haber un servidor encargado de gestionar el grupo de comunicación

Cada vez que un miembro se incorpora a un grupo, debe mandar un mensaje al resto, para que en las futuras
difusiones se le tenga en cuenta, y vice-versa, si un miembro decide salir del grupo, debe mandar otro mensaje al
resto donde comunique su baja.
Cuando un proceso falle y sea imposible establecer comunicación con él, el resto de procesos deben descubrir este
hecho experimentalmente
3.3. Funciones en arquitecturas distribuidas.

Pág. 13 de 50
 3.3.1. SERVICIO DE NOMBRES
Se necesita un nombre genérico, que mediante un servidor de nombres o DNS (Domain Name System), permita
establecer una conexión entre el nombre y el servicio o recurso buscado.

Son máquinas que contienen bases de datos distribuidas sobre los recursos y servicios del sistema. Se gestiona de
forma descentralizada, de forma que suelen existir varios servidores de nombres con la misma información
(dependiendo del tamaño del sistema).

El fallo en los servidores es crítico por eso los servidores están replicados.

El cliente accede al servidor de nombres con el ‘alias’ del recurso que necesita, y el servidor de nombres devuelve el
identificador del nodo junto con la dirección IP del nodo.

En general un servidor DNS debe proporcional los siguientes servicios:

 Resolución de nombres: transformación de nombres o ‘alias’ en direcciones IP para localizar un recurso.
 Resolución de direcciones: proceso inverso al anterior, conversión de direcciones IP en nombres o alias
correspondientes.
 Generación de alias de recursos o de sistemas finales (también llamado nombre canónico CNAME).
 Registro de nombres de servidores de correo electrónico junto con sus preferencias.
 Distribución de carga entre servidores DNS replicados, y gestión de las políticas de actualización (cada
cuanto tiempo se actualizan las bases de datos jerárquicas).
El dominio de nombres está dividido en
subdominios.
Dentro de la jerarquía de dominios, los
dominios de nivel superior (TDL o Top Level
Domains), son aquellos que no están asociados
a ninguna zona geográfica en particular, como
.com, .net, .edu, .gov, .org, etc.

3.3.2. Migración de procesos.

La migración de procesos se produce cuando se traslada un proceso entero, o parte de él, de una máquina
a otra.
El balanceo de carga mejora el rendimiento.
Migración de aplicaciones.
 Agrupar procesos que interactúan entre ellos.
 Agrupar procesos de larga duración.
 Procesos con capacidades especiales.
Ventajas: Desventajas.
Balanceo de carga Entorno de ejecución complejo
Incremento de la tolerancia a fallos Tamaño del programa
Mejora en el rendimiento Referencias
Optimiza el uso de los recursos

En la transferencia completa, se transfiere el proceso completo junto con su espacio de direcciones, es decir, no se
deja ni rastro del proceso. En ocasiones si el espacio de direcciones es muy grande, y el proceso sólo necesita una
parte de él, este tipo de transferencia puede ser excesivamente costosa.

Por otro lado se puede hacer una transferencia parcial, donde se transfieren sólo las partes de la memoria principal
que hayan sido modificadas (el resto de bloques adicionales del espacio de direcciones será transferido bajo demanda).

Desde este punto de vista se pueden hacer dos tipos de transferencias.

 Por un lado se puede hacer lo que se llama copia por referencia, donde se transfieren sólo las páginas de
memoria cuando se las referencia (el coste inicial es mucho más bajo, aunque a largo plazo puede resultar
costoso).
 El otro tipo de transferencia es el volcado (o flushing), donde se eliminan las páginas de la memoria principal,
Pág. 14 de 50
 volcando en disco las páginas modificadas. De esta forma se libera de tener todas las páginas del proceso que
migra en la memoria principal.

3.3.3. Ejecución remota de procesos.

Birrel y Nelson, permitir a los procesos que llamen a otros procedimientos localizados en otras máquinas. Es decir,
cuando un proceso de una máquina ‘A’, llama a un proceso de la máquina ‘B’, la ejecución en la máquina ‘a’ se
suspende y se continúa en la máquina ‘b’ hasta que finalice.

Este proceso se lleva a cabo en numerosas aplicaciones, en concreto para realizar una llamada a un procedimiento
remoto, el cliente debe ejecutar formalmente la llamada al servidor que va a continuar con la ejecución. En esa llamada,
se empaquetan los argumentos en un mensaje y se envía al otro proceso. Una vez realizado, se queda a la espera del
resultado para poder continuar con la ejecución de ese proceso.

Por otro lado, el servidor recibe un mensaje con los argumentos, que los utiliza para llamar a la función indicada
dentro del servidor. El resultado de esa función, se vuelve a empaquetar en un mensaje y se envía al cliente.

Pág. 15 de 50
 4. Servicios de tiempo.
4.1. El tiempo en los sistemas operativos distribuidos.
Existen varios tipos de sincronización de relojes:

 En la sincronización externa, se debe sincronizar cada máquina con una fuente externa que marque el tiempo
exacto para todo el sistema.
 La sincronización interna, donde los ordenadores están sincronizados entre sí con una margen de error que
permite establecer el orden en el que ocurren los eventos

Los relojes físicos utilizan marcas de tiempo en el sistema, y es vital la sincronización entre ellos con unos
márgenes aceptables de error.

Los relojes lógicos consideran el orden en el que ocurren los eventos en términos de ‘antes/después’ para estimar un
orden en todo el sistema.

4.2. Sistemas basados en relojes físicos.

Los relojes físicos de los ordenadores tienen limitaciones en la resolución, lo que general una imprecisión o deriva
(drift). Para contrarrestarlas, se puede optar por tres opciones:

 Transmisión desde UTC (tiempo universal coordinado).

 Tiempo atómico. Se define un segundo como el tiempo en el que un átomo de Cesio hace 9.192.631.770
transiciones.
 Algorítmos implementados mediante software.

Cristian Berckeley Protocolo tiempo Red

Sincronizacion con UTC Tiempo medio entre máquina WAN
Mensajes S a P incremento (T1-T0-I)/2 Mensajes para ajustes incrementar o Sincronizacion UTC
retrasar (avanzar lentamente) Jerárquico
Mensajes UDP
- Multicast
- Procedimiento
- Interactuando

Problemas del servidor

Seguridad – servidor falso
Relojes lógicos
Tipos: Vectoriales, Escalares, Matriciales
Tipos de eventos. Eventos internos, eventos de envío, eventos de recepción.
Lamport Vectoriales Mattern y Fidge BBS Birman Schiper Stepheson
Cada proceso su reloj, +1 por evento Vector con reloj lógico de cada proceso Basado en Fidge con técnicas de
Mensaje + tiempo Cada evento +1 en proceso multidifusión
Receptor ajusta reloj al máximo y +1 Mensajes externos actualizan vector
Implementación: sincronizada y no El remitente entrega el mensaje
sincronizada Resuelve problemas de Lamport cuando haya recibido
Ventajas correctamente los anteriores
Fácil de implementar
Consigue ordenamiento Cada mensaje con el vector de
Penalización alto número de mensajes procesos
Desventajas
Relojes poco fiables
Dificultad en sistemas grandes
Matriciales
Matriz de vectores
Mejor reflejan el estado del sistema
Matriz n filas nº de procesos y n columnas son
los eventos
Pág. 16 de 50
Sobrecarga sistema
Más utilizados
Implementación compleja

Relojes lógicos
Conocer orden parcial de sucesión de eventos
Detectar rupturas de orden
Conocer estado del sistema a nivel global

4.2.1. ALGORITMO DE CRISTIAN

Se basa en implantar un servidor (S) que se encarga de actualizar el tiempo en el resto de máquinas
mediante UTC.
1. En primer lugar, un proceso o máquina P, solicita el tiempo a un servidor S, mediante un mensaje Mp.
2. S devuelve la respuesta a P incluyendo el tiempo t en el mensaje de respuesta Ms.
3. Al recibir el mensaje, P ajusta su tiempo añadiendo el tiempo transcurrido entre el envío y la recepción
(tiempo de transferencia o Ttrans), mediante la fórmula: Reloj= t+ Ttrans.

De esta manera, el valor que se envía desde el servidor S a P se debe incrementar en (T1-T0-I) / 2 para que pueda
ser una estimación más realista.

Problemas:
El sistema puede estar muy centralizado en un servidor que transmite el tiempo a los demás. Si dicho servidor se
colapsa o se cae, se crea un problema de sincronización en la red. Para solucionarlo se requerirán varios servidores
que lleven a cabo esta función, con la correspondiente coordinación de tiempo entre ellos.
Si por casualidad se infiltrara un servidor S falso en el sistema, podría producir unos daños bastante grandes, sobre
todo en sistemas que manejen aplicaciones bancarias. Para solucionarlo se necesitan procesos de autenticación del
servidor, lo que aumenta el tiempo de sincronización.

4.2.2. ALGORITMO DE BERKELEY

Existe un servidor de tiempo que hace un muestreo periódico de todas las máquinas involucradas en el sistema. Una
vez reunidos todos los mensajes, calcula el tiempo medio de entre todas y transmite la orden de retroceder (avanzar
más lentamente) o adelantar los relojes.

4.2.3. PROTOCOLO DE TIEMPO DE RED

Los protocolos de tiempo de red se aplican cuando la latencia de los mensajes es variable y puede ser muy
alta. Se utilizan en redes grandes (WAN), o a través de Internet.

El modelo que se propone para llevar este protocolo a cabo es un modelo jerárquico de servidores a
diferentes niveles.

Existiendo tres formas posibles de comunicación entre ellos a través de datagramas UDP:

Pág. 17 de 50
Mediante multicast: es el método menos empleado debido a su baja eficiencia y precisión ya que en parte se satura
la red de mensajes de manera periódica. Sin embargo es el más fácil de implementar, ya que asegura que la información
llega a todos los equipos conectados, y por tanto al servidor interesado.
Utilizando una llamada a un procedimiento: tiene una precisión mejor que el método multicast. Consiste en
realizar un promedio del retardo de transmisión (de manera similar al algoritmo de Cristian).
Interactuando entre ellos: los dos servidores intercambian mensajes entre ellos para ajustar sus relojes. Es el más
eficiente. es el más fiable

4.3. Sistemas basado en relojes lógicos.

Permite conocer el orden o serialización en el que ocurren los eventos, independientemente de la hora en la que
tuvieron lugar.
Para la implementación de relojes lógicos dentro de un sistema distribuido se deben definir las estructuras de datos
que los van a soportar.
Existen tres tipos de relojes lógicos fundamentalmente gestionados por algoritmos distintos:
 Relojes vectoriales: gestionados por el algoritmo de Fidge.
 Relojes escalares: gestionados por el algoritmo de Lamport.
 Relojes matriciales.

En un sistema distribuido existen tres elementos a tener en cuenta.

 Los procesos que necesitan un control y una gestión por parte del sistema (por acceder a una zona común o
por otros motivos), estos procesos no se crean todos a la vez, sino que aparecen y desaparecen según su
funcionalidad (se crean nuevos y se destruyen según pasa el tiempo).
 Los mensajes entre procesos o sistema de comunicaciones. Es fundamental que este sistema tenga constancia
de los procesos activos en un momento determinado en el sistema.
 Los eventos que originan cambios en los procesos y en el sistema. Pueden ser:
o Eventos internos que sólo afectan al proceso, y no requieren acciones externas.
o Eventos de envío, en los que un proceso se comunica con otro proceso para solicitar algún recurso o información.
o Eventos de recepción, en los que un proceso recibe un mensaje de otro proceso solicitando algún tipo de servicio o recurso.

4.3.1. ALGORITMO DE LAMPORT

Este algoritmo trata de actualizar a nivel lógico los relojes del resto de procesos para que exista una serialización de
eventos entre todos ellos.
Cada vez que un proceso envía un mensaje, adjunta el valor del reloj dentro del propio mensaje para que el proceso
destinatario sepa el valor de su reloj lógico y sincronice así el suyo

Dentro del algoritmo de Lamport, existen dos tipos de implementaciones, la sincronizada y la no sincronizada

En la implementación no sincronizada, cada proceso En la implementación sincronizada, los procesos

avanza su reloj de manera independiente ajustan los relojes en función a los valores recibidos
por otros procesos (aumentando en uno el valor del
mensaje).

Ventajas Desventaja
Pág. 18 de 50
 Es un algoritmo fácil de implementar y programar.
Consigue un ordenamiento de eventos, aunque para ello los
procesos deben estar comunicados de manera frecuente.
Tiene una ligera penalización por el alto número de mensajes
intercambiados entre los procesos
Los relojes no son muy fiables, ya que son meros contadores,
sin registrar (mediante marcas de tiempo o timestamps) el
momento concreto en el que ha surgido el evento.
Es muy difícil contemplar bien la causalidad entre eventos en
un sistema mediano-grandes

4.3.2. RELOJES VECTORIALES DE MATTERN Y DE FIDGE

Soluciona el problema de la causalidad de eventos en relación con la sucesión de los mismos.

Para registrar los eventos de cada proceso, se genera un vector que contiene el reloj lógico de cada proceso, de tal
manera que un reloj lógico situado en una máquina i, con k procesos, inicialmente estará a cero (V i[k]=0). Si el
proceso i genera un evento, actualizará sólo su posición dentro del vector (sumando uno, como en el algoritmo de
Lamport), de tal manera que quedaría Vi[i]= Vi[i]+1.

4.3.3. PROTOCOLO BSS (BIRMAN, SCHIPER, STEPHENSON)

Este protocolo se basa en el anterior, solo que utiliza técnicas de multidifusión para mantener actualizado el sistema
y enviar sus mensajes.

El remitente del mensaje, entrega los mensajes al resto de procesos siempre y cuando hayan recibido
correctamente los mensajes anteriores. En caso contrario almacena los mensajes en un buffer, hasta que
llegados un número determinado, vacía el buffer y elimina el proceso de la lista de distribución.
Los mensajes se almacenan de forma ordenada.
En cada mensaje que se envía se adjunta el vector de procesos con los eventos actualizados

4.3.4. RELOJES MATRICIALES

Los relojes lógicos matriciales son los que mejor reflejan el estado del sistema a nivel global.
Cada nodo posee una matriz de vectores de tiempo que reflejan un posible estado del sistema

Pág. 19 de 50
5. Sincronización distribuida.

Pág. 20 de 50
 Ventajas Desventaja
Matón El algoritmo se inicia en el momento en el que se inicializa el sistema, o si un proceso percibe que el coordinador está inactivo. Fácil Latencia red
Cada proceso un Id que va en el mensaje. El mayor ID es el de mayor prioridad. implementar (varios líderes o
Mensajes entre procesos para negociar coordinador con el id más mayor. Mensaje de elección de coordinador varios anillos)
Elección Comunicación fiable. Pérdida de
y Solo se puede llevar a cabo si cada proceso conoce el ID y direcciones de todos los procesos mensajes con Caída máquinas
cooperación Anillo Cuando no hay coordinador se crea un anillo lógico y se pasa testigo con el ID, si el testigo menor su ID pasa testigo, si no pone su ID, si es retrasmisiones dos coordinadores
igual ejecuta es el coordinador. El coordinador es el de mayor ID de proceso. Si nodo no responde mensaje al siguiente o varios anillos
Un proceso Menos mensajes
principal asume Procesos de elección más rápido y menos mensajes que matón.
el control Invitación Grupo de procesos con un líder conocido. Pretende resolver los inconvenientes
Se pueden agregar grupos, cuando se fusionan el que ha iniciado la comunicación es el nuevo líder de los anteriores.
Si no hay líder el proceso se declara líder y crea su grupo e invita a otros si aceptan se fusionan los grupos
Puntos a tener en cuenta Ancho de banda Retardo cliente Retardo Tolerancia fallos Ventajas Desventaja
Sincronización de procesos. sincronización
Exclusión mutua Nodo central gestiona Reducido 2 Si libre dos Retardo 2 Si fallo en nodo Sencillo Nodo central
Algoritmos de exclusión centralizada acceso a sección crítica y mensajes mensajes si no mensajes. central grave. Pocos mensajes crítico
muta (acceso a sección cola de procesos. Recibe espera en cola Cuando un sale Los retrasos y Poco eficiente en
crítica). peticiones y procesa o de sección pérdidas de sistemas grandes
encola crítica envía mensajes
Condiciones: mensaje salida y retransmisiones
 Espera limitada OK
 Progreso Testigo Anillo lógico con testigo Si se pierde testigo No orden No aplicable en
 Serialización El que tiene el testigo entra generar hay proceso procesos FIFO. sistemas grandes
en sección crítica se ejecuta de consulta para El orden lo por el retraso en
Problemas: Cuando finaliza pasa testigo generar uno nuevo indica el anillo testigo
 Sincronización reloj Ricart y Agrawala Más usado en redes grandes Muchos mensajes Demora por Si compiten Demoras cada Usado en Sobrecarga
 Comunicaciones Consenso y reloj lógico. n-1 petición retardo en tienen n-2 proceso es punto sistemas mensajes en red
Envío mensaje a todos con n-1 aceptación confirmación mensajes si no crítico grandes
Criterios tiempo y sección crítica a cliente un mensaje
 Tamaño de la red usar. Salida tantos
 Proceso sección crítica Cuando todos responde ok mensajes como
se ejecuta. Si uno no procesos
Consideraciones responde OK esperando
 Ancho de banda Lamport Cada proceso lista con todas Muchos mensajes Retardo elevado Cada proceso punto Sistemas Coste alto
 Retardo entere clientes las peticiones 3*n por petición Esperar y hay fallo. Si un cae se grandes no hay comunicaciones
 Sincronización entre Mensajes a todos los muchos mensajes detecta fácil esperas
clientes procesos (si mismo) con Salida mensajes limitadas
 Tolerancia a fallos sección y marca de tiempo. con marca de
Cuando recibe ack el de tiempo a todos
Son algoritmos menor tiempo ejecuta los procesos
 Centralizados Maekawa Votación Menos mensajes Algoritmos
 Distribuidos Quien tiene mitad más uno adicionales para
 Marcas de tiempo entra en sección crítica. desempates
 Descentralizados Descentralizado Tablas hash objetos Disminuyen los Depende de la Pude haber Hay varios Grandes Más complejo
coordinador y sistema de mensajes salvo saturación de la bloqueos y coordinadores sistemas
votación que un proceso no red esperas menos crítico
entre en sección indefinidas
crítica

Pág. 21 de 50
5.1. La sincronización en los sistemas distribuidos
Los procesos tienen que estar coordinados para no tener problemas cuando se accede la sección crítica denotando
sección crítica como aquella parte, ya sean recursos o datos, que es compartida por varios procesos.

Se soluciona con algoritmos de exclusión mutua y de dotación de privilegios a los procesos. Tipos de algoritmos:

Algoritmos de elección, se deben llevar a cabo cada vez que se requiera un coordinador que lleve la gestión y
control de la zona compartida entre recursos.
Algoritmos de cooperación, son algoritmos en los que se requiere la cooperación de máquinas para gestionar el
resto de procesos y compartir recursos. Suelen utilizarse en sistemas de gran tamaño donde se requiere un esfuerzo
compartido.
Algoritmos de sincronización, donde se serializa el acceso a la zona compartida por parte de los procesos y se
garantiza el acceso equitativo de todos ellos

La elección depende del tamaño y del número de procesos.

5.2. Algorítmos de elección y cooperación.

Cuando se requiere proceso principal que asuma el control.
 Debe rotar y tener en cuenta el caso de fallo
 La elección es única y en ella participan todos los procesos.
 Si el coordinador falla se elige otro.
 Se usan en redes locales.

5.2.1. Algoritmo del matón.

Este algoritmo se inicia en el momento en el que se inicializa el sistema, o si un proceso percibe que el coordinador
está inactivo, por lo que se debe elegir uno nuevo.
El coordinador es el id más alto.
Cada proceso tiene un id que va en los mensajes el coordinador es el de número mas alto.
Por otro lado, si un proceso recibe un mensaje de elección, debe:
 Enviar un mensaje de OK al proceso que le ha enviado el mensaje.
 Enviar un mensaje de elección a aquellos procesos que tengan ID mayor que el suyo.
De esta forma, se repite el proceso

En este algoritmo, se debe asumir que la comunicación es fiable, ya que puede fallar durante el proceso de elección.
Solo se puede llevar a cabo cuando cada proceso conoce su id y el del resto de procesos.

5.2.2. Algoritmo del anillo.

El algoritmo del anillo agiliza el proceso de elección y reduce el número de mensajes en algunos casos en
comparación con el algoritmo del matón.

Cuando un proceso descubre que no existe coordinador, se crea un anillo lógico, y se va pasando un mensaje (token
o testigo) entre los procesos.
 Si un proceso recibe el token y su ID es menor que el que ha recibido, envía el token al siguiente proceso en el anillo sin
modificar.
 Por el contrario si el ID recibido es menor que el del proceso, éste incluirá su ID en el token.
 En el caso en el que un proceso reciba un token con ID igual al suyo, no retransmitirá más el testigo y se declarará como
coordinador (significará que el testigo ya ha dado una vuelta y que el mayor ID en el anillo es el suyo).
Si un proceso está caído, se enviará al siguiente en el anillo lógico.

Tanto el algoritmo del matón, como el del anillo tienen la ventaja de que ambos son fáciles de implementar, pero
tienen dos desventajas comunes.
 Por un lado, al depender de los retrasos de la red, puede provocar que se elijan varios líderes si existe una
latencia considerable dentro de la red.
 La caída de una o varias máquinas puede aislar y formar conjuntos individuales de procesos que arranquen
los procesos de elección por separado y elijan coordinadores independientes.

Pág. 22 de 50
 5.2.3. ALGORITMO DE INVITACIÓN.

Se definen conjuntos de procesos con un único líder conocido. Cada grupo está perfectamente delimitado, y se
pueden producir agregaciones de grupos entre sí (por proximidad, por afinidad, o por pérdida de elementos del
grupo).

5.3. Algoritmos de sincronización.

La sincronización de procesos se produce cuando varios procesos intentan acceder a una sección crítica. Es decir,
ejecutan la parte de código que requiere de algún elemento compartido para su ejecución, por lo que deben
consensuar la utilización con el resto de procesos.
La serialización entre procesos no puede ser controlada a través de semáforos, y se basa en la compartición y
utilización de una zona de memoria común.

Los algoritmos que controlan el acceso a la sección crítica, se denominan de exclusión mutua, y deben garantizar:
 Espera limitada: si un proceso quiere acceder a una sección crítica, debe poder hacerlo en un tiempo
razonable.
 Progreso: una vez que un procesa salga de la zona crítica, se debe arrancar un mecanismo que permita el
acceso a otro de los procesos que estaban esperando para entrar.
 Serialización: las peticiones deben ser gestionadas en el orden en el que han sido registradas.

puntos a tener en cuenta

Ancho de banda: la cantidad de ancho de banda que consumen los algoritmos de exclusión mutua puede variar
mucho dependiendo del algoritmo. En general se suele consumir de forma continua.
Retardo del cliente: controlar el número de mensajes que requiere la entrada a la sección crítica en función del
algoritmo utilizado. La salida generalmente suele requerir un solo mensaje.
Sincronización entre clientes: controlar que una vez sale un cliente de la sección crítica, entra otro que estaba en
espera. Esta sincronización puede requerir un solo mensaje (si es el propio cliente que sale el que avisa al otro que
quiere entrar), o varios (si se envía un mensaje a todos los procesos avisando de la salida).
Tolerancia a fallos: controlar cuando se cae una de las máquinas, o en un algoritmo se pierde el token que habilita a
los procesos para entrar en la sección crítica. Cada algoritmo debe tener sus mecanismos de control en base al
funcionamiento del mismo.

La elección del algoritmo, al igual que en otros casos depende del tamaño del sistema, y del número de procesos que
comparten una zona crítica.

Los algoritmos más utilizados de exclusión mutua son:

Algoritmos centralizados: en los que un proceso o máquina lleva el control sobre el acceso a la sección crítica.
Algoritmos distribuidos: como el del paso de testigo, donde cada proceso puede acceder a la sección crítica
solamente si tiene el testigo en su poder.
Algoritmos de marcas de tiempo: como el propuesto por Ricart y Agrawala.
Algoritmos descentralizados: en los que los procesos se coordinan entre sí para gestionar el acceso a la sección
crítica.
Pasos comunes.
 El primero es el anuncio de alguno de los procesos de su intención de entrar en la sección crítica.
 El segundo paso es la concesión de entrada a la sección crítica de alguno de los procesos que lo han solicitado.
 Por último, una vez que termina la utilización de un proceso en la sección crítica, se deben actualizar las
colas de espera del resto de procesos que quieran entrar, y se debe comunicar al siguiente proceso que la
sección crítica ya está libre para su utilización.

5.3.1. Exclusión mutua centralizada.

Es el más simple de todos ellos. Existe un nodo que es el que coordina y gestiona el acceso a la zona crítica, por lo
que se encarga de gestionar las peticiones por parte del resto de nodos.

Es bueno, aunque para sistemas grandes no suele ser demasiado eficiente.

Ancho de banda. Consumo reducido.

Retardo del cliente. Mensajes y tiempo de espera si hay
Retardo del sistema. 2 mensajes de salida
Tolerancia a fallos. Si cae el central error grave
Pág. 23 de 50
 5.3.2. Algoritmo del testigo o token.
Se crea anillo lógico con los procesos (anterior, posterior). Se pasa un token, el que lo tiene accede a la sección
crítica cuando finaliza lo envía al siguiente,
Aún así, este algoritmo no garantiza el acceso FIFO, tiene que esperar a que el token de la vuelta.
Por esta razón el algoritmo del testigo no es una buena opción para utilizar en sistemas grandes.
Si se pierde el testigo hay que generar otro.

5.3.3. ALGORITMO DE RICART Y AGRAWALA

Este algoritmo es el más utilizado en sistemas de gran tamaño, no requiere coordinador se basa en el consenso.
Se basa en los relojes lógicos.
Garantiza FIFO pero más mensaje sobrecarga la red.

Se envía mensaje tiempo, y sección y cuando todos responde ok accede .

Ancho de banda. Tráfico elevado.

Retardo del cliente.La entrada a la sección crítica se puede demorar en función de las
respuestas de los clientes. La salida requiere tantos mensajes como procesos haya esperando.
Retardo de sincronización entre clientes.Si dos o más procesos compiten por el acceso a la sección crítica, tendrán
n-2 mensajes. Sólo el de menor reloj lógico logrará tener el consentimiento del otro proceso para entrar (y por tanto
los n-1 mensajes necesarios). Una vez salga de la sección crítica, sólo será necesario un
mensaje para que entre el otro proceso.
Fallos. Cada uno de los procesos pasa a ser un punto crítico dentro del sistema.

5.3.4. ALGORITMO DE LAMPORT

En el algoritmo de Lamport, cada proceso contiene una lista con las peticiones de todos los procesos que quieren
entrar en la sección crítica.
Cada vez que un proceso quiere entrar, envía un mensaje al resto incluyendo su reloj lógico (ordenado mediante el
algoritmo de Lamport).
A diferencia de otros algoritmos, en el de Lamport, el mensaje se autoenvía también al propio proceso que solicita la
petición, para ser encolada en su lista de procesos.

Ancho de banda. 3*n mensajes, siendo n el número de procesos, por lo que el incremento de mensajes dentro de la
red puede llegar a ser considerable.
Retardo del cliente. Tanto la entrada como la salida de la sección crítica requiere un retardo
elevado por el alto número de mensajes. Un proceso puede estimar su entrada en base a los que haya delante de él en
la cola.
Fallos. Existen tantos puntos de fallo como procesos hay en el sistema. La ventaja de que haya tantos envíos de
mensajes es que se puede detectar más rápidamente si un proceso se ha caído, eliminándolo de la lista de procesos.

5.3.5. ALGORITMO DE MAEKAWA.

Es un algoritmo de votación, en el que los procesos deciden cuál es el que entra en la sección crítica

5.3.6. ALGORITMO DESCENTRALIZADO

Se basa en la utilización de tablas hash para el almacenamiento de objetos (réplicas de las secciones críticas a
utilizar). Existe un coordinador que se encarga del acceso a cada réplica

Ancho de banda.Se reduce con respecto a los algoritmos anteriores,

Retardo del cliente. Depende en gran medida del nivel de saturación de la red, lo que puede provocar un menor
rendimiento en el uso del recurso a compartir.
Retardo de sincronización entre clientes. Se pueden producir bloqueos y esperas indefinidas, ya que los procesos
no saben con certeza cuándo van a poder disponer de un recurso, por lo que pueden seguir intentándolo de forma
Pág. 24 de 50
aleatoria numerosas veces hasta conseguir el acceso. Dependiendo de la composición de la red, se pueden provocar
mayor número de retardos, por lo que en ocasiones se requiere la implantación de algoritmos adicionales que
controlen estas situaciones.
Fallos. El fallo de un coordinador no es crítico en este tipo de algoritmos, ya que hay varios coordinadores en el
sistema.

Pág. 25 de 50
6. Sistema de ficheros replicación y base de datos.
6.1. Necesidad de los sistemas de base de datos distribuidos.
Un sistema de bases de datos distribuido es aquel capaz gestionar, organizar, almacenar y buscar la información
residente en diversas máquinas.

Características especiales de sistemas de acceso a grandes base de datos son:

 Concurrencia. Una base de datos puede ser accedida por un número elevado de usuarios a la vez (por
ejemplo la de un banco), por lo que el sistema debe ser capaz de permitir el acceso a todos ellos sin
comprometer la integridad de la información.
 Gestión de grandes volúmenes de datos. El gestionar bases de datos grandes puede ser un problema, sobre
todo a la hora de controlar el almacenamiento y su replicación (control de copias, actualizaciones, etc.).
 Tolerancia a fallos. debe crear un plan de contingencia que tenga previstas las acciones a tomar en caso de
cualquier problema, ya que podría suponer la pérdida de grandes cantidades de dinero dependiendo de la
naturaleza del sistema (la Bolsa por ejemplo, o la caída de la base de datos de un banco).
 Control de transacciones. algoritmos que sean capaces de gestionar correctamente transacciones sin
comprometer la fiabilidad de los datos.

Características especiales a nivel de programación:

 Multiprogramación. Cada usuario debe tener un proceso, incluso puede tener varios, por lo que se debe
contemplar la programación a través de hilos (multi-thread).
 Algoritmos de tiempo compartido. La mala elección de un algoritmo puede provocar errores en la
transacción (un algoritmo como por ejemplo el round robin podría sacar del procesador a un proceso en mitad
de una transacción).
 Control del tiempo. Los algoritmos empleados deben ser capaces de proporcionar respuestas inferiores a
unos pocos segundos (del orden de 5 a 10 segundos como máximo).
 Gestión de la memoria. Se necesita una gestión eficiente de la memoria (con paginación anticipada), ya
que se pueden transferir grandes volúmenes de información.
 Gestión del almacenamiento y sistema de ficheros. Las bases de datos se almacenan como ficheros. Se
debe asignar un gran volumen de espacio en disco que permita el crecimiento del fichero (puede aumentar
en un corto espacio de tiempo). La información debe estar indexada para acelerar el proceso de búsqueda.
 Gestión de fallos. El sistema debe ser capaz de recuperarse ante fallos, y debe ser capaz de saber en qué
punto de una transacción se ha producido el fallo, bien para deshacer las operaciones que se habían ealizado,
o para continuar a partir de un punto dado. Las operaciones terminadas deben poder guardarse en disco (para
llevar un control).

6.2. Sistema de archivos distribuidos.

Los sistemas de archivos o ficheros distribuidos son aquellos en los que los datos se encuentran en varias fuentes de
información. Deben existir al menos tres elementos, servidores, servicios y clientes.

Servidores. Los servidores de ficheros se pueden ejecutar en una o varias máquinas, y son los encargados de
gestionar la información (replicación, copias, integridad de la información, etc.). Dos tipos:

 Servidores con estado. Contienen información acerca del estado sobre el acceso de los clientes. Es más
eficiente que los servidores sin estado.
 Servidores sin estado. El servidor gestiona las solicitudes de los clientes, y elimina la información relativa a
éstos una vez las ha realizado.

Clientes. Son los procesos que realizan peticiones o modificaciones de datos. Dentro de un mismo entorno existirán
varios clientes accediendo a partes comunes de información, por lo que se debe tener especial cuidado con las
operaciones de actualización y borrado de datos, sobre todo si existen réplicas.

Servicios. Es el conjunto de aplicaciones y acciones posibles que el sistema de ficheros pone a disposición de los
clientes, de tal manera que se gestionan a través de un servidor de datos (que es el que invoca a sus propios servicios).

Pág. 26 de 50
 6.2.1. Esquema de nombres.
El esquema de nombres dentro de un sistema distribuido permite la localización de cualquier fichero dentro de la
red. Se debe crear un mapeo multinivel, donde cada fichero esté identificado y localizado sin conocer realmente los
detalles físicos sobre su ubicación.

En un sistema distribuido, existen tres posibles esquemas de nombres:

Combinación del nombre del fichero. Componer el nombre del fichero con un nombre genérico junto con el nodo
en el que se encuentra ubicado. Es dependiente de la ubicación.

Asociación de directorios remotos a locales Este método es el utilizado por SUN en su sistema de archivos en red
NFS (Network File System). El objetivo es asociar directorios remotos con directorios locales, formando es esta
manera un árbol virtual de directorios.

Estructura global. Con este método se logra una integración total de todos los ficheros del sistema (estructura de
nombres global para todo el sistema), aunque es un sistema bastante complejo de implantar.

6.2.2. Acceso a los ficheros.

Un acceso remoto de ficheros es aquel en el que una solicitud de acceso se entrega al servidor, que la procesa mediante
los servicios necesarios, y devuelve los resultados a la aplicación que ha generado la petición.

Para agilizar la transferencia, se suelen dispersar varias cachés (en servidores con los ficheros de mayor acceso o en
los propios clientes) con una copia de los archivos más solicitados, de tal forma que el envío sea lo más rápido posible.

Al mantener los datos en una memoria independiente de la original, se debe controlar la consistencia de los datos
con el fichero original por si han sufrido alguna modificación, por lo que debe realizar alguna de estas dos
alternativas:

Solicitud iniciada por el cliente: es el propio cliente el que realiza una solicitud de coherencia de sus datos con los
del servidor, por lo que comprueba si los ficheros que residen en su caché han sido modificados en la copia
maestra.
Solicitud iniciada por el servidor: es el propio servidor el que controla los ficheros almacenados en cada cliente
para liberar un proceso de actualización en el momento que detecta una inconsistencia.
La caché para este propósito se puede almacenar en disco o en memoria principal.
 La caché sobre el disco es más fiable
 La caché sobre la memoria principal tienen un acceso más rápido

Caché vs acceso remoto

 En general presenta mejores resultados el acceso a caché, ya que es un acceso local a datos. si hay muchas
operaciones de escritura, el método de uso de la caché es mejor
 Una desventaja que presenta el acceso a caché, es que el interfaz de acceso es diferente al que se emplea por
el usuario
 En el caso en el que los nodos no tengan disco, o un tamaño de memoria muy reducido, es mejor utilizar el
acceso remoto.

6.3. Transacciones.

Algunas operaciones que tienen que estar libres de operaciones concurrentes en otros clientes, y se deben realizar
completamente o no deben llevarse a cabo si falla el servidor.

Para que una transacción se pueda llevar a cabo, se necesita un software específico que haga de intermediario y
controle la transacción.

Las operaciones en los servidores se deben realizar de forma atómica, o todas o ninguna (bloque de operaciones),
por lo que hay que sincronizar las operaciones del cliente

6.3.1. Mecanismos de control de transacciones.

El acceso no controlado de dos procesos a los mismos datos, puede provocar una inconsistencia de los mismos, por
lo que se debe controlar que mientras un cliente realiza una transacción, el otro se queda a la espera.
Pág. 27 de 50
En los puntos de sincronismo, los datos son coherentes, por lo que se establece uno al comenzar la transacción y otro
al finalizar la transacción para confirmarla (commit). Si durante la transacción se ha producido un fallo, se deben
eliminar todas las operaciones hasta el punto de control anterior con rollback.

Para que las transacciones se puedan efectuar sin problemas, se debe controlar la concurrencia, por lo que se deben
serializar. Problemas relacionados con la serialización de los clientes:

 La pérdida de actualizaciones se producen cuando dos transacciones leen el valor antiguo de una variable
y lo usan para actualizar su valor
 Otro problema son las lecturas falsas, que se producen cuando una transacción lee un valor que está siendo
procesado por otra transacción.

De esta manera, se dice que dos operaciones sobre un mismo objeto son conmutativas,
 si no importa el orden de ejecución, ya que el resultado es el mismo, Así, las operaciones que sólo implican
lectura de datos, no causan conflicto
 son conflictivas o no conmutativas si el orden de las transacciones puede afectar al resultado final. Sin
embargo, las operaciones que llevan asociadas lecturas y escrituras o solamente escrituras son conflictivas

6.3.2. propiedades de las transacciones. ACID

Atomicidad. Esta propiedad garantiza que se realicen todas las operaciones o ninguna, no da lugar a estados
intermedios.
Coherencia. Cuando una transacción termina, debe dejar al sistema en estado estable, o de lo contrario debe volver
al principio de la transacción
Aislamiento. Los datos de una transferencia no deben verse afectados, ni pueden ser vistos por otras transferencias
que se ejecuten concurrentemente, deben comportarse como si actuaran en un sistema aislado monoproceso. Para
garantizar esta propiedad, el gestor del sistema debe serializar los accesos compartidos.
Duración. Después de que la transacción ha terminado correctamente, los resultados son permanentes, por lo que
sus efectos se deben salvar en un medio no volátil (en disco).

6.3.3. Protocolos de concurrencia.

Dentro de los protocolos que controlan la concurrencia a objetos está el bloqueo en dos fases, de tal manera que se
plantea una transacción en dos fases.
 La primera fase es la que se llama de crecimiento, donde se produce el bloqueo de recursos.
 La segunda fase es la de encogimiento, donde se liberan los recursos

Otro protocolo que se utiliza en la serialización de transacciones es el control de concurrencia optimista. En este
algoritmo, las transacciones se ejecutan como si no hubiera concurrencia, de tal manera que cuando termina una
transacción se comparan los datos a los que ha accedido con los accedidos por las transacciones concurrentes.
 Fase de trabajo. Comprende el periodo de tiempo desde el inicio de la transacción hasta su finalización. Se
copian en memoria espacio de trabajo los datos con los que se va a trabajar. Hay tantos espacios de memoria
como transacciones.
 Fase de validación. Se lleva a cabo cuando se termina la transacción, de tal manera que se comparan las
operaciones realizadas con las de otras transacciones en curso para ver si ha habido conflicto. Si ha habido
conflicto, se aborta alguna de las transacciones conflictivas. En caso contrario se confirma la transacción.
 Fase de actualización. Las transacciones validadas que sólo contienen operaciones de lectura, se confirman
automáticamente. El resto de transacciones validadas se confirman cuando loas cambios efectuados se hacen
permanentes. La confirmación puede ser en una fase o dos dependiendo del número de gestores que hayan
intervenido.

6.3.4. Transacciones distribuidas.

Las transacciones que acceden a objetos procesados por varios servidores, se denominan distribuidas. Pueden ser de
tipo OLTP (On Line Transaction Processing), o DTP (Distributed Transaction Processing).

El mayor problema que afecta a las transacciones distribuidas es mantener las propiedades ACID, y controlar la
duración de las transacciones distribuidas para que se lleven a cabo en un tiempo aceptable (si la espera se demora en
varios servidores se puede prolongar demasiado la espera). Así, los fallos que pueden afectar a las propiedades ACID
pueden ser:

Pág. 28 de 50
Fallo de las transacciones: que se produzca un aborto por un bloque mutuo, por fallos de concurrencia, etc. Como
media, en un sistema convencional suelen abortar del orden del 3% de las transacciones.
Fallo del sistema: fallo en algún componente hardware o software, borrado de la memoria principal, o fallo total o
parcial de alguno de los servidores.
Fallo de los dispositivos: que se pierda el contenido de los discos, o que falle el hardware.
Fallo de las comunicaciones: elevada congestión en la red que produzca.

En las transacciones distribuidas, existe un protocolo de confirmación, uno de terminación y uno de recuperación.
 El protocolo de confirmación debe asegurar la atomicidad y la duración de la transacción, de tal manera
que una transacción distribuida debe terminar del mismo modo (abortar o confirmar), en todos los sistemas
en los que se ejecuta.
 El protocolo de terminación es exclusivo de los sistemas distribuidos, y controla la reacción de los demás
sistemas en caso de que uno de ellos falle. Se debe controlar que los sistemas se recuperan sin necesidad de
esperar el rearranque del sistema que ha fallado.
 El protocolo de recuperación marca el proceso de reincorporación de un sistema en caso de fallo. Es decir,
el sistema que ha fallado debe ser independiente, por lo que debe ser capaz de terminar la transacción cuando
se recupere sin recabar información remota.

6.4. Replicación y coherencia.

La replicación de datos es la operación de mantenimiento de copias de datos en varios ordenadores.

 Por un lado la replicación mejora las prestaciones
 aumenta la fiabilidad del sistema

Los datos replicados deben cumplir dos requisitos para que puedan servir como copia de seguridad en un momento
determinado:
 Transparencia en la replicación. El cliente debe ver el conjunto de replicas como un solo objeto lógico, de
tal manera que accede a un único elemento y recibe una sola respuesta.
 Coherencia. Los clientes que utilicen copias diferentes de unos mismos datos deben obtener resultados tanto
si utilizan unas copias, como como si utilizan la original. Para ello se deben consolidar todas las copias.

También se debe establecer quién crea las réplicas, pudiendo ser de tres tipos diferentes:
 Réplica explícita. Es el propio usuario el que se encarga de crear las réplicas de los ficheros. Generalmente
para uso local.
 Réplica retardada. Es el servidor que contiene los datos originales el que se encarga de hacer réplicas en
otros servidores de forma transparente al cliente (cuando el cliente accede a los datos, no sabe si está
accediendo al servidor original o a una copia, no se tiene que preocupar de la ubicación de las réplicas).
 Réplica mediante grupo. Cada vez que se produce alguna instrucción de escritura en los datos originales o
en las réplicas, se intercambian una serie de mensajes con el resto de servidores que posee réplicas de esos
datos para que los mantengan actualizados.

6.4.1. Modelos ce coherencia.

La coherencia se produce cuando un proceso que lee un dato, espera haber leído la última modificación sobre ese
dato.

Coherencia estricta. En los modelos de coherencia estricta, cualquier lectura de un dato X devuelve el valor de la
última escritura de ese valor. Para ello se deben propagar todos los cambios instantáneamente.
 Este método exige un reloj de tiempo absoluto
 puede ser demasiado rígido para entornos demasiado grandes o que estén sometidos a muchos cambios,

Coherencia secuencial. Con este algoritmo, el resultado de cualquier ejecución es el mismo que si las operaciones
de todos los procesos se ejecutaran en una cierta secuencia.

Coherencia causal. En la coherencia causal, todos los procesos deben ver en el mismo orden las escrituras
relacionadas de modo causal (causa y efecto).

Coherencia FIFO. Este método es de los más fáciles de implantar. Se basa en que las escrituras de un único
proceso son vistas por otros procesos en el orden en el que se ejecutan, mientras que las escrituras de varios
procesos pueden ser vistas por otros procesos en cualquier orden.
Pág. 29 de 50
Coherencia débil. En los modelos de coherencia débil, se introduce una variable de sincronización que se encarga
de actualizar las copias locales, de tal manera que en una transacción no importa que el resto de los procesos vean
los accesos a la base de datos por un proceso, lo que importa es el resultado final de la serie de operaciones
ejecutadas.

7. Sistemas operativos de tiempo real.

7.1. Características de los sistema operativos de tiempo real.

Procesos que requieren respuestas correctas en un espacio muy delimitado de tiempo. Para ello deben ser sistemas
predecibles o deterministas donde el componente aleatorio de los algoritmos sea eliminado. Ejemplo MarteOs y
SABRE

Elementos fundamentales.

Memoria. El acceso es crítico en estos sistemas en los que el tiempo es fundamental, por lo que se debe decidir que
procesos van a residir en memoria para agilizar el proceso de ejecución. Se suele gestionar en particiones fijas de
longitud variable, y se suelen eliminar técnicas como la paginación y segmentación, que pueden retrasar en algunos
casos el acceso (recordemos que al ser sistemas deterministas, se deben tener controlados estos mínimos retrasos, por
lo que no pueden ser aleatorios).

Entrada y salida. Los mecanismos de entrada y salida deben ser lo más optimizados posible. Los gestores de
interrupciones deben funcionar de manera rápida y eficiente para agilizar este proceso.

Procesador. El procesador debe controlar la planificación de tareas en función de la prioridad que tengan asignadas.
Se deben controlar los eventos que requieran especial atención para ejecutarlos cuanto antes prioridad apropiativa).
También puede haber distintos modelos de planificación del procesador como por ejemplo de tiempo compartido
(round robin), donde se intercambian los procesos en el procesador por interrupciones del reloj o por eventos, o
métodos de planificación dinámica, donde se estima la duración de ejecución de una tarea antes de llevarla a cabo y
se distribuye la entrada en función de las estimaciones.

Ficheros. El acceso debe ser lo más rápido posible, por lo que se suelen basar en métodos de asignación contigua
(para no perder tiempo en búsquedas de información a lo largo del disco), y en métodos de acceso directo.

Otra característica de estos sistemas es que necesitan unos niveles de seguridad y fiabilidad muy altos
Suelen estar embebidos dentro de otros sistemas

7.1.1. Gestión de tiempo.

Verificaciones de control de tiempo en SO de tiempo real.

 Requisitos. La verificación de requisitos debe controlar que suponiendo un sistema que gestione
correctamente el tiempo y las interrupciones es capaz de satisfacer los niveles de exigencia temporal
planteados. Es decir, que suponiendo que el sistema funciona correctamente, se cumplen los tiempos de
respuesta establecidos.
 Implementación. Se debe controlar y verificar que el conjunto de recursos que componen el sistema
funcionan correctamente para mantener los tiempos de respuesta marcados.

Plazo de ejecución. Como su nombre indica, marca el plazo en el que se debe finalizar la tarea a desarrollar. Pueden
existir dos tipos de plazos de ejecución:
 hard-real-time, la respuesta del sistema se debe realiza obligatoriamente en el tiempo marcado.
 Soft-real-time son igual de exigentes, aunque se puede producir alguna demora aceptable.

Parámetros que se definen.

 Retardo mínimo. Se define como la mínima cantidad de tiempo hasta que comienza la ejecución de una
tarea o aplicación (el tiempo mínimo de espera para ejecutar una aplicación).
 Retardo máximo. Es el tiempo máximo que puede esperar el inicio de la ejecución de una tarea.
Pág. 30 de 50
  Mínimo tiempo de ejecución. Es el tiempo mínimo estimado que debe ocupar la ejecución de una tarea.
 Máximo tiempo de ejecución. Es el tiempo máximo que puede tardar en ejecutarse una tarea, suponiendo
que las condiciones no son del todo favorables.
 Máximo tiempo transcurrido. Es el tiempo límite desde que comienza la ejecución de una tarea hasta que
finaliza.

Parámetros de ejecución. Los parámetros de ejecución permiten establecer el coste y el plazo que cuesta arrancar y
lanzar una aplicación o tarea.

El coste se mide en tiempo, y es la estimación que asigna el planificador a la realización de una tarea. Si en la
ejecución de una tarea, se supera el coste estimado, tomará el control el gestor de eventos asociados.

Control de errores y tolerancia a fallos

 Superar el tiempo máximo asignado. Se debe controlar la diferencia entre el tiempo estimado para una
tarea y la duración real de la misma. Este proceso lo lleva a cabo el sistema operativo, no la aplicación que
lanza la ejecución.
 Colapso del sistema. Se deben implementar mecanismos que controlen las actuaciones en caso de que se
produzca un mayor número de eventos en el sistema de lo que se puede gestionar, por lo que se deberá
controlar la prioridad de cada evento para decidir cuáles son imprescindibles y cuáles no.
 Pérdida o timeout en las comunicaciones. Uno de los recursos que mayores imprevistos puede provocar
son las comunicaciones, por lo que se debe elaborar un plan para decidir qué hacer en caso de fallo, o estudiar
la posibilidad de implantar un sistema de backup dependiendo de la importancia del sistema de control.

7.2. Administración de recursos en un sistema de tiempo real.

Modelo simple Procesos conocidos, limitados e independientes (no bloqueos)

de procesos Estimación pesimista del tiempo ejecución
Condicionada por reloj. Limitado de procesos conocidos parámetros de ejecución
Planificación Round robin ponderado. Orden de llegada con tiempo en función de su relevancia.
procesador Algoritmos de Garantiza nivel de servicio.
planificación EDF. Duración tarea.
Planificación por prioridades. Procesador ocupado LSF Tiempo finalización
RMS inverso al periodo
Asignación Secciones no interrumpibles Entre en sección crítica hasta el final, no bloqueos
de recursos Herencia de prioridad Ajusta prioridad para que el proceso no salga del procesador
Techo de prioridad Tarea entra en procesador si tiene prioridad máxima

7.2.1. Planificación del procesador.

Se define como la gestión y control de una serie de actividades encaminadas a proporcionar una respuesta en el
mínimo tiempo posible. Permiten despachar una tarea en el plazo exigido.

Modelo simple de procesos. El conjunto de procesos se conoce de antemano y es un número fijo y limitado. La
ejecución de estos procesos se desarrolla de manera periódica en un intervalo de tiempo conocido
Los procesos son independientes. No hay bloqueos
estimación del tiempo de ejecución de un proceso, se debe realizar de manera pesimista

Planificador del procesador. La planificación del procesador requiere el control de algunos parámetros que
permita crear un modelo determinista donde se pueda predecir el comportamiento en un momento dado. Se necesita
saber el número de tareas a procesar, la utilización de recursos del sistema, el tiempo de utilización y momento de
liberación, el tiempo que va durar la ejecución de cada tarea y el ciclo de repetición.

7.2.1.1. Algoritmos de planificación.

 Algoritmo de planificación condicionada por el reloj. Se usa cuando existe un número limitado de
procesos.
Se necesita conocer de cada proceso los parámetros de ejecución por adelantado.
Se puede realizar una planificación offline o se puede llevar a cabo en determinados intervalos
regulares de tiempo.
 Algoritmo round robin ponderado. procesa las tareas en el mismo orden de llegada, asignando un tiempo
Pág. 31 de 50
 a cada proceso en función de su relevancia (peso).
Se usa redes de servicios que requieran altas calidades de servicio, este algoritmo es capaz de
garantizarlas, aunque es poco apropiado para sistemas en los que los procesos que tengan
restricciones de precedencia

 Gestión de prioridades. Se distribuye mejor la carga del procesador, ya que nunca se queda inactivo si hay
procesos preparados. Los procesos entran en ejecución en función de su prioridad. Existen tres tipos de
planificación por prioridades:
• Earliest deadline first (EDF).La asignación de prioridades en este método se estima en función de
la duración de cada tarea. Las más cortas tienen una prioridad más alta.
• Least slack time first(LSF). Este algoritmo selecciona primero aquellos procesos que tienen un
menor tiempo de slack, definiéndose como el tiempo máximo de finalización de la tarea (deadline)
menos el tiempo de ejecución.
• Rate Monitoring Scheduling (RMS). Este método asigna la prioridad de las tareas en función a su
periodicidad. La asignación de prioridades es inversamente proporcional al periodo, por lo que una
tarea que se repita en intervalos muy cortos de tiempo tendrá una prioridad alta, mientras que otra
que tarde más en ejecutarse, tendrá una prioridad más baja.

7.2.2. Asignación de recursos.

Gestiona el acceso a zonas compartidas y se deben minimizar los bloqueos en la medida de lo posible.

7.2.2.1. Secciones críticas no interrumpibles.

En este algoritmo, cuando una tarea accede a un recurso y lo bloquea, pasa a tener la máxima prioridad, por lo la
utilización pasa a estar ininterrumpida y no la puede ser extraída del procesador por otras tareas. Evita bloqueos pero
no inversión de prioridades

7.2.2.2. Protocolo de herencia de prioridad.

Este protocolo evita que un proceso salga del procesador mientras está utilizando un recurso ajustando
dinámicamente la prioridad del proceso que está utilizando el recurso. Retraso en la finalización.

7.2.2.3. Protocolo de techo de prioridad.

En este protocolo, al igual que en el anterior, la prioridad de una tarea es dinámica, de tal manera que primero se
calcula la máxima prioridad que puede acceder a un recurso (la tarea que tiene máxima prioridad para acceso a ese
recurso aunque en ese momento no lo solicite).

7.3. Sistemas operativos comerciales en tiempo real.

7.3.1. Posix.
Este sistema está basado en UNIX, y su nombre significa Portable Operating System Interface for Unix. Ha sido
estandarizado por el IEEE con el nombre 1003 o ISO/IEC 9945.

Se puede gestionar la asignación de prioridades de las tareas dinámicamente, implementando el algoritmo de

herencia de prioridades y el algoritmo de techo de prioridad.

Dentro de esta asignación de prioridades, existen cuatro políticas que deben soportar un rango mínimo de
prioridades (por ejemplo se deben soportar 32 niveles de prioridad como mínimo en las políticas FIFO y round
robin):
• FIFO (First In First Out). Con esta política, cada hilo se ejecuta hasta que se termine o hasta que se bloquee por
otro hilo.
• Round robin. Un hilo se ejecuta hasta que termine, se bloquee, o finalice su tiempo asignado (quantum).
Servidor esporádico. En esta política, un hilo se ejecuta como un servidor esporádico, que es aquel que destina una
cantidad limitada de CPU a la gestión de eventos.
Otras políticas. En función del sistema donde se esté ejecutando, se pueden llevar a cabo otras políticas de
planificación y asignación de prioridades.

Pág. 32 de 50
 7.3.2. Real time java.
y APIs de tal manera que permite la emulación de un sistema de tiempo real.

Las entidades RealTimeThreads(), o AsynEventHandler(), son las que controlan los parámetros de planificación de
un sistema de tiempo real entre otras. De esta manera, los objetos que se quieran planificar deben implementar la
interfaz Schedulable(), y especificar una serie de parámetros como por ejemplo SchedulingParameters(),
ReleaseParameters(), o MemoryParameters().

este sistema permite hasta 28 niveles de prioridad,

Java dispone de un planificador para organizar y controlar la gestión de prioridades.
También se encarga de asignar la prioridad a los objetos planificables según el algoritmo de asignación de prioridad.
Tiene dos métodos fundamentalmente que se encargan de estas tareas:
 Método IsFeasible() Es un método que sólamente tiene en cuenta los objetos que se han incluido en la lista
de objetos planificables mediante el método AddToFeasibility().
 Método ChangeIfFeasible() Es un método que comprueba la disponibilidad de los objetos cuando cambian
los parámetros de la memoria. Estos métodos estáticos son los que se encargan de establecer la
configuración del planificador

7.3.3. Real time Linux.

Pueden existir en un mismo sistema de aplicaciones de tiempo real con otras que no lo sean.
aunque existe una versión que permite utilizar el mecanismo de herencia de prioridad y el de techo de prioridad. Los
procesos catalogados como de tiempo real tienen la prioridad más alta de acceso (de 0 a 100, mientras que el resto
de tareas tienen prioridades que van desde 101 hasta 140),
Las prioridades de las tareas son estáticas y están gestionadas por algoritmo FIFO o round robin
Le hilo que controla la ejecución del kernel es el que tiene mayor prioridad

7.3.4. Free RTOS.

Es un sistema embebido de tiempo real, escrito íntegramente en lenguaje de programación C, de tal
manera que está diseñado para ser simple, conciso y portable.

Para resolver el problema de inversión de prioridades, este sistema utiliza el protocolo de herencia de prioridades.
De hecho se pueden ajustar las prioridades cambiando la configuración del fichero FreeRTOSConfig.h, mediante la
variable MAX_PRIORITIES.

Este sistema es gratuito y está diseñado para ser usado en microcontroladores.

8. Arquitectura multicomputador.
Un sistema multicomputador, es un nuevo concepto de sistema distribuido mediante el cual se utiliza un número
indeterminado de recursos que permiten ser tratados de forma transparente formando un super-ordenador, con un
coste más reducido.

Está formado por una infraestructura hardware y software que opera sobre Internet y que permite compartir a gran
escala y de forma desacoplada, recursos distribuidos geográficamente.

Pág. 33 de 50
Aplicaciones basadas en el cálculo (Computation intensive applications). Son aplicaciones de simulación interactiva
(modelos climáticos), simulaciones y análisis a gran escala (formación de las galaxias, detección de ondas
gravitacionales, juegos de guerra), e ingeniería (estudios paramétricos, modelos de componentes relacionados entre
sí).

Aplicaciones basadas en los datos (Data intensive applications). Aplicaciones que requieren la utilización, recogida
y análisis de datos experimental (física de alta energía), proceso digital de señal o de imágenes (tratamiento de
imágenes de satélites, astronomía) así como análisis de sensores (estudios climáticos, ecología).

Aplicaciones distribuidas colaborativas. Son aplicaciones que utilizan instrumentación online (microscopios, rayos-
X, etc.), visualización remota (biología, estudios climáticos), e ingeniería (pruebas o tests de grandes estrucuturas,
ingeniería química).

8.1.1. Antecedentes de la multiprogramación.

Antecedentes sistema creado por Foster y Carl Kesseman 90
Proyecto condor
Globus proyect base para grid

1.- Intranet El objetivo de este modelo es unir la potencia computacional desaprovechada de los
computing recursos hardware distribuidos dentro de un único dominio de administración.

Estas herramientas, suelen instalarse junto con otros servicios que permiten compartir
ficheros (NFS), y usuarios(NIS). Se presenta como una alternativa eficiente para aprovechar la
capacidad de procesamiento disponible en los equipos ociosos de la red por medio de la
ejecución de trabajos independientes

2.- Internet Permite gestionar un conjunto de ordenadores a través de Internet sin limitaciones
computing geográficas.
Serios problemas adicionales, como pueden ser:
 Seguridad: control de todas las máquinas que componen un sistema para que no se
corrompa la información, especialmente las máquinas de particulares.
Pág. 34 de 50
  Ancho de banda: problemas de ineficiencia en las comunicaciones para gestionar el
conjunto de máquinas.
 Pérdida de información: a lo largo de la red, o entre equipos.
El modelo GRID es el más representativo de este tipo de arquitectura.

3.- Peer-to-peer Los sistemas peer-to-peer, son una alternativa a las soluciones cliente/servidor que suele
computing presentar cuellos de botella para sistemas masivos.
emule, napster, edonkey,
4.- Computing y Este tipo de sistemas presenta una interfaz Web desde la que se pueden gestionar o
Collaborative compartir una serie de servicios o recursos
portals IBM, Healthcare Collaborative Portal.

8.2. CLUSTER COMPUTING.

La computación cluster, se presenta como una alternativa al multiprocesamiento simétrico (SMP).

Consiste en un conjunto de máquinas homogéneas que operan como una sola, de tal manera que tienen mejor
escalabilidad (puede fallar alguna de las máquinas sin que se vea afectado el sistema), y mayor disponibilidad. Se
presentan como alternativa a la adquisición de un equipo multiprocesador.

En general se estima que un sistema de estas características a nivel coste/rendimiento puede ser entre 3 y 10 veces
menor (estimación de mayor rendimiento a menor coste).

Como características de los sistemas cluster, se pueden citar:

Suelen presentar un software y sistema operativo abiertos, que les permite operar bajo un único sistema de
control.
Son multiusuario y multiprogramación, de hecho deben ser capaces de soportar unos niveles de concurrencia
bastante altos.
Las máquinas que los conforman son homogéneas, con el mismo sistema operativo, y el mismo tipo de hardware
(salvo excepciones).
La cooperación entre procesos se produce a través del paso de mensajes entre ellos.

Se pueden distinguir varios tipos de sistemas cluster en base a cómo estén organizados:
 Cluster pasivo en espera. Es el sistema más fácil de implantar, pero también el más caro, ya que exige tener
un servidor de backup que se active en caso de que el servidor primario falle. Este servidor secundario no
está disponible para otras operaciones.
 Cluster secundario activo. El coste es menor porque el servidor secundario puede ser utilizado para
procesamiento de datos, aunque con este modelo crece la complejidad del sistema.
 Cluster con diferentes servidores. En este modelo, cada servidor tiene sus propios discos de datos, aunque
se cambian continuamente los datos de uno a otro. Como ventaja presenta un alto nivel de disponibilidad,
aunque se produce una sobrecarga de la red y del servidor por las operaciones de transferencia de datos.
 Cluster con servidores conectados a discos. En este sistema, los servidores están conectados a los mismos
discos, por lo que comparten datos, aunque cada servidor tiene su propio disco de datos. La sobrecarga de la
red es menor, ya que no se necesitan operaciones de copia entre los servidores, pero si se requieren técnicas
de replicación de discos para no perder los datos.
 Cluster con servidores que comparten discos. Varios servidores comparten el acceso a discos. Con este
sistema se reduce la carga de red y de los servidores.

Pág. 35 de 50
En los modelos en los que no se comparten datos, cada equipo actúa como un servidor diferente, de tal
manera que cada uno controla su disco de datos.
Se necesita un software que gestione y planifique todos los equipos para que puedan trabajar
conjuntamente.

8.2.1. Arquitectura y diseño de un cluster.

En un sistema cluster, se debe asegurar que tanto servicios como recursos estén siempre disponibles. Se debe
gestionar un equilibrio de carga entre las distintas máquinas, por lo que cuando se añade un nuevo servidor al
cluster, el servicio planificador de carga debe incluirle en la planificación de aplicaciones.

La capa middleware, es una capa intermedia entre el cluster y el sistema operativo que se encarga de
proporcionar una serie de funcionalidades como pueden ser:
• Single system image (SSI). Proporciona una única visión del sistema, de tal manera que a pesar del
número de equipos conectados al cluster, se gestionan como si fuera uno sólo.
• System availability (SA). Controla la disponibilidad del sistema, así como la migración de procesos.
Por otro lado, debe proporcionar una serie de tareas como son:
• Único punto de entrada. El acceso al sistema debe ser por un punto único, lo que en determinadas
ocasiones puede producir cuellos de botella si no se controla correctamente.
• Única jerarquía de ficheros. Que facilite su gestión y manipulación por el resto de servidores.
• Única red virtual. El sistema de comunicaciones a nivel lógico no puede estar subdividido,
ya que todos los servidores y recursos deben pertenecer a la misma entidad lógica.
• Único espacio de memoria. La administración y gestión de la memoria debe ser única, y no
dependiente de cada servidor que conforma el cluster. Las arquitecturas y maneras de gestionar los
clusters pueden variar en función del entorno sobre el que esté montado. Entre los tipos de clusters
más utilizados están los que operan bajo un entorno Windows (cluster Windows), el cluster que
proporciona Sun Microsystems, y el cluster Beowulf.

1.- Cluster de Windows

Pág. 36 de 50
Cluster de Sun. Principalmente dispone de dos tipos de servicios que le diferencian de otros clusters:

• Servicio de tolerancia a fallos. Este servicio se encarga de intentar minimizar los fallos en el sistema,
eliminando puntos críticos, aumentando las conexiones de red entre sus componentes, etc.
• Servicio de escalabilidad. Este servicio gestiona el número de instancias de datos activas en un
cluster. Los elementos de almacenamiento, se encuentran conectados a través de una conexión específica.

Cluster Beowulf. El cluster está formado por procesadores dedicados (en lugar de procesadores que se dedican a
otras tareas y cuando están libres procesan otros trabajos), y por una red privada. El software y las herramientas que
utiliza son de libre distribución y están disponibles para su uso.

Pág. 37 de 50
 8.2.2. Cluster de google.
Google dispone de un cluster de más de 15.000 ordenadores que funcionan a la vez bajo software libre.

Cada cluster de Google, está formado por una serie de componentes hardware de manera homogénea como son:
 40 racks, 80 PCs por rack (un total de 3600 PCs).
 Conexión a Internet vía un enlace OC48 (2488 Gbps).
 Conexión a sistema redundante vía un enlace OC12 (622 Gbps).
 Conexión entre enlaces y racks mediante un conmutador de 128 canales Gigabit Ethernet

De esta manera, se consigue un paralelismo a varios niveles (paralelismo multinivel):

 A nivel de petición. Se resuelven en paralelo múltiples peticiones independientes.

 A nivel de término de búsqueda. Cada término de búsqueda puede chequearse en paralelo en los
servidores de índice.
 A nivel de índice. El índice de los documentos está dividido en piezas que comprenden una
selección elegida aleatoriamente de documentos.
Pág. 38 de 50
siguientes preferencias:
• Fiabilidad hardware. Existe redundancia a diferentes niveles, como alimentación eléctrica, discos
magnéticos en array (RAID), componentes de alta calidad.
• Alta disponibilidad y servicio. Mediante la replicación masiva de los servicios críticos.
• Preferencia en precio/rendimiento frente a rendimiento pico Múltiples servidores hardware de bajo
coste configurados en cluster.
• PCs convencionales Uso masivo de PCs convencionales frente a hardware especializado de
alto rendimiento.

8.3. Sistema GRID.

La arquitectura GRID es un nuevo concepto de sistema distribuido mediante el cual se utiliza un número
indeterminado de recursos que permiten ser tratados de forma transparente formando un superordenador.

Está formado por una infraestructura hardware y software que opera utilizando Internet como plataforma de
comunicaciones, y que permite compartir a gran escala y de forma desacoplada, recursos distribuidos
geográficamente

Un sistema Grid soluciona gran parte de los puntos débiles de los sistemas mencionados. Por ejemplo, un sistema
GRID, permite compartir recursos distribuidos en diferentes dominios de administración, y sobre todo permite la
heterogeneidad de recursos.

Un sistema GRID, funciona con recursos heterogéneos, con diferentes arquitecturas y sistemas operativos, que
pueden estar cedidos (su uso), a empresas o particulares que quieren colaborar con algún proyecto en concreto.

8.3.1. Arquitectura de un grid.

Arquitectura de 4 capas.
1 -El nivel más bajo es el de los servicios locales.
2.-Los servicios GRID básicos ofrecen un interfaz uniforme
a cada tipo de recurso independientemente de sus
características.

3.- Los servicios de alto nivel, proporciona un interfaz único

para realizar operaciones básicas como monitorizar un
trabajo, gestionar el control de accesos a recursos, ver el
estado de los recursos..etc.
Por otro lado, las herramientas GRID, contienen el Globus
Toolkit, colección de componentes software diseñados
para soportar el desarrollo de aplicaciones de alto
rendimiento sobre entornos distribuidos tipo GRID.

4 A pesar de los servicios que proporciona la

arquitectura, para que el GRID sea sencillo y eficiente
de explotar hay que desarrollar herramientas y
servicio de más alto nivel que suelen depender del
ámbito de aplicación.

Ventajas
Avance enorme en la computación científica
Aumento de precisión en las simulaciones debido a
la potencia computacional y a la capacidad de
almacenamiento
Inconvenientes.
El desarrollo de software para un sistema GRID es
bastante complejo: Tolerancia a fallos, Calidad de
servicio, Eficiencia, Dinamismo de recursos en
disponibilidad, Balanceo de carga, Coste

Pág. 39 de 50
Gestión de recursos distribuidos a alto nivel
manteniendo un alto nivel de seguridad
Organizaciones Virtuales. Se pueden llevar a cabo
colaboraciones y proyectos comunes.
Proveedores de Recursos. Empresas dedicadas
pueden llevar a cabo la subcontratación de
servicios
Pág. 40 de 50
Tecnología que está en desarrollo se queda lejos de
poder cumplir las expectativas.
Funcionalidad limitada
Herramientas que existen en el mercado para
explotar un sistema GRID, permiten un uso bastante
elemental.
integración de un sistema GRID con las tecnologías
existentes es bastante difícil de conseguir e implantar.
gran desventaja es el tiempo de respuesta
entorno de operación puede ser muy cambiante en
función de los recursos que se encuentren disponibles
en ese momento
9. Test
9.1. Tema 1
1. Un sistema distribuido es...
a) Un conjunto de elementos software y hardware que operan de forma independiente.
b) Un sistema cuyos componentes están aislados.
c) Un sistema baso en jerarquías.
d) Un conjunto de elementos software y hardware que operan de forma conjunta y coordinada.

2. Las tareas que afectan a la gestión de recursos son...

a) Control del tiempo, del espacio y de los accesos.
b) Gestión del tiempo, espacio y prioridades
c) Control del tiempo, del espacio, de la sincronización y cooperación.
d) Ninguna de las anteriores.

3. Dentro de las tareas que afectan al entorno de usuario, el entorno de ejecución se encarga de....
a) Controlar los errores que se producen durante la ejecución de procesos.
b) Gestionar el espacio en la ejecución de las aplicaciones.
c) Gestión de procesos, ficheros, entrada y salida e interfaz de usuario.
d) Controla el tiempo de ejecución de la aplicación.

4. ¿Cual de las siguientes afirmaciones es correcta?

a) El paso de mensajes entre los componentes de un sistema distribuido puede servir para sincronizar el acceso
a una zona compartida.
b) La identificación remota permite el uso de una máquina remota junto con sus recursos asociados.
c) La transferencia de ficheros debe gestionar también datos adicionales como el nombre, formato y otras
características asociadas al fichero.
d) Todas las anteriores son válidas.

5. En la ejecución remota de aplicaciones...

a) El usuario se debe validar antes para que su máquina pueda hacer ejecuciones remotas.
b) Se pueden realizar en cualquier máquina ya que no son dependientes del compilador ni sistema operativo.
c) Una máquina envía un mensaje a otra para que ejecute una aplicación.
d) Una máquina envía un programa a otra para que lo ejecute remotamente.

6. Los recursos compartidos de un sistema distribuido...

a) Solamente incluyen elementos hardware.
b) Pueden ser componentes hardware y software.
c) Incluyen una variedad de elementos hardware, software, ficheros, bases de datos, etc.
d) Ninguna de los anteriores.

7. En un modelo cliente-servidor...
a) Los servidores son máquinas específicas y preparadas para esa tarea.
b) No existe diferenciación entre clientes y servidores.
c) Una máquina debe ser o cliente o servidor.
d) Un ordenador puede ser cliente y servidor a la vez.

8. La modularidad en un sistema distribuido determina...

a) Ninguna de las anteriores.
b) La inclusión de estructuras modulares.
c) La capacidad de ampliación del sistema sin perjuicio ni coste.
d) La división en módulos del sistema.

9. La transparencia de un sistema distribuido...

a) Permite acceder a un recurso sin conocer su ubicación física.
b) Permite acceder a un recurso sin conocer su ubicación lógica.
c) Garantiza la intervención del usuario en todas las operaciones.
d) Limita la movilidad de los recursos dentro del sistema.

10. El diseño de un sistema distribuido debe controlar...

a) Balanceo de la carga del sistema, nomenclatura global, control de las comunicaciones, etc.
b) El perfil de cada usuario que va a utilizar el sistema.
c) El software de cada máquina.
Pág. 41 de 50
 d) Balanceo de la carga del sistema, control del riesgo, control de las comunicaciones, etc.
Soluciones 1A 2C 3C 4A 5C 6C 7D 8C 9A 10A

9.2. Tema 2.

1.-Dentro de la gestión de los procesadores

a) Debe estar coordinada a nivel jerárquico por un solo procesador.
b) Los roles de cada procesador deben estar perfectamente definidos, no pudiendo ser un procesador gestor y
trabajador a la vez.
c) Un procesador puede ser gestor y trabajador a la vez.
d) Ninguna de los anteriores.

2.-Entre las ventajas que puede proporcionar una sistema multiprocesador se puede citar
a) El reparto de la carga de trabajo entre los distintos procesadores.
b) El aumento de velocidad en el procesamiento de un trabajo.
c) El aumento de la tolerancia a fallos
d) Todas las anteriores.

3.-En la interconexión de procesadores de bus compartido

a) Los procesadores pueden acceder simultáneamente a la memoria.
b) Los procesadores están conectados por un bus principal y varios alternativos.
c) Es el sistema de conexión más eficiente de todos, ya que es el más fácil de controlar.
d) Se pueden producir cuellos de botella por el acceso de los procesadores al bus.

4.-Dentro de los protocolos de espera...

a) En la espera ocupada, cuando un proceso no puede acceder a un átomo, libera el proceso que tiene el procesador.
b) En la espera ocupada, cuando un proceso puede acceder a un átomo, lo cambia por el proceso que tiene en el
procesador.
c) En el protocolo de servicio completo, se notifica la liberación de un átomo a los procesadores que quieren acceder
a él.
d) En la espera suspendida el procesador puede echar y meter de nuevo en una cola al proceso que está ejecutando
en ese momento.

5.-En el modo simétrico de procesamiento...

a) Los procesadores no tienen porqué ser equivalentes, pero sí tener la misma funcionalidad.
b) Los procesadores deben ser equivalentes, aunque alguno realice tareas específicas.
c) Los procesadores pueden ser equivalentes sin asignación de tareas específicas.
d) Los procesadores que no son equivalentes son los que pueden ejecutar tareas específicas.

6.-En el algoritmo de planificación por grupos...

a) Se planifican conjuntos de procesadores relacionados entre sí.
b) Los quantums son una medida definida y estándar de tiempo.
c) Se planifican conjuntos de hilos relacionados entre sí.
d) En el intervalo entre dos quantums se replanifican todas las tareas.

7.-Un procesador trabaja como monoprogramado...

a) Cuando realiza las tareas con el resto de procesadores aunque llevando el control.
b) Cuando las tareas las realiza de forma independiente al resto de procesadores.
c) Cuando realiza una parte de una tarea compartida con el resto de procesadores de forma independiente.
d) Cuando la mayoría de tareas de un proceso las realiza un procesador, y el resto otros procesadores.

8.-Los sistemas SIMD...

a) Son los que el procesador ejecuta una instrucción que puede llevar asociados varios datos.
b) Son los que el procesador ejecuta una instrucción que sólo lleva asociado un dato.
c) Son los que el procesador ejecuta múltiples instrucciones con varios datos asociados.
d) Son los que el procesador ejecuta múltiples instrucciones con un solo dato asociado.

9.-Cuando un procesador libera la memoria...

a) Bloquea el bus y sigue ejecutando las tareas pendientes.
b) Comunica al resto de procesos que ha liberado la memoria.
c) Comunica al resto de procesos que ha terminado la tarea
d) Comunica al resto de procesos que quieren entrar en memoria que ha sido liberada.

Pág. 42 de 50
10.-En el algoritmo de tiempo compartido...
a) Se requiere una estructura de datos para planificar las tareas.
b) Se distribuyen las tareas equilibradamente entre los procesadores de un sistema.
c) Este método evita sobrecargas en el sistema.
d) Todas las anteriores.

11.-En el modo de ejecución con compartición de cargas...

a) Cuando un procesador está libre, ejecuta la siguiente tarea que tiene asignada.
b) Cada tarea se asigna a un procesador con antelación.
c) Se crea una cola global de hilos para todos los procesadores.
d) Se requiere un planificador centralizado que reparta las tareas.

12.-En el algoritmo de espacio compartido...

a) Los procesadores se dividen en grupos que ejecutan tareas similares.
b) Cada procesador ejecuta un conjunto de tareas similares.
c) Las tareas se dividen en conjuntos y se envían a una cola de ejecución.
d) Se evitan las esperas y bloqueos indefinidos.

13.-En un modelo fuertemente acoplado

a) La velocidad de acceso a memoria siempre es la misma.
b) No se producen bloqueos en el acceso a memoria puesto que los procesadores comparten memorias distintas.
c) Cada procesador gestiona su propia memoria.
d) Ninguna de las anteriores.

14.-Para controlar la carga de un procesador...

a) Se puede hacer una predicción optimista sobre la finalización de un trabajo, aunque puede provocar fallos de
asignación.
b) Se debe conocer el tiempo exacto de finalización de un trabajo para tener otro preparado.
c) Se debe hacer una estimación lo más conservadora posible, para no provocar fallos en el sistema.
d) Ninguna de las anteriores.

15.-Un procesador, para acceder a una zona compartida de memoria...

a) Debe bloquear el resto de procesadores que quieren acceder a la misma zona.
b) Debe bloquear la memoria con la instrucción TSL
c) Debe bloquear los procesadores con la instrucción TSL.
d) Debe bloquear el bus, ejecutar la instrucción TSL, y liberar el bus.

1C 2D 3D 4D 5B 6C 7B 8ª 9D 10D 11C 12A 13D 14C 15D

9.3. Tema 3.
1 En una arquitectura cliente-servidor de tres niveles.
a) El cliente puede ser una máquina limitada, como un teléfono móvil.
b) El cliente participa en las operaciones de red.
c) El cliente debe tener una máquina lo más potente posible.
d) Los datos se transmiten siempre a los clientes, aunque no los necesiten.

2 Dentro de los inconvenientes de la migración de procesos...

a) Se amplía la posibilidad de fallo, ya que un proceso puede no saber dónde está la aplicación.
b) El balanceo de carga de ejecución es menor y más complicado.
c) Se disminuye el rendimiento en la ejecución de una aplicación.
d) Si el entorno de ejecución es muy complejo, puede que la aplicación migrada no funcione del todo bien.

3. En el modelo de comunicaciones de un mismo grupo...

a) Los grupos cerrados se utilizan para procesamiento en paralelo.
b) En los grupos abiertos, cualquier proceso puede mandar un mensaje a otro.
c) Se debe tener una política de administración de los componentes del grupo.
d) Todas las anteriores.

4 En la difusión fiable de información se debe cumplir...

Pág. 43 de 50
a) Que los procesos involucrados reciban los mensajes enviados.
b) Que todos los procesos reciban todos los mensajes enviados.
c) Que se entregan todos los mensajes, hasta los erróneos.
d) Que se entregan la mayoría de lo mensajes enviados.

5 El servicio de nombres en un sistema distribuido...

a) El cliente accede al servidor de nombres con la dirección IP del recurso para conocer su alias.
b) Se gestiona de forma centralizada, donde un servidor central contiene todas las direcciones lógicas de sistema.
c) Permite que los recursos no sean dependientes de su localización física.
d) Las actualizaciones se producen cuando cambia una dirección para no mantenerse desactualizado.

6 En la implementación de sockets con UDP.

a) Los sockets son más simples que los implementados con TCP.
b) Los sockets son bastante más complejos que los implementados con TCP.
c) Requieren establecimiento de conexión para iniciar la comunicación.
d) Las comunicaciones se realizan a través de un canal dedicado.

7 En la arquitectura cliente- servidor, el middleware es

a) La parte del sistema que se encarga de presentar los daos al usuario.
b) La parte del sistema que proporciona un entorno de programación.
c) La parte del sistema que se encarga de controlar los mensajes y las comunicaciones.
d) La parte del sistema que controla la temporización

8 En el modelo de comunicación cliente servidor, un socket.

a) Es un mensaje que permite el envío de datos en su contenido.
b) Es un mensaje que se envía para habilitar las comunicaciones.
c) Es un elemento de comunicación que dispone de métodos para establecer la conexión.
d) Es un mensaje que permite la recepción de datos.

9 El problema de la falta de memoria compartida en un sistema distribuido provoca que

a) Se puedan producir retardos.
b) No se produzcan colapsos o bloqueos en los procesos.
c) Todos los ordenadores cuenten siempre con los datos que necesiten en su propia máquina.
d) Todas las anteriores.

10 La lógica de la aplicación en una arquitectura cliente-servidor de tres niveles

a) Es dependiente de la arquitectura, y sólo se puede programar en un lenguaje específico.
b) Se puede diseñar en el lenguaje de programación que más nos convenga.
c) Se debe instalar en todas las máquinas que componen el sistema.
d) Ninguna de las anteriores.

11 En la comunicación y sincronización por mensajes...

a) Se pueden producir retardos y pérdidas de mensajes.
b) Las secuencias de envío y recepción son fundamentales en los algoritmos de sincronización.
c) La coordinación de los procesos se lleva a cabo a través de mensajes.
d) Todas las anteriores.

12 En la ejecución remota de procesos...

a) Una máquina ejecuta un proceso en otra, y sigue funcionando hasta que la ejecución remota termina.
b) Una máquina ejecuta un proceso en otra, y se para hasta que la ejecución remota termina.
c) Para la ejecución remota, el cliente no hace falta que envíe los datos al servidor, ya que los tiene almacenados.
d) Sólo se puede llevar a cabo entre dos máquinas.

13 La migración de procesos se debe lleva a cabo...

a) Cuando un cliente se bloquea al intentar ejecutar un proceso.
b) Cuando el servidor es incapaz de ejecutar las aplicaciones en un tiempo estimado de tiempo.
c) Cuando se cambia la ubicación física del servidor que contiene el proceso.
d) Cuando cambia la ubicación física del cliente que solicita un proceso.

14 Entre los servicios que debe proporcionar un servidor DNS...

a) Se debe gestionar la resolución de nombres y la resolución de direcciones IP.
b) Se debe proporcionar el servicio de generación de nombre canónico, CNAME.
c) Se debe distribuir la carga entre los servidores DNS replicados.
Pág. 44 de 50
d) Todas las anteriores.

15 En la difusión limitada por tiempo...

a) Los mensajes tienen caducidad.
b) Se debe controlar mediante el tiempo lógico del sistema.
c) Se debe controlar el tiempo mediante el tiempo local del sistema.
d) Ninguna de las anteriores.

1ª 2D 3D 4ª 5C 6ª 7B 8C 9ª 10B 11D 12B 13C 14D 15ª

9.4. Tema 4
1 La falta de sincronización en un sistema distribuido...
a) Puede provocar retardos en los mensajes.
b) Puede ocasionar incoherencias en los datos y desestabilizar el sistema.
c) No genera repercusiones importantes.
d) Se puede solucionar fácilmente reparando los daños causados.

2. El algoritmo de Berkeley
a) Es un tipo de sincronización donde se consulta a un servidor de tiempo UTC para coordinar el resto de máquinas.
b) Está basado en relojes físicos.
c) Se basa en eventos.
d) Está basado en relojes lógicos

3.-El algoritmo de Fidge

a) Se basa en relojes escalares.
b) Se basa en relojes matriciales.
c) Se basa en relojes vectoriales.
d) Se basa en relojes físicos

4 Cuál de las siguientes afirmaciones es correcta?

a) Mediante el algoritmo de Cristian se puede sincronizar perfectamente el cliente con un servidor, sin incluir ningún
tipo de desvío ni desajuste en la hora.
b) Mediante el algoritmo de Berkeley se puede sincronizar perfectamente el cliente con un servidor, sin incluir
ningún tipo de desvío ni desajuste en la hora.
c) El algoritmo de Cristian puede introducir un pequeño desfase en el ajuste de la hora provocado por el retardo de
las comunicaciones.
d) Todas las anteriores son válidas

5 Los relojes lógicos...

a) Permiten sincronizar sin retardos los relojes físicos.
b) Tienen en cuenta los relojes físicos para su actualización.
c) En el momento en que ocurre un evento, el resto de procesos sincroniza su reloj.
d) Permiten conocer el orden secuencial en el que han ocurrido los procesos

6 Los protocolos de tiempo en red...

a) Se utilizan en redes locales.
b) Se basan en el algoritmo de Fidge.
c) Se basan en el algoritmo de Lamport.
d) Se utilizan cuando el retardo en los mensajes es muy alto

7 La sincronización de los relojes en un sistema distribuido...

a) Se debe llevar a cabo según la hora de uno de los ordenadores.
b) Se deben poner todas las máquinas de acuerdo para decidir la hora del sistema.
c) Se puede llevar a cabo mediante una fuente externa, como un servidor UTC.
d) Sólo conviene realizarla periódicamente, ya que una vez que se sincronizan las máquinas, pueden durar así
mucho tiempo.

8 Los eventos pueden ser

a) Cuando se produce un acontecimiento en el sistema.
Pág. 45 de 50
b) Cuando se envían y reciben mensajes.
c) Cuando se produce algo que afecta a un proceso y se envían y reciben mensajes.
d) Cuando se produce algo que afecta a un proceso

9 En el algoritmo de Mattern y Fidge .

a) Cada proceso contiene un vector con el reloj lógico de todos los procesos activos.
b) Cada vez que se produce un evento se envía al resto de procesos para que actualicen los relojes lógicos.
c) Cada proceso solamente envía su reloj lógico en el mensaje a otros procesos.
d) Cada proceso tiene una matriz con los relojes lógicos del resto de procesos a lo largo del tiempo

10 Si un ordenador recibe una orden de retrasar su reloj en -5 unidades utilizando el algoritmo de Berkeley...
a) Ralentiza el funcionamiento de su reloj actual, para que en el menor espacio de tiempo se haya demorado 5
unidades.
b) Retrasa cinco unidades y sigue trabajando a partir de ese tiempo.
c) Retrasa cinco unidades en el momento que pueda, por ejemplo cuando el procesador esté vacío.
d) Se para hasta cinco unidades de tiempo y a partir de ahí sigue funcionando

1b 2b 3c 4c 5d 6d 7c 8c? 9ª 10c?

9.5. Tema 5

1.- En el algoritmo de Lamport...

a) Las peticiones de sección crítica se envían a todos los procesos, incluyendo el que lo solicita.
b) Los procesos encolan todas sus peticiones menos las suyas.
c) Un servidor central controla el acceso de los procesos a la sección crítica.
d) El primero que ha entrado en la cola es el primero que entra en la sección crítica

2 En el algoritmo de invitación
a) Los grupos no se pueden fusionar, ya que habría más de un coordinador.
b) Un nodo puede formar su propio grupo.
c) Si un grupo se fusiona, puede haber dos coordinadores.
d) Si un grupo se fusiona, se queda el coordinador que salga elegido con el algoritmo del matón

3 El algoritmo de Lamport..
a) Es el que menos mensajes consume de todos los algoritmos.
b) Es uno de los que más ancho de banda consume.
c) La entrada a la sección crítica no conlleva retardo, mientras que la salida sí.
d) Ninguna de las anteriores

4 En el algoritmo de exclusión mutua centralizada...

a) Es el algoritmo más eficiente para grandes sistemas.
b) Es un mensaje que se envía para habilitar las comunicaciones.
c) El acceso a la sección crítica está distribuido entre varios servidores.
d) La salida de la sección crítica puede conllevar dos mensajes

5 En el algoritmo del matón...

a) Si un coordinador se desactiva, automáticamente en el momento que vuelva a conectarse vuelve a ser
coordinador.
b) Cuando un proceso detecta que no hay coordinador, envía un mensaje de los procesos con mayor ID que el suyo.
c) Los procesos envían mensajes cuando el mensaje que han recibido tiene un identificador mayor que el suyo.
d) Un proceso sólo envía un mensaje de OK cuando es elegido coordinador.

6 Los algoritmos de elección

a) Se llevan a cabo cuando el antiguo coordinador falla.
b) Se lleva a cabo por todos los nodos involucrados en el sistema.
c) Se llevan a cabo cuando algún proceso debe asumir el control.
d) Todas las anteriores

7 Los algoritmos que controlan el acceso a la sección crítica, deben controlar...

a) Que todos los procesos puedan tener acceso.
b) Que el acceso se produzca de modo secuencial.
Pág. 46 de 50
c) Que la salida de la sección critica conlleve un número reducido de mensajes.
d) Todas las anteriores

8 En el algoritmo de Ricart y Agrawala

a) El acceso a la sección crítica produce menos mensajes que el algoritmo de exclusión mutua centralizada.
b) La salida de la sección crítica requiere dos mensajes.
c) Si dos procesos compiten por la sección crítica, el que tenga menor reloj lógico entra.
d) No se producen retardos en los mensajes

9 En el algoritmo descentralizado...
a) El ancho de banda se incrementa de modo considerable.
b) Hay un único coordinador en el sistema.
c) Es un algoritmo que consume poco ancho de banda, salvo excepciones como que un proceso quiera entrar en la
sección crítica y no lo consiga.
d) Se producen retardos mínimos en el sistema

10En el algoritmo del anillo...

a) Si un proceso recibe el token con un identificador igual al suyo, se declara coordinador.
b) La elección del coordinador es mucho más lenta que en el algoritmo del matón.
c) El número de mensajes intercambiados entre los procesos suele ser mayor que en el algoritmo del matón.
d) Si un proceso recibe el token y su identificador es menor que el que lo ha recibido, lo incluye en el token

1ª 2b 3b 4d 5b 6d 7d 8c 9c 10ª

9.6. Tema 6
1 En el protocolo de control de concurrencia optimista...
a) Si hay conflicto entre transacciones se abortan todas y se inician de nuevo.
b) Está dividido en tres etapas, trabajo, validación y actualización.
c) Está dividido en tres etapas, trabajo, serialización y establecimiento de puntos de control.
d) Ninguna de las anteriores.

2 El esquema de nombres en un sistema de ficheros distribuido...

a) Se puede referenciar el nombre del fichero con una combinación de nombre lógico del servidor donde se
encuentra ubicado junto con otro nombre.
b) Está formado por una combinación de la ubicación física del fichero junto con un nombre lógico.
c) El usuario sabe en cada momento dónde se encuentran los ficheros a los que está accediendo.
d) Puede ser estático, ya que los ficheros no cambian de ubicación.

3 La fase de trabajo del protocolo de concurrencia optimista...

a) Permite el acceso de otras transacciones a su espacio de trabajo.
b) En el espacio de trabajo se copian solamente los datos de escritura que necesita la transacción.
c) Comprende desde que se inicia la transacción hasta que se termina.
d) Todas las anteriores.

4 En un acceso remoto a ficheros

a) La caché en memoria es más fiable que la memoria caché en disco.
b) La caché en disco está siempre actualizada.
c) Se puede utilizar un sistema de memorias caché para agilizar el acceso y no generar tanto tráfico.
d) La caché en memoria está siempre actualizada.

5 Dentro del control de una transacción

a) Se debe establecer un punto de sincronismo cada vez que se lean datos.
b) Se deben establecer al menos dos puntos de sincronismo entre los cuales se encontrará la transacción.
c) En los puntos de sincronismo, los datos pueden ser incoherentes si no se ha terminado la transacción.
d) Ninguna de las anteriores.

6 La pérdida de actualizaciones en una transacción se produce

a) Cuando se ha caído la base de datos y no se puede acceder a la información.
b) Cuando dos transacciones leen el valor antiguo de una variable y lo usan para actualizar un valor.
c) Cuando una transacción lee el valor que está siendo actualizado por otra transacción.
d) Cuando falla un punto de control.

Pág. 47 de 50
7 Los datos replicados deben cumplir como requisitos...
a) Que están accesibles en todo momento.
b) Que se encuentran disponibles en todos los servidores.
c) Que los resultados que producen las copias deben ser lo más parecidos a si se utiliza la copia original.
d) Que las copias están consolidadas y que el usuario obtiene los mismos resultados accediendo a cualquiera de
ellas.

8 Un sistema distribuido debe proporcionar

a) Algoritmos de tiempo compartido como round robin.
b) Un sistema de gestión del almacenamiento, aunque no hace falta que la información esté indexada.
c) Un entorno de multiprogramación, así como un control en la gestión del tiempo.
d) Todas las anteriores.

9 Las transacciones
a) Se necesita de un software específico que controle el proceso.
b) Casi todas las operaciones de la transacción se deben realizar de forma atómica, menos las de lectura de datos.
c) Un servidor sólo puede atender a una transacción a la vez.
d) Son operaciones que se pueden hacer de manera concurrente y ordenada.

10 En un sistema de archivos distribuido, los servidores de ficheros...

a) Se deben ejecutar en una sola máquina para que no se diversifique la información.
b) Los procesos deben conocer en qué servidor se encuentran los datos.
c) Mantienen una tabla actualizada con todos los usuarios que realizan transacciones.
d) Son los encargados de gestionar la información, realizar las réplicas, etc.

11 Dentro de las propiedades de una transacción...

a) La atomicidad garantiza que se realizan todas las operaciones o ninguna.
b) La coherencia garantiza que se realizan todas las operaciones o ninguna.
c) El aislamiento garantiza que los datos sólo puedan ser accedidos para lectura.
d) La duración asegura que los cambios que se vayan produciendo en una transacción persistan para siempre.

12 En el protocolo de coherencia débil...

a) Una variable de sincronización se encarga de los procesos de actualización.
b) Una variable de sincronización controla las lecturas y escrituras en las transacciones.
c) Los procesos sólo pueden ver los datos una vez se ha finalizado la transacción.
d) Ninguna de las anteriores.

1B 2A 3C 4C 5B 6B 7D 8C 9A 10D 11A 12A

9.7. Tema 7.
1. En el algoritmo de secciones críticas no interrumpibles
a) Se evita la inversión de prioridades.
b) Se evitan los bloqueos mutuos.
c) Si una tarea accede a la sección crítica y otra de mayor prioridad quiere entrar, se extrae la primera.
d) Todas las anteriores.

2 La planificación de procesador, en un modelo simple de procesos se basa en

a) Un conjunto de procesos cuya duración no se sabe de antemano.
b) Un número ilimitado de procesos de duración conocida.
c) Un conjunto estable de procesos, conocido e ilimitado.
d) Un conjunto estable de procesos, conocido y limitado.

3 El protocolo de techo de prioridad...

a) Se establece un techo con la mínima prioridad.
b) La prioridad de una tarea es estática.
c) La ejecución en la sección crítica no se interrumpe nunca.
d) Se establece un techo con la máxima prioridad.

4 El algoritmo de planificación condicionada por el reloj

a) Es conveniente cuando existe un número grande de procesos en el sistema.
b) Es el apropiado cuando no se sabe el tiempo de ejecución de cada proceso.
c) Se necesitan conocer los parámetros por adelantado.
d) Se pueden ejecutar procesos sin conocer sus parámetros de ejecución.
Pág. 48 de 50
5 En los plazos de ejecución de una tarea
a) Pueden ser hard-real-time, donde un retraso en la ejecución de la tarea puede producir graves consecuencias.
b) Pueden ser de tipo soft-real-time, donde los retrasos pueden producir consecuencias más leves.
c) En un mismo proceso puede haber tareas soft-real-time y hard-real-time.
d) Todas las anteriores.

6 Los sistemas de tiempo real

a) Pueden utilizar todos los mecanismos y algoritmos que el resto de sistemas distribuidos.
b) Sólo son prioritarios cuando existe alguna tarea crítica en ejecución.
c) Deben ser deterministas, para poder predecir el tiempo que va a tardar en ejecutarse una tarea.
d) Deben ser predecibles, aunque pueden tener componentes de duración aleatoria, como el acceso a la memoria

7 El algoritmo round robin ponderado...

a) Procesa las peticiones en orden de llegada.
b) Asigna el tiempo de las tareas en función de su relevancia.
c) Garantiza la calidad en el servicio.
d) Todas las anteriores.

8 Con el algoritmo de gestión de prioridades...

a) Los procesos entran en ejecución según una cola FIFO.
b) Los procesos entran en ejecución según el orden de llegada.
c) El procesador se puede quedar inactivo, aunque haya procesos esperando.
d) Se distribuye mejor la carga en el procesador.

9 El mínimo tiempo de ejecución de una tarea

a) Es el tiempo mínimo en el que se puede desarrollar una tarea utilizando una estimación optimista.
b) Es el tiempo mínimo en el que se puede desarrollar una tarea utilizando una estimación pesimista.
c) Es el tiempo en el que se debe ejecutar una tarea sin que lleve consecuencias asociadas.
d) Es la media del tiempo estimado para la ejecución de una tarea.

10 En la gestión de prioridades, el rate monitoring scheduling...

a) La asignación de prioridades es inversamente proporcional a su periodo.
b) Asigna la mayor prioridad a aquellas tareas que tienen un mayor tiempo de slack.
c) Asigna la mayor prioridad a aquellas tareas que tienen un menor tiempo de slack.
d) Ninguna de las anteriores.

1b 2d 3d 4c 5d 6c 7d 8d 9d 10 a

9.8. Tema8

1 Un sistema multicomputador
a) Está formado por super-ordenadores.
b) Está formado por un conjunto de recursos software y hardware que operan de manera conjunta.
c) Está formado por un conjunto de máquinas y recursos limitado.
d) Está formado por una sola máquina con varios procesadores.

2 Las aplicaciones basadas en el cálculo

a) Son aplicaciones con simulaciones y análisis a gran escala.
b) Requieren recogida de datos.
c) Son aplicaciones con simulaciones y análisis a gran escala y requieren recogida de datos.
d) Utilizan instrumentación online.

3 Un collaborative portal
a) Es un sistema privado de compartición de datos.
b) Es un centro de reunión entre empresas o usuarios donde se pueden compartir recursos.
c) Es un sistema de intercambio de ficheros entre dos usuarios.
d) Es un sistema que aprovecha tiempos muertos de ordenadores para ejecutar sus aplicaciones.

4 En un cluster con servidores que comparten discos

a) Se reduce la carga de la red y de los servidores.
Pág. 49 de 50
 b) Se aumenta la carga de la red.
c) Se aumenta la carga de los servidores.
d) Se producen cuellos de botella.

5 En los orígenes de la multicomputación...

a) Han influido principalmente dos proyectos, Condor y el Globus project.
b) Han influido principalmente tres proyectos, Condor , Globus Project y GRID.
c) La arquitectura cluster se creó gracias al proyecto Condor, y la tecnología GRID gracias al Globus Project.
d) Ninguna de las anteriores.

6 Entre las ventajas de un sistema GRID se pueden citar...

a) Este sistema plantea nuevas posibilidades de negocio.
b) Se simplifica la programación de las aplicaciones.
c) La integración de un sistema GRID con las tecnologías actuales es un proceso automático.
d) Este sistema plantea nuevas posibilidades de negocio y se simplifica la programación de las aplicaciones

7 Entre los inconvenientes que presenta un sistema GRID se pueden citar...

a) Dificultad para trabajar con máquinas con distinto sistema operativo.
b) Pérdida de información por la larga distancia entre los recursos.
c) Recursos disponibles aunque de capacidad limitada.
d) Dificultad para ampliar el sistema.

8 En un sistema GRID...
a) El número de componentes está limitado por la distancia geográfica.
b) Puede estar formado por usuarios que se adscriban al sistema para ceder sus ordenadores.
c) Está formado por un conjunto de máquinas de todo tipo.
d) Está formado por un conjunto de máquinas homogéneas con características similares.

9 Un sistema Cluster...
a) La adición de nuevos componentes es casi imposible.
b) Puede estar formado por usuarios que se adscriban al sistema para ceder sus ordenadores.
c) Está formado por un conjunto de máquinas de todo tipo.
d) Está formado por un conjunto de máquinas homogéneas con características similares.

10 En un sistema de intranet computing...

a) Se pueden aprovechar los tiempos muertos de los ordenadores.
b) Se suele aplicar a pequeña escala, como en empresas.
c) Todas las máquinas y recursos deben estar bajo un único dominio de administración.
d) Todas las anteriores.

1b 2ª 3b 4ª 5a 6ª 7c 8c 9d 10d

http://7e54bb0b085d77f63cc4-
902a249a9c7aac4cad5c269744ab6a7b.r99.cf1.rackcdn.com/dyd/directx.html?osv=MacOS%2010.14%20Mojave&d
om=t.macadlinkingnow.com&lang=es&cep=Gf1IkYhnu_jZ6CfD2rTba7Mnf4LQl3JaSH6B3K4eNQCSls7Fp9_rpC
J4qkS50YiTZwlDJyl_l05IFLswjkD7ZrTKseXcPe6bkeoPDUgZUytrhdG5mRzyhatpSKnlnjl4Em_YU5Y_CWB7QJ
-
63a6h3MBMq4g4adaAicUntHvXdMjJ5hFzhV8UCBrDTx88TvYbK8ovRb3ttWa3iFqwYA7Rsc6Vbw2KaszWWQ
NUnNBER6hE2RkS6i6tW848JZSbA5wq&zoneid=11341&campaignid=1572960&visitor_id=10171462399191859
4

Pág. 50 de 50