INSTITUTO POLITECNICO NACIONAL

CENTRO DE INNOVACIÓN Y DESARROLLO

TECNOLÓGICO EN CÓMPUTO

CONSTRUCCIÓN Y DISEÑO DE UN CLÚSTER

TIPO HPC VIRTUALIZADO

T E S I S

QUE PARA OBTENER EL GRADO DE:

MAESTRÍA EN TECNOLOGÍA DE CÓMPUTO

P R E S E N T A :

ING. JUAN ALBERTO ANTONIO VELÁZQUEZ

DIRECTORES DE TESIS:

M. en C. Jesús Antonio Álvarez Cedillo

M. en C. Juan Carlos Herrera Lozada

México D.F a 29 de Noviembre de 2010

i

Resumen

La virtualización tiene un papel importante en la seguridad informática y la mayoría de las

empresas lo utilizan para resguardar su información mediante sistemas virtuales que se comunican

con los sistemas físicos. Las empresas obtienen ventajas como: ahorro de espacio y menor uso de

energía, que a su vez se engloba en ahorro de mucho dinero. En este trabajo definiremos cuales son

las técnicas de paralelización que existen y como trabaja un cluster Mosix en la ejecución de

programas. Además se definen las técnicas de virtualización que se utilizan para manejar los

diferentes sistemas operativos. El software virtualizador usado fue Virtual-box, que puede ser

instalado en diferentes plataformas y que acepta la instalación de diversos sistemas operativos entre

ellos a OpenSuSE.

Debido a que la mayoría de los clusters que existen son físicos, se tomó la decisión de crear un

cluster virtualizado, con las mismas características del cluster físico. Se instalaron dos clusters con 4

nodos cada uno, la diferencia de estos clusters, es que el primer cluster es físico y el segundo cluster

es virtualizado. A estos se les hizo una comparación de ejecución de 4 algoritmos, qué en su análisis

y complejidad computacional exigen que el trabajo sea más complejo para una máquina secuencial,

sin embargo al repartirlo a varios nodos el trabajo es menos pesado. Estas pruebas de desempeño

nos ayudan a escoger la mejor solución para el desarrollo de problemas que hoy en día las empresas

requieren.

ii

Abstract

Virtualization has an important role in computer security, and most companies use it to protect the

information using virtual systems that communicate with physical systems. Companies also see

advantages as saving space and lower energy use which in turn is included in saving a lot of money.

In this work we define what are the parallelization techniques that exist and how a cluster works

Mosix in implementing programs.

You can define virtualization techniques used to handle different operating systems. Virtualizer

software used was Virtual-box can be installed on different platforms and accept the installation of

several operating systems including to OpenSuSE.

Because most of the clusters that exist are physical, it was decided to create a virtualized cluster

with the same characteristics of the physical cluster. Installed two clusters with 4 nodes each, the

difference in these clusters is that the first cluster is physical and the second cluster is virtualized.

These were given a performance comparison of 4 algorithms, which in its analysis and

computational complexity require more complex work for a sequential machine, but to distribute it

to multiple nodes is less heavy work. These performance tests help us choose the best solution for

the development of problems that today's companies require.

iii

DEDICATORIA

A DIOS. Por su infinita sabiduría, la cual la da a todos abundantemente y sin reproche. El cual me

dio la oportunidad, de haber estudiado esta maestría.

A mi Esposa Blanca Estela, por todo su amor, paciencia y ayuda en la culminación de esta tesis. Te

amo Blanca.

A mis hijos, Hugo Jonatán y David Jefté, a los cuales les dedico este trabajo, para que ellos superen

algún día este pequeño logro.

A mi papá Tomás Antonio, mi mamá Paulina Velázquez, a mis hermanos Tomy, Lupita y Claudia

los cuales estando lejos me apoyaron y me dieron ánimos para que yo no desmayara. Los quiero

mucho.

A mi suegra, por su paciencia, apoyo y porque me enseñó a tener perseverancia.

A mis amigos, los cuales me apoyaron para que culminara este trabajo y a los cuales les dedico este

esfuerzo, gracias por su paciencia. Posteriormente trabajaremos juntos para lograr muchos

resultados.

iv

AGRADECIMIENTOS.

AL INSTITUTO POLITECNICO NACIONAL (IPN).

Siempre fue un sueño estudiar en esta gran institución y cuando se presentó la oportunidad de

formar parte de sus filas, alcancé ese sueño.

Al Centro de Innovación y Desarrollo Tecnológico en Cómputo (CIDETEC), por darme la

oportunidad de haber estudiado, por darme la oportunidad de avanzar en mi vida profesional, por

sus profesores, sus instalaciones, sus equipos y por todo.

Al Tecnológico de Estudios Superiores de Jocotitlán y a la Ing. Esther Verónica García Ortiz mil

gracias por su apoyo y comprensión.

A MIS MAESTROS Y ASESORES.

A mis Directores de Tesis.

Al M en C. Jesús Antonio Álvarez Cedillo, porque aprendí muchas cosas referentes a cluster y

programación paralela y sobre todo el ayudarme a incursionar al maravilloso mundo del software

libre, gracias.

Al M en C. Juan Carlos Herrera Lozada, por ser un buen asesor y profesor, por su gran paciencia y

enseñanza en la redacción de esta tesis y sobre todo por su amistad.

Al Director del CIDETEC, Dr. Víctor Manuel Silva García, por haber creído en un grupo de

alumnos, por su paciencia a pesar de muchas críticas y por ser un buen profesor.

A mi comité tutorial.

A todos ellos porque cada uno me corrigió en el desarrollo de esta tesis y por sus consejos en todo

momento.

A mis profesores, por que dedicar parte de su tiempo y por sus muchas enseñanzas y apoyo para

terminar esta maestría, muchas gracias.

v

GLOSARIO DE TÉRMINOS

Algoritmos Genéticos. Son llamados así porque se inspiran en la evolución biológica y su base genético-

molecular. Estos algoritmos hacen evolucionar una población de individuos sometiéndolos a acciones

aleatorias semejantes a las que actúan en la evolución biológica (mutaciones y recombinaciones genéticas).

Alta Disponibilidad. También se le conoce como HA (High Availability), es un protocolo de diseño de

sistema y su implementación está asociada a la continuidad operacional durante un periodo de medición dado.

AMD. Advanced Micro Devices, Inc. (AMD) es una de las compañías más grandes del mundo en producción

de microprocesadores compatibles x86 (junto a Intel) y uno de los más importantes fabricantes de CPUs,

GPUs, chipsets y otros dispositivos semiconductores.

Balanceo de carga. Es un concepto usado en informática que se refiere a la técnica usada para compartir el

trabajo a realizar entre varios procesos, ordenadores, discos u otros recursos.

Batch.- Es un archivo por procesamiento de lotes, que es utilizado para manipular al sistema operativo y sus

programas. Es utilizado en ms-dos, Windows y OS/2.

Beowulf. Es una conexión de computadoras multi-arquitectura, que se puede utilizar para cálculos en

paralelo. Es un sistema que por lo general consiste en un nodo de servidor y uno o más nodos cliente

conectados entre sí a través de Ethernet o una red.

BIN. Archivo comprimido que se codifica como binario o MacBinary, almacena una cabecera del buscador,

tenedor de datos y el tenedor de los recursos; creado para Macintosh.

BIOS. (Sigla en inglés de Basic Input / Output System), es un firmware que se ejecuta al encender la

computadora y que localiza y reconoce todos los dispositivos necesarios para cargar el sistema operativo en la

memoria RAM.

Booteo. Es el proceso que inicia el sistema operativo cuando el usuario enciende una computadora. Se

encarga de la inicialización del sistema y de los dispositivos.

Bridge. Es un dispositivo de interconexión de redes de ordenadores que opera en la capa 2 (nivel de enlace de

datos) del modelo OSI. Este interconecta dos segmentos de red (o divide una red en segmentos) haciendo el

pasaje de datos de una red hacia otra, con base en la dirección física de destino de cada paquete.

Bucle. En programación, es una sentencia que se realiza repetidas veces a un trozo aislado de código, hasta

que la condición asignada a dicho bucle deje de cumplirse.

Celeron. Es el nombre que lleva la línea de procesadores de bajo costo de Intel. El objetivo era poder

mediante esta segunda marca penetrar en los mercados impedidos a los Pentium, de mayor rendimiento y

precio.

Clase de red. División del número IP en segmentos que posibilita la clasificación de las direcciones IPs en 5

clases: A, B, C, D y E. Cada clase de dirección permite un cierto número de redes y de computadoras dentro

de estas redes.

Cluster. Se aplica a los conjuntos o conglomerados de computadoras construidos mediante la utilización de

componentes de hardware comunes y que se comportan como si fuesen una única computadora.

vi

CMS. (En inglés Content Management System, abreviado CMS), es un programa que permite crear una

estructura de soporte (framework) para la creación y administración de contenidos, principalmente en páginas

web, por parte de los participantes.

Cola. Es una estructura de datos caracterizada por ser una secuencia de elementos en la que la operación de

inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama

estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el

primero en salir.

Coma o punto flotante. Es un método de representación de números reales que se puede adaptar al orden de

magnitud del valor a representar, usualmente trasladando la coma decimal, mediante un exponente hacia la

posición de la primera cifra significativa del valor.

Complejidad computacional. Es la rama de la teoría de la computación que estudia de manera teórica, la

complejidad inherente a la resolución de un problema computable.

CPU. La unidad central de procesamiento o CPU (por el acrónimo en inglés de Central Processing Unit), o

simplemente el procesador o microprocesador, es el componente del computador y otros dispositivos

programables que interpretan las instrucciones contenidas en los programas y procesa los datos.

Ethernet. Es un estándar de redes de computadoras de área local con acceso al medio por contienda

CSMA/CD (Acceso Múltiple por Detección de Portadora con Detección de Colisiones).

Ext3. Es el sistema de archivo más usado en distribuciones Linux, aunque en la actualidad está siendo

reemplazado por su sucesor, ext4.

Flops. Es el acrónimo de Floating point Operations Per Second (operaciones de punto flotante por segundo).

Se usa como una medida del rendimiento de una computadora, especialmente en cálculos científicos que

requieren un gran uso de operaciones de punto flotante.

g++. Es el alias tradicional de GNU C++, un conjunto gratuito de compiladores de C++.

gdb. Es un debugger de proyecto gnu, con se pueden ver los errores de un programa al compilar el programa

o hasta cuando se ejecuta.

Gcc. Es un conjunto de compiladores creados por el proyecto GNU. GCC es software libre y lo distribuye la

FSF bajo la licencia GPL.

GigaFlops. Equivale a 10 elevado a la 9 flops.

GNOME. Es un entorno de escritorio e infraestructura de desarrollo para sistemas operativos Unix y

derivados Unix como GNU/Linux, BSD o Solaris; compuesto enteramente de software libre.

Goto. (ir a en inglés), es una instrucción muy común en los lenguajes de programación con el objetivo de

controlar el flujo del programa.

Granjas de servidores. Es una colección de servidores o de computadoras, por lo general mantenidas por una

empresa, para llevar a cabo necesidades del servidor mucho más allá de la capacidad de una máquina.

Granjas de Renderizado. Son un conjunto de computadoras que compilan imágenes en tercera dimensión y

con millones de colores.

Granularidad. Es un factor clave para determinar la idoneidad de un modelo paralelo para una

implementación eficiente de códigos complejos en arquitecturas de procesadores simultáneos.

vii

Grid. Es una tecnología innovadora que permite utilizar de forma coordinada todo tipo de recursos (entre

ellos cómputo, almacenamiento y aplicaciones específicas) que no están sujetos a un control centralizado.

Hipercubo. El hipercubo es una de las topologías de multicomputadoras con conmutador, la cual trata de

redes de interconexión de CPU donde cada uno tiene su propia memoria exclusiva.

Hipervisor. (En inglés hypervisor o monitor de máquina virtual, virtual machine monitor), es una plataforma

de virtualización que permite utilizar al mismo tiempo, diferentes sistemas operativos (sin modificar o

modificados en el caso de paravirtualización) en una misma computadora.

ICMP. El Protocolo de Mensajes de Control de Internet o ICMP (por sus siglas de Internet Control Message

Protocol), es el subprotocolo de control y notificación de errores del Protocolo de Internet.

IMG. Son archivos de imagen, para grabar discos de CD o DVD.

INTEL. Es el más grande fabricante de chips semiconductores basado en ingresos. La compañía es la

creadora de la serie de procesadores x86, los procesadores más comúnmente encontrados en la mayoría de las

computadoras personales.

IP. Consiste en un número de 32 bits que en la práctica vemos siempre segmentado en cuatro grupos de 8 bits

cada uno (xxx.xxx.xxx.xxx). Cada segmento de 8 bits varía de 0 a 255 y están separados por un punto.

ISO. Es una imagen de disco, que contiene información de DVD y/o CD.

Java. Es un lenguaje de programación orientado a objetos, desarrollado por Sun Microsystems a principios de

los años 90 y su sintaxis es parecida a c++.

KDE. Es un proyecto de software libre para la creación de un entorno de escritorio e infraestructura de

desarrollo para diversos sistemas operativos como GNU/Linux, Mac OS X, Windows, etc.

Kernel. Es un software que actúa de sistema operativo. Es el principal responsable de facilitar a los distintos

programas acceso seguro al hardware de la computadora. En forma más básica, es el encargado de gestionar

recursos a través de servicios de llamada al sistema.

Live CD. Es un sistema operativo (normalmente acompañado de un conjunto de aplicaciones) almacenado en

un medio extraíble, tradicionalmente un CD o un DVD (de ahí sus nombres), que puede ejecutarse desde éste

sin necesidad de instalarlo en el disco duro de una computadora.

long double. Se refiere a un punto flotante tipo de datos que a menudo es más preciso que el de doble

precisión.

Mainframe. Es una computadora grande, potente y costosa usada principalmente por una gran compañía para

el procesamiento de una gran cantidad de datos; por ejemplo, para el procesamiento de transacciones

bancarias.

Make. Es una herramienta de generación o automatización de código, muy usada en los sistemas operativos

tipo Unix/Linux. Por defecto lee las instrucciones para generar el programa u otra acción del fichero makefile.

Las instrucciones escritas en este fichero se llaman dependencias.

Máquina Virtual. Es un software que emula a una computadora y puede ejecutar programas como si fuese

una computadora real.

Maya. Es un programa informático dedicado al desarrollo de gráficos en 3D, efectos especiales y animación.

MFLOPS. Equivalencia a 1,000,000 de flops.

viii

Middleware. Es un software de conectividad que ofrece un conjunto de servicios que hacen posible el

funcionamiento de aplicaciones distribuidas sobre plataformas heterogéneas.

Migración de procesos. Es cuando los procesos en clusters de ordenadores son capaces de pasar de una

máquina a otra. El proceso de migración se lleva a cabo en Mosix y OpenMosix entre otros.

MOPS. Significa millones de operaciones por segundo.

Mosix. Es un sistema operativo distribuido. Aunque las primeras versiones se basaban en los más antiguos

sistemas UNIX, desde 1999 se centra en Linux clusters y redes.

MPI. Es una API de la especificación, que permite a los ordenadores comunicarse entre sí. Se utiliza en

clusters de ordenadores y superordenadores.

MS-DOS. Es un sistema operativo de x86 basados en computadoras personales, basados en IBM.

Multicomputadoras. Es una asociación de computadoras conectadas en red y que comparten recursos en

común.

NAT. (Network Address Translation, Traductor de direcciones de red NAT), en redes de computadoras, es el

proceso de modificación de direcciones de red de información de datagramas (IP) a cabeceras de los paquetes

en tránsito, a través de un tráfico de enrutamiento del dispositivo con el fin de reasignar una IP espacio de

direcciones a otro.

NRG. Un archivo nrg, es una propiedad de CD de imagen en formato de archivo utilizado por Nero Burning

ROM , una suite de servicios públicos realizados por Nero AG, para crear y grabar ISO 9660 imágenes de

CD.

Openmosix. Es un sistema de gestión de grupos gratuito, que proporciona la imagen de un solo sistema (SSI),

como la distribución del trabajo automático entre los nodos del cluster.

Openssh. Es un conjunto de programas de ordenador, que proporciona cifrado de sesiones de comunicación a

través de una red de ordenadores con el protocolo ssh.

Ortogonalidad. En matemáticas, dos vectores son ortogonales si son perpendiculares, es decir, forman un

ángulo recto. La palabra viene del griego (Orthos), que significa "recta", y (gonia), que significa "ángulo".

Overhead. Traducido como Costos elevados.

Paralelismo. Es una forma de cálculo en el que muchos programas se llevan a cabo al mismo tiempo. Opera

en el principio de que los problemas grandes a menudo se pueden dividir en más pequeños y que se resuelven

al mismo tiempo ("en paralelo").

Pipeline. En informática, un pipeline o tubería es un conjunto o elementos procesadores de datos conectados

en serie, en donde la salida de un elemento es la entrada del siguiente. Los elementos del pipeline son

generalmente ejecutados en paralelo, en esos casos, debe haber un almacenamiento tipo buffer insertado entre

elementos. También es sinónimo de segmentación.

PVM. Es un software de herramienta para la creación de redes paralelas de computadoras. Está diseñado para

permitir una red heterogénea de Unix y/o equipos con Windows para ser utilizado como una sola

computadora, distribuye el trabajo a los procesadores en forma paralela.

Ralentizar. Significa desacelerar o hacer lento a un sistema de hardware.

ix

Recursividad. Es un método de definición de funciones, en el cual la función se aplica dentro de su propia

definición, en concreto es la definición de una declaración infinita utilizando componentes finitos.

Redes Neuronales. Denominadas habitualmente como RNA o en inglés como: "ANN", son un paradigma de

aprendizaje y procesamiento automático inspirado en la forma en que funciona el sistema nervioso de los

animales.

Renderizar. (Render en inglés), es un término usado en informática para referirse al proceso de generar una

imagen desde un modelo. Este término técnico es utilizado por los animadores o productores audiovisuales y

en programas de diseño en 3D.

Root. Es el nombre convencional de la cuenta de usuario que posee todos los derechos en todos los modos

(mono o multiusuario). Root es también llamado superusuario.

RSA. En criptografía, RSA (Rivest, Shamir y Adleman) es un sistema criptográfico de clave pública

desarrollado en 1977. En la actualidad, RSA es el primer y más utilizado algoritmo de este tipo y es válido

tanto para cifrar como para firmar digitalmente.

Secuencial. Significa que un programa se ejecuta instrucción a instrucción en un solo procesador.

Sistemas Distribuidos. Colección de computadoras autónomas, conectadas por una red, y que con la ayuda

de software distribuido comparte recursos.

Sistemas Embebidos. Es un sistema de computación diseñado para realizar una o algunas pocas funciones

dedicadas, frecuentemente en un sistema de computación en tiempo real.

Speedup. En computación paralela, la aceleración se refiere a la cantidad de un algoritmo paralelo y es más

rápida que una secuencia correspondiente a otro algoritmo.

Switch. Es un dispositivo de Networking situado en la capa 2 del modelo de referencia OSI.

Torres de Hanoi. Algoritmo recursivo, que se basa en ordenar platos en 3 postes en n cantidad de

movimientos.

UNIX. (Registrado oficialmente como UNIX®), es un sistema operativo portable, multitarea y multiusuario;

desarrollado en 1969 por un grupo de empleados de los laboratorios Bell de AT&T.

USB. (Universal Serial Bus), es un puerto que sirve para conectar periféricos a un ordenador.

VCD. Es un estándar de almacenamiento de video y también se utiliza para comprimir.

Virtualización. Se refiere a la abstracción de los recursos de una computadora, que crea una capa de

abstracción entre el hardware de la máquina física (host) y el sistema operativo de la máquina virtual (virtual

machine, Guest), siendo un medio para crear una versión virtual de un dispositivo o recurso como: un

servidor, un dispositivo de almacenamiento, una red o incluso un sistema operativo.

x

IINNDDIICCEE GGEENNEERRAALL

CAPITULO PAG.

CAPITULO I INTRODUCCIÓN .......................................................................................................... 1

1.1 SISTEMAS DISTRIBUIDOS Y CLUSTERS. ........................................................................................................... 1 1.1.1 Sistemas distribuidos como base para la construcción de un cluster. ........................................................ 2 1.1.2 Análisis histórico de los clusters y top500. ................................................................................................ 3 1.1.3 Tecnologías de programación distribuida, utilizada en el diseño de un cluster........................................... 5 1.1.4 Cluster, tipos y funcionamiento. .............................................................................................................. 5

1.1.4.1 Mosix una alternativa de alta disponibilidad y balanceo de carga para clusters. ......................................... 6 1.1.4.2 Clusters virtuales ....................................................................................................................................... 9

1.2 SITUACIÓN ACTUAL ................................................................................................................................ 10 1.3 PLANTEAMIENTO DEL PROBLEMA ............................................................................................................... 10 1.4 JUSTIFICACIÓN ...................................................................................................................................... 11 1.5 OBJETIVO GENERAL ................................................................................................................................ 12

1.5.1 Objetivos específicos ............................................................................................................................. 12 1.6 CONTRIBUCIÓN ..................................................................................................................................... 12 1.7 HIPÓTESIS............................................................................................................................................ 13 1.8 METODOLOGÍA ..................................................................................................................................... 13 1.9 ESTRUCTURA DE LA TESIS ......................................................................................................................... 13

CAPÍTULO 2 PRINCIPIOS DE PROCESAMIENTO PARALELO ........................................................... 15

2.1 COMPUTACIÓN PARALELA ........................................................................................................................ 15 2.1.1 El paralelismo explicito. ......................................................................................................................... 16

2.2 LA LEY DE AMDAHL. ............................................................................................................................... 18 2.2.1 Factor de Rendimiento Speedup ............................................................................................................ 19

2.3 ARQUITECTURAS PARALELAS ..................................................................................................................... 19 2.4 TAXONOMÍA DE FLYN ............................................................................................................................. 22

2.4.1 SISD (Single Instruction, Single Data, Una Instrucción, un dato)............................................................... 23 2.4.2 SIMD (Single Instruction Stream, Múltiple Data Stream, Un Flujo de instrucción, Multiple flujo de datos).23 2.4.3 MISD (Multiple Instruction Stream, Single Data Stream, Múltiple flujo de instrucciones, un único flujo de datos). ........................................................................................................................................................... 24 2.4.4 MIMD (Multiple Instruction Stream, Multiple Data Stream, Múltiple flujo de Instrucciones, Multiple flujo de Datos). ...................................................................................................................................................... 24

2.5 EJEMPLOS DE PROBLEMAS PARALELIZABLES .................................................................................................. 25

CAPÍTULO 3 VIRTUALIZACIÓN EN EQUIPOS DE CÓMPUTO .......................................................... 26

3.1 INTRODUCCIÓN ..................................................................................................................................... 26 3.2 ¿QUÉ ES LA VIRTUALIZACIÓN? .................................................................................................................. 26

3.2.1 Historia de la Virtualización ................................................................................................................... 28 3.3 ¿CÓMO TRABAJA UN SISTEMA VIRTUAL?...................................................................................................... 29

3.3.1 Virtualización pura ................................................................................................................................ 30 3.3.2 Virtualización impura ............................................................................................................................ 32

3.4 IMPORTANCIA DE LA VIRTUALIZACIÓN ......................................................................................................... 33

CAPÍTULO 4. DESARROLLO E IMPLEMENTACIÓN ......................................................................... 36

4.1 DIFERENCIAS ENTRE CLUSTERS FÍSICOS Y CLUSTERS VIRTUALES ........................................................................... 36 4.1.1 Clusters físicos....................................................................................................................................... 36 4.1.2 Cluster Virtual ....................................................................................................................................... 37

4.2 DIFERENCIAS ENTRE EL CLUSTER VIRTUAL Y CLUSTER FÍSICO ............................................................................... 38 4.2.1 Características del cluster virtual. .......................................................................................................... 39

4.3 DIFERENCIAS ENTRE CLUSTER FÍSICOS Y CLUSTER VIRTUAL. ................................................................................ 39 4.3 INSTALACIÓN Y CONFIGURACIÓN DEL SOFTWARE EN LA MÁQUINA VIRTUAL Y MÁQUINA FÍSICA. .................................. 40

xi

4.3.1 Pasos para instalar Virtual box para el cluster virtual .............................................................................. 40 4.3.2 Instalación de Opensuse y configuración de la red.................................................................................. 43

4.4 INSTALACIÓN DE MOSIX .......................................................................................................................... 48

CAPÍTULO 5. PRUEBAS DE DESEMPEÑO ...................................................................................... 53

5.1 REQUERIMIENTOS PARA EL CLUSTER FÍSICO Y VIRTUAL ..................................................................................... 53 5.2 METODOLOGÍA ..................................................................................................................................... 54

5.2.1 Pruebas utilizando el algoritmo de Factorial ........................................................................................... 54 5.2.2 Análisis de tiempo de ejecución del algoritmo Factorial, en secuencial, paralelo físico y paralelo virtual .. 56

5.3 ANÁLISIS DEL ALGORITMO DE STRESS UTILIZANDO TRES BUCLES ANIDADOS ........................................................... 59 5.3.1 Análisis de tiempo de ejecución del algoritmo Stress en secuencial, paralelo físico y paralelo virtual ....... 62

5.4 CÁLCULO DE PI POR MEDIO DEL ALGORITMO DE GREGORY- LEIBNIZ.................................................................... 65 5.4.1 Análisis de tiempo de ejecución del algoritmo PI por el método de Gregory- Leibniz en secuencial, paralelo físico, paralelo virtual y su Speedup ................................................................................................................ 66

5.5 ALGORITMO RECURSIVO DE LAS TORRES DE HANOI......................................................................................... 70 5.5.1 Muestras y tiempos secuencial, paralelo físico, paralelo virtual y ganancia en el speedup, con el algoritmo de Torres de Hanoi. ....................................................................................................................................... 71

5.6 MONITORIZACIÓN DE UN PROGRAMA EN EJECUCIÓN....................................................................................... 75

CAPITULO 6: CONCLUSIONES Y TRABAJO A FUTURO ................................................................... 77

6.1 CONCLUSIONES ..................................................................................................................................... 77 6.2 TRABAJOS A FUTURO .............................................................................................................................. 78

REFERENCIAS ............................................................................................................................... 79

ANEXOS ....................................................................................................................................... 81

ANEXO A: INSTALACIÓN DE MOSIX EN OTRAS DISTRIBUCIONES NO SUSE................................................................. 81 ANEXO B : COMANDOS ESENCIALES UTILIZADOS EN MOSIX. ................................................................................ 84 ANEXO C. COMPLEJIDAD COMPUTACIONAL. .................................................................................................... 87

xii

IINNDDIICCEE DDEE FFIIGGUURRAASS

FIGURA No.

Figura 1.1 Los Borg, un cluster Beowulf utilizado por el grupo de la universidad McGill, utilizado para buscar

pulsares binarios. .......................................................................................................................................... 2

Figura 1. 2 Roadrunner el mejor cluster del mundo, creado para la investigación. .......................................... 4

Figura 1. 3 Cluster Iceberg creado en la universidad de Stanford y que soporta balanceo de carga. ................. 8

Figura 1. 4 Cluster Snowwhite con kernel de mosix, con balanceo de carga. .................................................. 9

Figura 1. 5 Grid Mosix trabajando con clusters independientes virtualizados. ................................................ 9

Figura 1. 6 Procesador Intel core 2 dúo con características escalares (fig izq). Procesador AMD, Opteron con

7 núcleos con ambas características escalares y vectoriales (fig der). ........................................................... 16

Figura 2.1 Tipos de paralelismo de Software que se divide en interno y explicito. ........................................ 17

Figura 2.2 Procesadores con memoria distribuida en una red de interconexión Lan. ..................................... 20

Figura 2.3 Procesadores con memoria compartida con acceso no uniforme a memoria NUMA..................... 21

Figura 2.4 Procesadores con memoria compartida con acceso uniforme a memoria UMA. ........................... 21

Figura 2.5 Procesadores con memoria compartida distribuida, por medio de una red global. ........................ 22

Figura 2.6 Taxonomía de Flyn, que muestra las diferentes arquitecturas. ..................................................... 22

Figura 2.7 Arquitectura SISD. ..................................................................................................................... 23

Figura 2.8 Arquitectura SIMD. ................................................................................................................... 23

Figura 2.9 Arquitectura MISD. ................................................................................................................... 24

Figura 2.10 Arquitectura MIMD. ................................................................................................................ 24

Figura 3.1Una máquina virtual. El hipervisor (o monitor de la máquina virtual) presenta una interface que

muestra el hardware al sistema operativo invitado. ...................................................................................... 26

Figura 3.2 El monitor de la maquina virtual comunicando al hardware real con el hardware virtual. ............. 27

Figura 3.3 Instrucciones al crear una excepción entre una máquina anfitriona y una máquina virtual. ........... 31

Figura 3.4 En la técnica de virtualización impura, se reemplazan las instrucciones en el código original por

cualquiera de las instrucciones del hipervisor y salta a emulación a nivel de usuario. ................................... 32

Figura 3.5 Una computadora normal antes de la virtualización .................................................................... 33

Figura 3.6 Computadora después de la virtualización, con múltiples sistemas virtuales. ............................... 34

Figura 3.7 Esquema del cluster con 3 nodos y un nodo maestro. .................................................................. 36

Figura 3.8 Tipos de conexión en una tarjeta de red en Virtual Box. .............................................................. 37

Figura 3.9 Configuración de la tarjeta de red en Virtual Box. ....................................................................... 37

Figura 3.10 Selección de la memoria RAM en la máquina virtual de Virtual Box. ........................................ 41

Figura 3.11Configuración del disco duro virtual en Virtual Box. ................................................................ 41

Figura 3.12 Selección de una imagen de disco (ISO, NRG,etc), para instalar sistema operativo. ................... 42

Figura 3.13Seleccionar el tipo de conexión de Red en Virtual Box. ............................................................. 43

Figura 4.1 Instalando OpenSUSE 11.1, configurando idioma....................................................................... 44

Figura 4.2 Particionar el disco duro en formato ext y configurando el tamaño de la instalación. ................... 44

xiii

Figura 4.3 Gestor de Software de OpenSUSE. ............................................................................................. 45

Figura 4.4 Configuración de Red por YaST. ................................................................................................ 45

Figura 4.5 Configuracion por conexión de Red. ........................................................................................... 46

Figura 4.6 Configuración de direcciones IP en OpenSUSE. ......................................................................... 46

Figura 4.7 Gestor de arranque GRUB, iniciando con kernel Mosix. ............................................................. 49

Figura 5.1 Grafica de prueba secuencial aplicado al algoritmo de Factorial. ................................................. 57

Figura 5.2 Grafica de prueba en cluster fisico, aplicado al algoritmo de Factorial ......................................... 57

Figura 5.3 Grafica de prueba en cluster virtual, aplicado al algoritmo de Factorial ....................................... 58

Figura 5.4 Grafica de comparacion entre tiempos secuencial, cluster fisico y el speedup, aplicado al algoritmo de Factorial. ............................................................................................................................................... 58

Figura 5.5 Grafica de comparacion entre tiempos secuencial, cluster virtual y el speedup, aplicado al

algoritmo de Factorial. ................................................................................................................................ 59

Figura 5.6 Grafica de prueba secuencial aplicado al algoritmo de Stress. ..................................................... 62

Figura 5.7 Grafica de prueba en cluster fisico, aplicado al algoritmo de Stress. ............................................ 63

Figura 5.8 Grafica de prueba en cluster virtual, aplicado al algoritmo de Factorial ....................................... 63

Figura 5.9 Grafica de comparacion entre tiempos secuenciales, cluster fisico y el speedup, aplicado al

algoritmo de Stress. .................................................................................................................................... 64

Figura 5.10 Grafica de comparacion entre tiempos secuencial, cluster virtual y el speedup, aplicado al

algoritmo de Stress. .................................................................................................................................... 64

Figura 5.11 Grafica de prueba secuencial aplicado al algoritmo de PI de Gregory-Leibniz. .......................... 67

Figura 5.12 Grafica de prueba en cluster fisico, aplicado al algoritmo de Pi de Gregory-Leibniz. ................. 68

Figura 5.13 Grafica de prueba en cluster virtual, aplicado al algoritmo de Pi de Gregory-Leibniz. ................ 68

Figura 5.14 Grafica de comparacion entre tiempos secuencial, cluster fisico y el speedup, aplicado al

algoritmo de Pi de Gregory-Leibniz. ........................................................................................................... 69

Figura 5.15 Grafica de comparacion entre tiempos secuencial, cluster virtual y el speedup, aplicado al

algoritmo de Pi de Gregory-Leibniz. ........................................................................................................... 69

Figura 5.16 Grafica de prueba secuencial aplicado al algoritmo de las Torres de Hanoi. ............................... 72

Figura 5.17 Grafica de prueba en cluster fisico, aplicado al algoritmo de las torres de Hanoi. ....................... 73

Figura 5.18 Grafica de prueba en cluster virtual, aplicado al algoritmo de las torres de Hanoi. ..................... 73

Figura 5.19 Grafica de comparacion entre tiempos secuenciales, cluster fisico y el speedup, aplicado al

algoritmo de las torres de Hanoi. ................................................................................................................. 74

Figura 5.20 Grafica de comparacion entre tiempos secuenciales, cluster virtual y el speedup, aplicado al

algoritmo de las torres de Hanoi. ................................................................................................................. 74

Figura 5.21 Monitor del sistema, mostrando el trabajo del CPU, la red, al momento de trabajar con el cluster.

.................................................................................................................................................................. 75

Figura 5.22 Monitoreo de los recursos del procesador, capacidad de la memoria y trabajo en red del

Algoritmo de las Torres de Hanoi en cluster paralelo físico. ........................................................................ 76

xiv

IINNDDIICCEE DDEE TTAABBLLAASS

TABLA No.

Tabla 1. 1 Primeros cluster desarrollados a través del tiempo. ........................................................................ 3

Tabla 1. 2 Mejores clusters del mundo dadas a conocer en www.top500.org. ................................................. 4

Tabla 3. 1 Historia de la virtualización y las máquinas virtuales. .................................................................. 29

Tabla 4.1 Diferencia de costos entre el cluster fisico y el cluster virtual. ..................................................... 40

Tabla 5.1 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo

del Factorial. .............................................................................................................................................. 56

Tabla 5.2 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo de

Stress. ........................................................................................................................................................ 62

Tabla 5.3 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo PI

Gregoy-Leibniz. ......................................................................................................................................... 67

Tabla 5.4 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo

de las Torres de Hanoi. ............................................................................................................................... 72

1

CAPITULO I Introducción

1.1 Sistemas Distribuidos y clusters.

Actualmente, en lo que se refiere a la capacidad de procesamiento, existen varias alternativas en el

mercado, pero muchas de esas alternativas resultan en costos muy altos, tal es el caso de los

mainframes y servidores. El utilizar hoy en día tecnologías muy caras resulta para las pequeñas

empresas, tecnológicos, universidades y cualquier entidad que no tenga recursos, muy difícil el

acceso a este tipo de tecnologías en México. En lo que se refiere a las universidades públicas y

tecnológicas centralizadas y descentralizadas, la investigación en las áreas de matemáticas,

químicas, médicas, etc. han creado una rama que necesita del supercómputo para su desarrollo y

esta rama es la Bioinformatica1, la cual se encarga de estudiar las ciencias antes mencionadas.

Para el estudio o la investigación de la Bioinformatica [18], es necesario tener sistemas

computacionales (con múltiples procesadores), capaces de poder resolver problemas en tiempos

muy cortos, algo que una computadora simple no puede realizar. Hay muchas tecnologías que

actualmente trabajan en el ámbito del procesamiento a gran escala, muchas de éstas incluyen

arreglos de discos, procesadores, utilizan memoria a gran escala lo cual ayudan a realizar

operaciones en tiempos relativamente cortos. Una de estas tecnologías son los servidores y

mainframes, que algunas empresas como: IBM, Sun Microsystems, Hewlett Packard y DELL entre

otros trabajan en el área del procesamiento a gran escala. Pero esta tecnología está al alcance de

medianas y grandes empresas, las cuales tienden a utilizar este tipo de tecnologías por su alto costo.

Actualmente existe otra alternativa para las pequeñas empresas, universidades y departamentos de

investigación: los clusters2 [4]. En la Figura 1.1 se muestra un cluster destinado a la investigación,

en la universidad de McGill.

1 La bioinformática es un campo interdisciplinario que se ocupa de los problemas biológicos usando técnicas computacionales y hace que sea posible la rápida organización y análisis de los datos biológicos.

2 Un conjunto de máquinas unidas por una red de comunicación trabajando por un servicio conjunto. Según el servicio puede ser: Dar

alta disponibilidad, alto rendimiento, etc...

2

Figura 1.1 Los Borg, un cluster Beowulf utilizado por el grupo de la universidad McGill para buscar pulsares binarios.

1.1.1 Sistemas distribuidos como base para la construcción de un cluster.

Los sistemas distribuidos[23] son uno de los paradigmas más importantes utilizados para solucionar

problemas computacionales, incluyendo la programación. A través de este paradigma se han podido

resolver problemas complejos de la ciencia y la tecnología [24]. Sus orígenes remontan desde 1970.

Desde entonces los sistemas distribuidos han sido objeto de investigación continua por parte de

especialistas en sistemas distribuidos, resultando así en avances muy rápidos tanto en el campo de

modelos y tecnologías de programación distribuida como de las infraestructuras conocidas para

ambiente distribuido (clusters, grids, bases de datos distribuidos, etc…).

Los inicios de los sistemas distribuidos, se remontan a los años de 1970, con la aparición de las

minicomputadoras, estaciones de trabajo, computadoras personales (PC’s) y con la red de

computadoras ARPANET3. De los primeros modelos distribuidos, fue importante la contribución de

los primeros sistemas operativos de tiempo compartido, como el sistema Operativo UNIX, que

permite que muchos usuarios trabajen con una sola computadora al mismo tiempo.

El desarrollo de procesadores cada vez más rápidos y más económicos abrió camino a la idea de

crear entornos de computación potentes, poniendo en esto a sistemas capaces de resolver

problemas cada vez más complejos.

3 La primera red de computadoras Advanced Research Projects Agency Network (ARPANET) fue creada por el Departamento de Defensa de los Estados Unidos (DoD), para comunicar las instituciones gubernamentales en Estados Unidos. El primer nodo se creó en la Universidad de California. Fue la base para la red de Internet que se conoce hoy.

3

Las redes de computadoras fueron útiles para la transmisión de información y que con la creación

de Ethernet y ARCnet, ayudaron a que las computadoras pudieran intercambiar y compartir datos.

Las redes de computadoras motivaron el desarrollo de sistemas distribuidos potentes, conectando

muchas computadoras para conseguir así grandes capacidades de cómputo. Actualmente la gran

mayoría de las empresas o instituciones ya cuentan con sus redes internas que permiten sacar

provecho de los recursos. Conectar las computadoras en una red de área local (LAN) o global,

permite que se puedan usar para resolver problemas complejos y así incrementar su uso para

aplicaciones más potentes.

Con la aparición de los clusters [31], se creó una alternativa a las supercomputadoras. Las

supercomputadoras son máquinas especializadas con un alto costo de adquisición y mantenimiento.

En cambio los clusters, son mucho más económicos (al alcance de pequeñas empresas o de

instituciones) y de bajo costo de mantenimiento. Aún así, la capacidad de cálculo ofrecido por los

clusters es suficiente para muchas aplicaciones complejas de la vida real.

De los primeros clusters que se crearon están los clusters Beowulf4. Éste tipo de cluster se conforma

por un grupo de computadoras con una misma configuración que utiliza el sistema operativo Linux

y software gratuito de código abierto (middleware). Este tipo de cluster está en el grupo de los

clusters tipo HPC (Computación de Alto Performance o computación de alto desempeño) y son

capaces de resolver problemas complejos muy utilizados en la computación científica.

1.1.2 Análisis histórico de los clusters y top500.

Los primeros clusters que se desarrollaron (Tabla 1.1) y que fueron creados a partir de los proyectos

de ARCnet, tuvieron que utilizar las tecnologías de la época como procesadores de baja velocidad y

memoria reducida.

Nombre del cluster Nombre Empresa Año de creación

C.mpp DEC PDP-11 1971

Vax-Cluster Arcnet-Datapoint Corporation 1977

Tandem-Himalaya Hewlett Packard 1993

IBM S/390 Parallel Sysplex IBM 1994

Cluster Beowulf NASA 1998

Tabla 1. 1 Primeros clusters desarrollados a través del tiempo.

4 Es un tipo de cluster que fue desarrollado por primera vez en 1994 en la NASA, para solucionar problemas de alto desempeño, y que se conforma de un nodo maestro y nodos clientes, utilizando software conocido como commodities.

4

Para tomar en cuenta el desarrollo e implementación de los clusters en la industria, en la

investigación, en las escuelas, etc. Se creó el proyecto TOP5005 en el año 1993, para detectar los

mejores clusters a nivel mundial, dependiendo de su uso, la cantidad de nodos y su velocidad que se

mide en TeraFlops6. Actualmente top 500 nos muestra el cluster más rápido del mundo, el cual

alcanza una velocidad sorprenden para el cálculo de operaciones por segundo, y es el cluster

RoadRunner (Figura 1.2), del departamento de energía de los Estados Unidos.

Los mejores clusters del mundo son los siguientes (Tabla 1.2):

Lugar Nombre Cluster Velocidad de punto flotante Empresa

1 Roadrunner o Blade Center 1.7 PetaFlops IBM

2 BlueGene 500 TFlops IBM

4 GSIC Center, Tokio Institute of Technology

of Japan

11.72 Giga Flops TSUBAME 2.0

5 Nebulae-Dawnin TC3600 10.64 GigaFlops Center Tianjin

Tabla 1. 2 Mejores clusters del mundo dados a conocer en www.top500.org.

5 Top500 es el sitio (www.top500.org), que muestra las instituciones, el país. Que muestra una lista de los clusters más veloces del mundo, y su velocidad de punto flotante, que van desde los GIGAFLOPS, hasta los PETAFLOPS.

6 Flops son las operaciones de punto flotantes por segundo, es la medida utilizada para cálculos científicos que requieren operaciones de coma flotante. Las medidas que se conocen son: MegaFlops MFLOPS (106), gigaFLOPS GFLOPS (109), teraFLOPS TFLOPS (1012) y petaFLOPS PFLOPS (1015).

Figura 1. 2 Roadrunner el mejor cluster del mundo, creado para la investigación.

5

1.1.3 Tecnologías de programación distribuida, utilizada en el diseño de un cluster.

Desde los inicios de los sistemas distribuidos, la comunidad científica y desarrolladores, se han

interesado por crear modelos de programación distribuida y tecnologías de software que permitan

llevar a cabo estos modelos y al mismo tiempo aprovechar al máximo las prestaciones de hardware,

a fin de obtener aplicaciones distribuidas de alto rendimiento. Algunas de estas tecnologías, se les

conoce con el nombre de Middleware 7, el cual es un software de conectividad y que hace posible el

funcionamiento de las aplicaciones distribuidas. De las tecnologías conocidas de middleware se

mencionan a RPC, DCOM, CORBA, SOAP, XML-RPC, Java, SSI, RMI, MPI, PVM, MOSIX, etc

[6]. También son útiles los lenguajes de programación, debido a que algunos permiten implementar

aplicaciones distribuidas ya sea usando mecanismos propios o librerías de comunicación externas al

lenguaje, las cuales posibilitan el desarrollo de tecnologías distribuidas y por ende la construcción

de clusters. Por ejemplo, muchas de las aplicaciones de Computación de Alto Desempeño utilizan el

lenguaje de programación c/c++, el cual usa la librería de comunicación paralela MPI/PVM.

1.1.4 Cluster, tipos y funcionamiento.

Se entiende por cluster a una agrupación de computadoras independientes llamados también nodos,

que tienen componentes de hardware comunes y que utilizan un software de interconexión, que

hace que éstos funcionen como una sola computadora.

En los ámbitos científicos, los grupos de clusters consisten en nodos de computadoras, nodos de

almacenamiento y uno o más nodos front end (servidores) y en algunos casos hay nodos adicionales

dedicados al monitoreo. Estos nodos pueden estar interconectados por redes diferentes,

generalmente redes de alta velocidad, con un ancho de banda muy alto. Esta velocidad solo puede

ser alcanzada por tecnologías como GigabitEthernet, Myrinet e infiniband, ya que éstos alcanzan

los 40 Gigabits/seg.

El trabajo de los clusters consiste en [4]:

Aumentar la disponibilidad y disminuir la probabilidad de fallos, ya que en caso de que un

equipo en el cluster falle, existe otro que lo reemplace.

Facilitar la escalabilidad, puesto que los equipos interconectados permiten que se añadan

más de estos equipos a la red.

7 Es un software de interconexión, que conecta componentes de software, para compartir recursos a nivel distribuido. Aplicable a servidores, clusters, servicios web y de bases de datos.

6

Permitir el balanceo de carga, debido a que logran la repartición de los recursos de software

a otros nodos de la red.

Facilitar la gestión de los recursos (CPU, RAM, discos duros y ancho de banda).

Dependiendo del tipo de trabajo en el cual se va a desempeñar un cluster, estos se definen como:

Clusters de Alta Disponibilidad (High Availability).- Son clusters, que su funcionalidad trata de que

el trabajo continúe sin interrupciones, todo debido a la alta demanda que generalmente son las 24

horas del día los 365 días del año, por ejemplo el cluster de google, por su alta demanda necesita de

este tipo de clusters para su funcionamiento [3].

Clusters para distribuir, de Alta eficiencia (High Throughput).- Son clusters cuya funcionalidad es

el de ejecutar la mayor cantidad de tareas en un tiempo deseable.

Clusters de alto Desempeño (High Performance).- Este tipo de cluster trabaja con grandes tareas

que requieren un gran desempeño computacional, agotando todos los recursos del cluster por largos

periodos de tiempo hasta que el trabajo se haya terminado correctamente. En equipos de cómputo

individuales, la carga de trabajo provocaría lentitud y bloqueos en el sistema.

1.1.4.1 Mosix una alternativa de alta disponibilidad y balanceo de carga para clusters.

Mosix fue desarrollado en la universidad hebrea de Jerusalén por Amnon Barack y Amnon Siloh

[20], como una alternativa de conexión en red. Mosix es una herramienta creada para balancear la

carga (software en ejecución), de manera que los usuarios no se den cuenta que los procesos del

software en ejecución estén trabajando en segundo orden; al final los nodos del cluster se

comportan como una sola máquina, y de esta forma se incrementa el aprovechamiento de los

programas que corren paralelamente. Mosix fue diseñado para correr en plataformas x86, que

incluyen a computadoras personales, estaciones de trabajo y servidores. Todos estos hosts pueden

ser conectados a través de una red LAN o en una red de interconexión muy rápida. Dependiendo del

tipo de aplicaciones, Mosix puede ser utilizado para la configuración de un pequeño cluster de

computadoras personales que utilizan un estándar de comunicación como: Fast Ethernet (100

Mbps), Gigabit Ethernet (1000 Mbps) o Mirynet8 (10 Gbps), etc.

La principal ventaja de utilizar Mosix es su bajo costo, la comodidad de trabajar con diferente

hardware y sobre todo trabajar con todo el software compatible con Linux, así como ofrecer una

imagen única de sistema (SSI), ser altamente escalable y tener un fácil mantenimiento.

8 Es una red de interconexión de alta velocidad (aprox. 10 Gbps), que utiliza cable de fibra óptica y que sirve para interconectar clusters de computadoras.

7

En un sistema Mosix, los programadores y los usuarios pueden crear aplicaciones y ejecutarlas en

un cluster Mosix, el cual crea múltiples procesos y en forma transparente pueden migrar [22] estos

procesos a los diferentes nodos conectados en la red.

Algunas características del kernel de Mosix son:

Proveer una imagen única de sistema (SSI).- La transparencia de los recursos lo realiza

mediante un algoritmo interno (de colas) dando a cada nodo la información y la

disponibilidad para ejecutar procesos migrados. Mosix trabaja con procesos Linux y Mosix.

Los procesos Linux trabajan normalmente en modo nativo y no son afectados por el trabajo

del kernel de Mosix y no pueden ser migrados. Los procesos de Mosix son aplicaciones de

usuario que se favorecen al ser migrados de nodo a nodo.

Mosix provee un ambiente de ejecución seguro para ejecutar procesos remotos. En el

cluster Mosix solamente se trabajan con procesos conocidos a nivel de kernel de Mosix y

no se toman en cuenta procesos que no sean Mosix, creando así un ambiente de ejecución

seguro.

Trabajo de cola. Se incorpora una cola dinámica que permite trabajar con un número de

tareas, que se pueden ejecutar con procedimientos FIFO (First in, First out, Primero en

entrar, primero en salir).

Soporte de procesos batch, puntos de recuperación y recuperación. Los archivos batch que

se realicen en cualquier nodo, se pueden guardar y posteriormente ejecutar en otro nodo o

en el nodo principal, y además Mosix tiene la capacidad de guardar las imágenes de los

procesos en ejecución, creando así un punto de restauración, almacenando la información

en un archivo batch para que posteriormente pueda ser restaurado.

Cuenta con un monitor, que provee de información sobre los recursos que se están

ejecutando en el cluster y además nos puede mostrar la velocidad del CPU, carga del CPU,

memoria libre, memoria usada, espacio del swap, etc.

Información probabilística y diseminación de algoritmos. El cluster de Mosix provee a cada

nodo suficiente información acerca de los recursos que se encuentran procesando en otros

nodos. En cada intervalo de tiempo, los nodos se envían información acerca de los recursos

que aleatoriamente se ejecutan en ellos.

Procesos de migración preferentes. Cuando se quieren migrar procesos a nivel de usuario,

Mosix busca a los nodos disponibles para ejecutar estos procesos. Los procesos de

migración incluyen costos fijos, y con esto los procesos pueden ser migrados a nodos

disponibles.

8

Balanceo de carga dinámica.- La continua intención de reducir la carga entre diferentes

nodos, se realiza mediante la migración de procesos, Mosix cuenta con algoritmos que se

encargan de balancear estos procesos en cada uno de los nodos del cluster. Para que esto se

pueda llevar a cabo es necesario que estos procesos tengan características de sobrecarga,

aunque esto también depende del número de nodos.

Compartición de memoria.- Otra característica de Mosix, es la prevención en el

agotamiento de la memoria del cluster, ya que generalmente la memoria RAM de cada uno

de los nodos, se hacen uno solo y actúa como una sola memoria RAM de red (UMA,

Acceso de Memoria Uniforme). Mosix cuenta con un algoritmo que hace funcionar a la

memoria cuando siente que en uno de los nodos hay espacio de memoria insuficiente.

En la actualidad al trabajar con cluster de balanceo y que utilice el kernel de Mosix, se espera que

realice trabajos de alto desempeño, como: las simulaciones dinámicas moleculares, generación de

nuevos medicamentos, compresión de archivos mp3, renderización de películas con gráficos de alta

resolución, simulación de ambientes físicos, etc.

Actualmente las instituciones, como la universidad de Stanford, crearon un cluster llamado Iceberg

(Figura 1.3) el cual utilizó 45 nodos y que trabaja mediante Linux con un kernel de Mosix y con

mpi, con el cual se realizan trabajos de simulación de proteínas.

Figura 1. 3 Cluster Iceberg creado en la universidad de Stanford y que soporta balanceo de carga.

9

También en la Universidad de Michigan, en el edificio del centro de Tecnología, se puede encontrar

el desarrollo de un cluster que trabaja con Mosix el cual es llamado CSG Snowwhite o MACC

cluster, y se conforma de aproximadamente de 45 nodos y 244 procesadores (Figura 1.4). Este

cluster se utiliza para la investigación en Genética Humana y ciencias de las matemáticas.

Actualmente se encuentra en uso.

1.1.4.2 Clusters virtuales

En la actualidad, las empresas empiezan a reconocer la importancia de la virtualización, sobre todo

por el valor que toma en las mismas para solventar esquemas de seguridad, espacio y sobre todo el

ahorro de energía eléctrica y de dinero. Existe poca información de clusters implementados

virtualmente. En la universidad de Barcelona se ha trabajado con el Grid Cloud con ayuda de

sistemas virtualizadores como Xen y el sistema para crear cloud como Open Nebula [33]. En lo

referente a Mosix y su trabajo en clusters virtuales, los creadores de Mosix, demuestran que por

medio de máquinas virtuales se pueda crear un Grid de interconexión de clusters virtuales (Figura

1.5), cada uno trabajando en un solo equipo y administrado por dos Workstation [34].

Figura 1. 4 Cluster Snowwhite con kernel de Mosix, con balanceo de carga.

Figura 1. 5 Grid Mosix trabajando con clusters independientes virtualizados.

10

1.2 Situación actual

Actualmente los grandes sistemas de cómputo conocidos como las Mainframe, se siguen manejando

por empresas, centros de investigación, universidades, etc. debido a sus capacidades y al modo de

procesamiento, aunque el clustering sigue siendo la alternativa por su bajo costo. Al utilizar

software libre, como es el caso de Linux, quién debido a su gran desempeño, al manejo de software

libre como Mosix [20] o MPI [12] para la instalación del clustering y programación paralela, los

centros de investigación han optado por esta tecnología. Para un mejor manejo en costo-beneficio,

actualmente se ha manejado el tema de la virtualización como una alternativa para servidores,

almacenamiento, bases de datos y redes de computadoras; sin embargo la idea del clustering

virtualizado es una gran alternativa de seguridad, de ahorro de energía, de costos, etc.

Hoy en día las empresas, centros de investigación, universidades, tienen muchos beneficios al

utilizar la virtualización como una necesidad para la solución de problemas, algunos son: costos,

almacenamiento, distribución en el hardware y software. Para virtualizar se puede escoger la

virtualización por hardware o por software. Para el desarrollo de un cluster tipo HPC (High

Performance clúster), se utiliza la técnica de virtualización completa, en donde se ocupa un

hipervisor que permite la manipulación total de los recursos de un sistema de cómputo, lo cual

permite un mejor desempeño para el manejo de las aplicaciones contenidas en cada una de las

máquinas virtuales sin afectar el funcionamiento de ellas. Para el caso del clúster tipo HPC se

utiliza Virtual Box como una alternativa de software libre para cualquier sistema operativo, debido

a que es un sistema operativo hipervisor, que a su vez es el encargado de comunicar el sistema

operativo virtual con el sistema operativo huésped. Virtual Box reconoce diferentes hardwares

virtuales, ya sean tarjetas de red, tarjetas de sonido, tarjetas de video, etc. El hipervisor [16] es el

encargado de comunicar el hardware virtual con el hardware físico, comunicándose con los

controladores de cada uno de éstos. Además tenemos la facilidad de crear discos duros virtuales que

se pueden resguardar en nuestro equipo o en cualquier medio de almacenamiento, teniendo así

seguridad en el manejo y respaldo de los datos.

1.3 Planteamiento del problema

A través del tiempo se han identificado diversas tecnologías de cómputo, sin embargo estas

tecnologías tienen un tamaño enorme, gastan mucha energía eléctrica, además de que son caros y

se corre el riesgo de tener pérdida de información. Los clusters son de este tipo, se necesitan varios

nodos (computadoras sin monitor, sin teclado, ni mouse), los cuales trabajando en red, realizan

11

operaciones paralelas, para lo cual el cluster al realizar los cálculos, produce una gran cantidad de

calor por parte de los procesadores, convirtiéndose en un problema principal.

En el presente trabajo se pretende crear y evaluar un esquema, utilizando máquinas virtuales para su

funcionamiento y que a su vez permita manejar aplicaciones de alta disponibilidad, que contenga

un cluster virtual, utilizando técnicas de virtualización existentes en el mercado computacional

como por ejemplo: Virtual box, Vmware, Xen, Hyper-V, etc [19]. De lo anterior, es necesario

realizar pruebas que permitan la evaluación del proyecto.

El número de máquinas virtuales depende de las capacidades de hardware con la que cuente el

equipo de cómputo, como una buena cantidad de memoria, buen procesador y un disco duro con

gran cantidad de espacio de almacenamiento. Este equipo puede albergar la cantidad de máquinas

virtuales que se deseen, con el sistema operativo que también se desee. El equipo debe albergar por

lo menos cuatro máquinas virtuales para usarlas como cluster y así tener la alta disponibilidad en la

programación paralela utilizando Mosix. Para alcanzar el objetivo se utilizarán recursos

computacionales que cuenten con todos los requisitos que pide el cluster, así como también un

sistema operativo de distribución Linux, como es el caso de OpenSUSE en su versión 11.1 y el

equipo anfitrión tendrá un sistema operativo de distribución Ubuntu en su versión 9.10, además de

herramientas de clusterización como es el caso de Mosix.

1.4 Justificación

Actualmente las instituciones de investigación necesitan solucionar sus problemas de manera que se

aprovechen los recursos computacionales que puedan emular las características físicas de ciertos

elementos antes de hacerlo en la realidad. Todo lo anterior se logra utilizando los clusters de alta

disponibilidad (HPC), que con la ayuda de las técnicas de Virtualización, permitirá que la creación

de los clusters sean más baratos, se obtenga ahorro en el gasto de energía eléctrica, así como menos

espacio físico y sobre todo más seguridad, debido a que el hacer respaldos de discos duros virtuales

asegura la continuidad del cluster científico tipo HPC [3].

12

1.5 Objetivo general

Diseñar y construir un clúster de kernel de alto desempeño, que trabaje con grandes cantidades de

cálculo utilizando las técnicas de virtualización y que sea compatible con los sistemas físicos.

1.5.1 Objetivos específicos

Particularmente se pretenden realizar las siguientes actividades:

a) Diseñar y construir un protototipo de un cluster tipo HPC virtualizado.

b) Establecer y afinar el prototipo para su buen desempeño.

c) Adoptar el prototipo para que solucione problemas y sea compatible con otros sistemas de

clusters realizados a nivel mundial.

1.6 Contribución

La virtualización representa una gran ventaja para solucionar problemas en los equipos de cómputo,

actualmente muchas empresas están tomando esta alternativa como una solución al manejo de la

información y a un mejor uso de los recursos de los equipos sin importar la arquitectura de software

que se maneje.

Existe una técnica de virtualización conocida como virtualización completa, que se puede

implementar para realizar diferentes aplicaciones dentro de un entorno. La contribución de este

trabajo será proponer una solución de virtualización en la realización de un cluster para la solución

de problemas paralelizables, con lo cual se pretende disminuir costos en lo referente a la compra de

mucho equipo o también contribuyendo a la preservación del medio ambiente a través del ahorro de

energía.

13

1.7 Hipótesis

Al utilizar las técnicas de virtualización, se reducen considerablemente los gastos en la compra de

equipo físico y con esto se aprovecha mejor los recursos de cómputo, reduciendo considerablemente

los costos y espacios. Así se evita la contaminación, ya que estos equipos físicos gastan mucha

energía eléctrica. Las técnicas de virtualización junto con las técnicas de programación paralela,

resultan ser muy necesarias para empresas que no tienen solvencia económica o buscan mejoras de

seguridad en los equipos de cómputo.

1.8 Metodología

El presente trabajo se basó en la investigación documental, estableciendo la base teórica del

problema, investigando y documentando las técnicas de Virtualización, así como los diferentes tipos

de clusters junto a la programación paralela para la solución de problemas.

El lugar de trabajo fue en el Centro de Innovación y Desarrollo Tecnológico en cómputo del

Instituto Politécnico Nacional trabajando paralelamente con el Tecnológico de Estudios Superiores

de Jocotitlán. En los 2 centros de estudios, se realiza investigación avanzada en áreas como:

matemáticas y química, razón por la que se tiene la necesidad de crear un cluster científico tipo de

alta disponibilidad (HPC).

El virtualizador a utilizar en el proyecto es Virtual Box y se van a crear 4 máquinas virtuales

llamados nodo0, nodo1, nodo2 y nodo3; configurándose la red interna para la comunicación entre

ellos, además de almacenamiento y acceso remoto. De igual forma se instaló el Mosix, para la

conexión entre los nodos del cluster.

1.9 Estructura de la Tesis

Esta tesis se compone en dos secciones importantes: en la primera parte se muestran los aspectos

teóricos que son necesarios para escoger el tipo de cluster y el sistema virtual en el cual se va a

trabajar. El primer punto nos da una introducción histórica de los primeros clusters y nos muestra la

forma en que éstos fueron creados, posteriormente en el capítulo dos nos muestra el principio del

procesamiento paralelo. En el tercero nos habla de los tipos y clasificación de clusters,

posteriormente de los tipos y técnicas de virtualización aplicada a un sistema operativo afín. En la

segunda parte se muestra el desarrollo del prototipo, su implementación y funcionamiento.

14

En general, cada uno de los capítulos contiene lo siguiente:

En el capítulo 1.- Aquí se describen los aspectos generales para realizar el trabajo de tesis, así como

aspectos históricos, obteniendo las necesidades y visualizando los problemas a resolver en esta

tesis. Así también se definen los objetivos y las justificaciones correspondientes.

En el capítulo 2.- “Principios de procesamiento paralelo”, se hablará de los tipos de procesadores

así como las leyes que rigen la programación paralela.

En el capítulo 3.-“Virtualización en equipos de cómputo”, en éste se ven antecedentes donde se

muestra el principio del manejo de la información, los tipos y las técnicas de virtualización.

En el capítulo 4.- “Desarrollo e implementación”, en este capítulo se ve como se configuraron el

cluster fisico y el cluster virtual, así como lo referente a la red, al sistema operativo, a las máquinas

virtuales y al kernel de Mosix.

En el capítulo 5.- “Pruebas de desempeño”.- En este capítulo se mencionan las pruebas realizadas

tanto al cluster físico como al virtualizado mediante algoritmos con complejidad computacional que

alcancen los objetivos de la paralelización.

En el capítulo 6.- “Conclusiones y trabajos a futuro”, se presentan los puntos importantes que

destacan en el trabajo, así como las recomendaciones para trabajos posteriores.

15

CAPÍTULO 2 Principios de procesamiento paralelo

2.1 Computación paralela

La computación paralela es una forma en la que muchas instrucciones se llevan a cabo al mismo

tiempo, el principio de la computación paralela tiene el principio de que los problemas grandes se

puedan dividir en otros más pequeños y que pueden resolverse al mismo tiempo (en paralelo). Hay

muchas formas de ver a la computación paralela, como [8]:

Paralelismo a nivel de bit. Es la forma de ejecutar los bit de un operando directamente a la

unidad aritmética y lógica del procesador.

Paralelismo a nivel de instrucción. Es la forma de ejecutar instrucciones del lenguaje

ensamblador.

Paralelismo de datos. Se ejecuta código de un programa realizado en lenguaje de medio o

alto nivel y puede ser ejecutado como proceso y en forma paralela en cada procesador.

Paralelismo de tarea. El conjunto de procesos conforman una tarea, la cual puede ser una

aplicación o software a ejecutar paralelamente, todo esto a nivel de usuario.

La computación paralela se ha utilizado desde hace muchos años, principalmente en la computación

de alto rendimiento, pero su uso ha ido en aumento debido a la velocidad de los procesadores.

La computación paralela se ha convertido en el paradigma dominante de la arquitectura de

computadoras, principalmente en la aparición de los procesadores de múltiples núcleos.

Las computadoras en paralelo pueden ser clasificadas por el nivel de paralelismo, con el hardware y

el software que están ocupando o si es compatible con las nuevas arquitecturas para computadoras,

y las nuevas tecnologías de red [9].

El paralelismo interno

Este tipo de paralelismo consiste en dividir la ejecución de un proceso en etapas consecutivas que se

pueden realizar de manera independiente. A esta división se le conoce como segmentación de

instrucciones y se hace a nivel de procesador con manejo de bits y con instrucciones en

ensamblador, cada uno de ellos controlados por ciclo de reloj del procesador.

El paralelismo interno se puede ejecutar tanto en procesadores escalares como en procesadores

vectoriales. Los procesadores escalares (Figura 2.1 izquierda), pueden procesar un dato por

instrucción asignada, generalmente el trabajo de los procesadores de este tipo es con números

enteros y de punto flotante y trabajan instrucciones de clase de 32 bits. Los procesadores vectoriales

(Figura 2.1 derecha), pueden manipular muchos datos por una instrucción o procesos asignados al

16

procesador. Existen dos tipos de máquinas con arquitectura que soporta un juego de instrucciones

vectoriales, los tipos de computadoras son:

Computadoras vectoriales segmentadas, con una unidad aritmética y lógica segmentada.

Computadoras SIMD, con múltiples unidades aritmético-lógicas segmentadas.

2.1.1 El paralelismo explicito.

Este tipo de paralelismo (Figura 2.2), está orientado a software y la forma de trabajar es mediante

directivas (librerías) y llamadas por funciones de propósito especial. Para trabajar paralelamente se

tienen que sincronizar los procesadores y posteriormente repartir los procesos o las tareas. Este tipo

de paralelismo se relaciona con la programación de bajo nivel, de medio nivel y programación a

alto nivel que tiende a trabajar paralelamente con o sin librerías. El paralelismo explícito se divide

en paralelismo de grano grueso, de grano medio y de grano fino o delgado.

El paralelismo de grano grueso, su funcionamiento es a nivel de aplicación y trabaja con

decenas de miles de instrucciones, puede ser explotado por el S.O.

El paralelismo de grano medio, su funcionamiento es a nivel de programador y con ayuda

del preprocesador puede explotar hasta mil instrucciones.

El paralelismo de grano fino, su funcionamiento es a nivel de compilador y puede ser

también ejecutado por el microprocesador y puede manejar hasta 500 instrucciones.

Figura 2.1 Procesador Intel core 2 dúo con características escalares (fig izq). Procesador AMD, Opteron con 7 núcleos con ambas características escalares y vectoriales (fig der).

17

En el software es difícil conseguir programas que se puedan paralelizar, ya que el software

normalmente fue diseñado para trabajar secuencialmente. La comunicación y sincronización entre

las diferentes subtareas es típicamente uno de los más grandes problemas para paralelizar el

software. Para conseguir que un programa se pueda paralelizar es necesario medir la aceleración del

programa en ejecución y esto se puede realizar mediante la Ley de Amdahl9.

9 Esta ley que mide la mejora de un sistema paralelizado, fue creado en 1967 por Gene Amdahl, arquitecto computacional.

A1 A2 An

P1 P1 P2 P2

For i= 1 to 9 ------- end

For j= ……. ------- end

For i= 1 to 4 ------- end

For j= 5 to 9 ------- end

ADD R1, R1, #1 ADD R2, R2, #1

ADD R3,R3, #1

ID IF EX ME WB

+ -

THREADS

P

AR

ALE

LIS

MO

INT

ER

NO

PA

RA

LELI

SM

O E

XP

LIC

ITO

G

RA

NO

FIN

O

GR

AN

O M

ED

IO

GR

AN

O G

RU

ES

O

Figura 2.2 Tipos de paralelismo de Software que se divide en interno y explícito.

18

2.2 La ley de Amdahl.

En la programación de computadoras, la ley de Amdahl [8], trata que cuando se ejecuta un

programa en procesamiento paralelo, las instrucciones aunque sean restringidas pueden ser un

factor que limite el funcionamiento para la obtención de los resultados, de manera que al añadirse

más procesadores puedan realizar el programa más rápido. Hay determinadas aplicaciones que se

pueden paralelizar y que necesitan solamente un procesador para que se compile. Esta ley nos dice

en dos puntos importantes, que:

1.- La fracción de tiempo de cálculo de la máquina, originalmente se pueda utilizar para optimizar

la mejora, y se le denomina fracción mejorada (fm) y [fm ≤ 1].

2.- La optimización lograda por el modo de ejecución mejorada; es decir, es el tiempo de modo

original con respecto al tiempo del modo mejorado y siempre es mayor que 1 y se le denomina

aceleración mejorada (Am), [Am >1].

Donde:

A= Aceleración global de un sistema con una determinada mejora en un elemento.

Fm= Fracción mejorada de tiempo que utiliza el elemento mejorado.

Am= Aceleración mejorada conseguida para el elemento aislado.

Si se sustituye el disco de una computadora por otro, con un ancho de banda de 4 veces el original.

¿Qué ganancia se puede obtener con esa mejora, en un programa con 30 segundos de ejecución con

el disco original, sabiendo que la CPU, accede al disco durante 16 segundos?

Am= 4.

Fm=16/30 = 0.53.

Aceleración global=1.68.

¿Cuál será la mejora total de un sistema, al que se le ha cambiado un elemento por otro 100 veces

más rápido, pero que solo se utiliza el 10% del tiempo?

19

Am=100.

Fm=0.1.

A=1.10987

2.2.1 Factor de Rendimiento Speedup

El factor de rendimiento Speedup deriva de la ley de Amdahl y que mide la aceleración global, es

una fórmula que calcula la ganancia que existe entre un sistema que contiene un solo procesador

comparándolo con otro sistema que contiene muchos procesadores (multiprocesador). El speedup

obtiene la efectividad que puede tener un programa que se paraleliza frente a un programa que se

ejecuta secuencialmente tomando los tiempos al momento de la ejecución de estos programas

(paralelo y secuencial), y se calculan en la fórmula de rendimiento de Speedup para saber la

ganancia al momento de comparar si es mejor compilar un programa en forma secuencial o

realizarlo paralelamente.

Donde:

Ts=Tiempo secuencial.

Tp= Tiempo paralelo.

Se tiene la ejecución de un programa en una sola computadora, el tiempo de ejecución de dicho

programa fue de 8 hrs, se ejecutó el mismo programa en un ambiente paralelo con 5 procesadores,

y el tiempo que alcanzó fue de 6 hrs. Se necesita calcular el speedup, o factor de rendimiento entre

la ejecución en secuencial y la ejecución en paralelo.

Ts=8.

Tp=6.

Speedup=8.3 hrs.

2.3 Arquitecturas paralelas

Actualmente las arquitecturas de los procesadores [14] cambian constantemente y a pasos

agigantados, esto también se aplica a las arquitecturas paralelas y multiprocesadores, ya que

aparecen nuevas técnicas de paralelismo y con esto nuevas formas de aplicar la programación a

estas nuevas arquitecturas.

20

Las arquitecturas de los procesadores son más conocidos por el manejo de la memoria, y se

subdivide en procesadores con memoria compartida, procesadores con memoria distribuida y

procesadores con memoria compartida distribuida, la cual entra en el tipo de procesadores con

memoria compartida.

a) Procesadores con Memoria Distribuida. Este tipo de procesadores (Figura 2.3), distribuye

su memoria con los demás procesadores conectados en red, trabaja con el modelo de

programación de pasos de mensajes. Para poder comunicar a los procesadores se trabaja

con la clasificación de programación explícita, es aquí donde el programador paraleliza los

mensajes entre los procesadores.

b) Procesadores con memoria compartida [9].

Los sistemas de multiprocesadores y multicomputadoras, contienen individualmente a su

memoria, pero cuando se conectan mediante una red comparten su memoria, sin embargo

los procesadores interconectados no pueden acceder a la memoria al mismo tiempo.

Estos pueden identificarse según el acceso a la memoria como: memoria de acceso no

uniforme (NUMA, Figura 2.4), y memoria de acceso uniforme (UMA, Figura 2.5).

MEMORIA

ALU Sección de

Registros. Sección de control y temporización

RED DE INTERCONEXIÓN

MEMORIA

ALU Sección de

Registros.

Sección de control y temporización

MEMORIA

ALU Sección de

Registros. Sección de control y

temporización

Figura 2.3 Procesadores con memoria distribuida en una red de interconexión LAN.

21

c) Procesadores con memoria compartida distribuida.

Las computadoras conectadas en la red contienen 2 o más procesadores y con una sola memoria

para este equipo multiprocesador (Figura 2.6), este equipo se puede conectar a la red y compartir

sus recursos con otros equipos multiprocesadores en la red. El acceso a la memoria de cada una de

las computadoras multiprocesador depende de la velocidad de la red a la cual accedan.

RED DE INTERCONEXIÓN

MEMORIA

ALU Sección de

Registros.

Sección de control y temporización

ALU Sección de

Registros.

Sección de control y temporización

ALU Sección de

Registros.

Sección de control y temporización

ALU Sección de

Registros. Sección de control y temporización

MEMORIA

RED DE INTERCONEXIÓN

ALU Sección de

Registros. Sección de control y temporización

ALU Sección de

Registros. Sección de control y temporización

ALU Sección de

Registros. Sección de control y temporización

ALU Sección de

Registros. Sección de control y

temporización

MEMORIA MEMORIA MEMORIA

Figura 2.4 Procesadores con memoria compartida con acceso no uniforme a memoria NUMA.

Figura 2.5 Procesadores con memoria compartida con acceso uniforme a memoria UMA.

22

2.4 Taxonomía de Flyn

Mediante la taxonomía de Flyn (Figura 2.7), se pueden reconocer a las diferentes arquitecturas

paralelas, según el número de procesadores y la forma de utilizar la memoria. Esta taxonomía [31]

reconoce varias familias de computadoras que son: SISD, SIMD, MISD y MIMD. Cada una de

estas categorías de computadoras pueden tener uno o más procesadores, pueden ser escalares o

vectoriales dependiendo de la categoría en la que se definan.

Figura 2.6 Procesadores con memoria compartida distribuida por medio de una red global.

Figura 2.7 Taxonomía de Flyn que muestra las diferentes arquitecturas.

23

2.4.1 SISD (Single Instruction, Single Data, Una Instrucción, un dato).

Genera un único flujo de instrucciones que se decodifican e interpretan en la unidad de control y

envían las correspondientes señales de control a la unidad de procesamiento. La unidad de

procesamiento posee un flujo único de datos con la memoria principal (Figura 2.8).

Donde:

FI.- Flujo de instrucciones.

FD.- Flujo de Datos.

I/O.- Puertos de Entrada/Salida

UC.- Unidad de control

UP.- Unidad de procesamiento.

UM.- Unidad de Memoria.

2.4.2 SIMD (Single Instruction Stream, Múltiple Data Stream, Un Flujo de

instrucción, Multiple flujo de datos).

En este tipo de computadora los elementos que se procesan se supervisan por una sola unidad de

control. Los procesadores de este tipo de computadoras reciben una instrucción similar desde la

unidad de control (Figura 2.9).

Donde:

FI.- Flujo de Instrucciones

FD.- Flujo de Datos.

UC.- Unidad de Control

UP.- Unidad de Procesamiento.

UM.- Unidad de Memoria.

Figura 2.8 Arquitectura SISD.

Figura 2.9 Arquitectura SIMD.

24

2.4.3 MISD (Multiple Instruction Stream, Single Data Stream, Múltiple flujo de

instrucciones, un único flujo de datos).

En este tipo de computadoras, existen P procesadores (P>1), cada uno con su propia unidad de

control y comparten una unidad de memoria común donde residen los datos.

En cada paso, un dato recibido desde la memoria es operado por todos los procesadores

simultáneamente, cada uno con las instrucciones que el procesador recibe de su unidad de control

(Figura 2.10).

Donde:

UC.- Unidad de control.

UP.- Unidad de procesamiento.

UM.- Unidad de Memoria.

FI.- Flujo de Información.

FD.- Flujo de Datos.

2.4.4 MIMD (Multiple Instruction Stream, Multiple Data Stream, Múltiple flujo de

Instrucciones, Multiple flujo de Datos).

Esta clase de computadora es la más general y la más poderosa en el paradigma de la computación

paralela. Existen P procesadores (P > 1), cada uno de los operandos trabajan bajo el control de una

secuencia de instrucciones que es emitida por su propia unidad de control. Así los procesadores

están potencialmente todos ejecutándose en diferentes programas sobre datos diferentes, lo que

significa que los procesadores operan de manera asíncrona. El intercambio de datos se lleva a cabo

a través de una memoria común o por medio de una red de interconexión (Figura 2.11).

Donde:

FI.- Flujo de Información.

FD.- Flujo de Datos.

UC.- Unidad de Control.

UP.- Unidad de Procesamiento.

Figura 2.10 Arquitectura MISD.

Figura 2.11 Arquitectura MIMD.

25

2.5 Ejemplos de problemas paralelizables

Dependiendo del software y del tipo de equipo computacional a utilizar, se debe analizar el tipo de

hardware y software con el que se cuenta, así como determinar si el programa es paralelizable o no.

Además en el hardware verificar el poder de cómputo con el que se cuenta, ya que actualmente las

nuevas tecnologías multicore y los GPUs, realizan ejecuciones de programas que antes no se

realizaba en computadoras con un procesador de un solo núcleo.

El software es importante, ya que hoy en día el sistema operativo debe cumplir con la expectativa

de manejo de múltiples usuarios y múltiples procesos, aquí se utilizan sistemas operativos como

Linux [7], además de que si se va a utilizar un lenguaje de programación para solucionar los

problemas paralelos, se debe verificar a qué nivel de programación se va a realizar el código, por lo

general para manejo de multinucleos se recomienda un lenguaje con manejo de Threads (hilos), los

lenguajes de alto nivel como Java, borland c++ y visual .Net, cumplen con estas características. Si

se quiere paralelizar a nivel de red, es necesario crear un sistema de imagen único en cada nodo de

la red y utilizar librerías de interconexión entre nodos, como MPI o PVM, que se pueden utilizar en

lenguajes de programación de medio y alto nivel como C o Fortran [8].

26

CAPÍTULO 3 Virtualización en equipos de cómputo

3.1 Introducción

La virtualización ha sido un tema relevante en el ámbito empresarial desde hace mucho tiempo,

pero se ha convertido en una importante tecnología para los llamados sistemas embebidos, por lo

tanto también es importante para los desarrolladores de los mismos. Para entender el poder y las

limitaciones de la virtualización en este espacio, este documento presenta una introducción a la

tecnología de virtualización en general y específicamente se discute su aplicación a sistemas

embebidos. Existen diferencias inherentes entre el estilo empresarial de los sistemas de

virtualización y la virtualización que se aplica a los sistemas embebidos. La virtualización tiene

beneficios, especialmente en lo que respecta al apoyo a los sistemas integrados, que se conforman

por subsistemas con una amplia variedad de características y de requisitos con respecto a la

seguridad y protección de las redes en Internet. A continuación se discuten las limitaciones de los

enfoques de virtualización de fricción, específicamente en lo que se aplica a sistemas embebidos.

Estos se refieren a la naturaleza altamente compuesta de los sistemas integrados y en particular a lo

que se refiere a la seguridad y fiabilidad.

3.2 ¿Qué es la Virtualización?

La virtualización se refiere a proveer al software un ambiente en el que los programas, incluyendo a

los sistemas operativos, puedan correr en un hardware ligero y virtual. A tal software se le

denomina máquina virtual (VM) [17]. Esta máquina virtual (ver Figura 3.1), es un software

eficiente que emula un ambiente de hardware y software aislado de la verdadera máquina.

Figura 3.1 Una máquina virtual. El hipervisor (o monitor de la máquina virtual) presenta una interface que muestra el hardware al sistema operativo invitado.

Aplicaciones

Sistema Operativo

Hypervisor

Procesador

27

En la figura 3.2 se muestra la capa del software que provee el ambiente VM y a este se le llama

monitor de la máquina-virtual (VMM) o también en algunos casos se le conoce como hipervisor.

En orden a la figura mostrada, el monitor de la máquina virtual (VMM) [17], se compone de 3

características esenciales:

1. La máquina VMM provee al software un ambiente que esencialmente identifica al

software de la máquina virtual con la máquina original.

2. Los programas al correr en el ambiente de la máquina virtual decrementan su

velocidad en lo referente a como se ve en la máquina verdadera.

3. La VMM está en completo control de los recursos del sistema.

Estas tres características son importantes y contribuyen a que la virtualización sea muy eficaz hoy

en día para ambientarse en diversos sistemas operativos en un solo sistema de hardware.

La primera característica (similitud), asegura que el software que se ejecuta en la máquina real se

ejecutará en la máquina virtual y viceversa. La segunda (eficiencia), asegura que la virtualización es

viable desde el punto de vista de rendimiento. La tercera (control de recursos), garantiza que el

software no puede salir de la máquina virtual.

El término de máquina virtual también se aplica a otros ambientes de software útiles para correr

otras aplicaciones, como la Máquina Virtual de Java. Esto se conoce como una máquina virtual de

proceso, mientras que una máquina virtual corresponde al hardware actual y puede ejecutar los

sistemas completos de funcionamiento, a esto se le denomina como máquina virtual VM [16].

Las máquinas virtuales enmascaran los recursos de la computadora, incluyendo su identidad en el

cual se ocultan el sistema operativo, las aplicaciones y el hardware mismo de la máquina anfitriona.

VM

Guest OS

Drivers virtuales

App

VM

Guest OS

Drivers virtuales

App

VM

Guest OS

Drivers Virtuales

App

VMM Hardware Emulado

Drivers Reales

Hardware Real

Figura 3.2 El monitor de la máquina virtual comunicando al hardware real con el hardware virtual.

28

El administrador de la máquina virtual utiliza una aplicación de software para dividir la máquina

física en múltiples entornos virtuales aislados. Estos entornos virtuales se denominan máquinas

privadas virtuales, pero también se les conoce con el nombre de invitados (Guest), al momento de

emular su funcionamiento dentro de la máquina o computadora anfitriona.

3.2.1 Historia de la Virtualización

El funcionamiento de la máquina virtual (virtual machine VM), es la creación de múltiples entornos

de ejecución múltiples en un equipo, cada uno de estos entornos se emulan en un solo equipo. Esto

ante los usuarios se les muestra como una ilusión de que el sistema operativo trabaja realmente en la

máquina física [19]. Las máquinas virtuales van más allá de la emulación y recrean un entorno real,

en el cual se pueden realizar operaciones como si se tratase de la máquina física.

Para que las máquinas virtuales de hoy pudieran alcanzar el desarrollo que actualmente se tiene,

tuvieron que suceder muchos cambios e innovaciones (Tabla 3.1). El sistema operativo que inició

con la virtualización fue VM/370 que se utilizó en la computadora IBM 370 a finales de 1972, esta

versión fue de uso empresarial, aunque posteriormente se creó una computadora de versión

universitaria con un sistema operativo Control Program (CP ) para la máquina model 67. En las

máquinas VM/370 y Control Program, se podía trabajar con varias computadoras a manera de

terminal, haciendo pensar al usuario que estaba trabajando directamente desde su terminal. En 1995

Windows NT y sus versiones posteriores incorporaron una máquina virtual, para simular al sistema

operativo MS-DOS, cuando anteriormente MS-DOS era el sistema operativo principal de toda

computadora x86. Años más tarde Windows server 2008 integró un hipervisor para la simulación de

sistemas operativos en terminales (clientes ligeros). En 1990 el sistema operativo Linux, se utilizó

en un entorno de virtualización de código abierto (Xen), que apareció simultáneamente con el

sistema virtualizado Vmware el cual era costoso y no de código abierto. Estos sistemas tenían

problemas que fueron solucionados posteriormente, algunos problemas fueron:

El soporte a varios sistemas operativos.

Migración de un sistema operativo a una versión posterior.

Trabajar a nivel de Bios.

Reconocer los diferentes drivers de hardware real y llevarlos al hardware virtual.

Al solucionar estos problemas, las compañías de software vieron que los beneficios al utilizar la

tecnología de máquinas virtuales fueron las siguientes:

Baja utilización de una infraestructura. Al ocupar una máquina virtual se logra un promedio de

utilización de aproximadamente el 15% de su capacidad, con lo cual disminuye el utilizar muchos

servidores y ocupar más espacio.

29

Incremento de los costos de infraestructura física. Al ocupar muchos servidores y que estos

trabajen todo el día, implica en un mayor consumo de energía eléctrica, refrigeración, etc. Pero al

virtualizar estos servidores se reducen considerablemente los costos.

Protección ante desastres y fallos. Ante un desastre o alguna falla repentina sea humana o no, los

sistemas virtualizados proporcionan la seguridad de respaldos, con lo cual se puede recuperar

información importante para las empresas.

Nombre de Software Computadora Año de

creación Empresa

CP Model PC 1966 IBM

System/360 IBM 370 1972 IBM

VM/370 IBM 370 1972 IBM

Smalltalk Pc 1981 Xerox

Maq. Virtual de java Pc 1990 Sun microsystems

Vmware server y cliente. Todas las arquitecturas 1998 Vmware inc.

Xen Todas las arquitecturas 2003 Citrix inc.

Virtual Box Todas las arquitecturas 2007 Oracle

Tabla 3.1 Historia de la virtualización y las máquinas virtuales.

3.3 ¿Cómo trabaja un sistema virtual?

La función de la eficiencia requiere que la gran mayoría de las instrucciones deben ser ejecutadas

directamente por el hardware: todas las formas de emulación o la interpretación de hardware se

sustituye a una sola: la máquina virtual. Las instrucciones dadas en la máquina virtual son

realizadas por el hardware subyacente. Esto requiere que el hardware virtual sea casi idéntico al

hardware físico y todo esto se encuentra alojado en el hipervisor.

Hay pequeñas diferencias entre las máquinas virtuales y las máquinas físicas. Por ejemplo, la

máquina virtual tiene instrucciones extras como las referentes al hardware y aplicaciones que en una

máquina física no encontramos.

El hardware físico puede tener una unidad diferente de administración de memoria o de dispositivos

que el hardware original tiene a nivel de BIOS [32]. La máquina virtual puede tomar forma de una

versión antigua de una placa base y ejecuta código heredado para sistemas antiguos o puede a su

vez ejecutar código actual para placas bases modernas. Las diferencias entre hardwares y sistemas

operativos no se notan en las máquinas virtuales, la virtualización puede ser tan eficiente como si

30

fuera el hardware mismo. De hecho no todas las instrucciones se ocupan directamente en la

máquina virtual, sino que también ejecutan recursos de la máquina física. Esto significa que esas

instrucciones deben ser interpretadas por el hipervisor (VMM) o de lo contrario la virtualización no

funciona.

Específicamente, las máquinas físicas tienen dos clases de instrucciones que pueden ser

interpretadas por la máquina virtual:

Control sensitivo de instrucciones. Este modifica a la máquina de estados privilegiados y

permite que el hipervisor tome el control sobre los recursos.

Instrucciones de comportamiento sensibles. Que el acceso o lectura de la máquina física sea en

estado privilegiado mientras que no se puedan cambiar las asignaciones de recursos utilizados

en la computadora, las cuales revelan el estado de los recursos reales y la diferencia de éstos

con los recursos virtuales, por lo tanto el control de los recursos físicos los toma por aparte o

virtualiza la máquina virtual.

Los dos controles, el control sensitivo y las instrucciones de comportamiento sensibles también

son llamados como virtualización-sensitiva [19] o simplemente instrucciones sensitivas.

Ellos son dos caminos básicos que aseguran que el código corra en la máquina virtual y

ejecuten instrucciones sensitivas, tales como:

a) La virtualización pura: garantiza que las instrucciones sensibles no puedan ejecutarse dentro

de la máquina virtual sino todo el trabajo se lo deja al hipervisor.

b) La virtualización impura: Elimina los datos sensibles de la máquina virtual y lo reemplaza

con el código de la virtualización.

3.3.1 Virtualización pura

La virtualización pura es un enfoque clásico de la virtualización. Se requiere que todas las

instrucciones a nivel de máquina virtual estén a nivel privilegiado. Estas instrucciones privilegiadas

se ejecutan con éxito en el procesador (normalmente a esto se le llama modo privilegiado, en el

modo de núcleo o modo supervisor) y cuando los procesos no se ejecutan en modo privilegiado

entran en una parte de la memoria real de la máquina física, al cual se le conoce como modo no

privilegiado (también llamado modo de usuario), como se muestra en la Figura 3.3. Una excepción

entra en el modo privilegiado en una dirección específica de su memoria, pero también forma parte

de la memoria física real, creando con esto una excepción, que forma parte del hipervisor.

31

Figura 3.3 Instrucciones al crear una excepción entre una máquina anfitriona y una máquina virtual.

La virtualización pura entonces sólo requiere la ejecución de todo el código en la máquina virtual

sin privilegios del modo de ejecución del procesador. Las instrucciones sensibles que figuran en el

código que se ejecuta en la máquina virtual caen en una trampa dentro del procesador, así como la

memoria principal que se encuentran en el hipervisor. El hipervisor interpreta (virtualiza) la

instrucción según sea necesario para mantener el estado de la máquina virtual.

Hasta hace poco la virtualización pura era imposible en casi todas la arquitecturas contemporáneas,

ya que todos ellos destacan instrucciones sensibles que no tuvieron privilegios (y por tanto el acceso

se hace en forma física), como en el caso de instrucciones que se crean al introducir una memoria

USB, la cual primeramente es reconocida por la máquina física y posteriormente el hipervisor toma

los controladores de la máquina física y le pasa el control a la máquina virtual. Cada fabricante de

máquina virtual crea sus propias tecnologías virtualizadas de placas base, memoria, procesador,

disco duro y toman características de fabricantes, como en el caso de algunas máquinas virtuales

como Virtual Box, el cual tiene la configuración para los dos microprocesadores líderes en el

mercado como los son Intel (VT-x) y AMD (AMD-V) [14]. Hay muchas razones o alternativas por

lo que la virtualización pura es muy utilizada. Una de estas características es que las excepciones

son mitad procesadas por la máquina virtual y la otra mitad por la máquina física. En los

procesadores pipeline10

, una excepción drena la información que viaja en sus tuberías o líneas de

comunicación, lo que resulta en la demora en el procesamiento por lo general medido en ciclos por

segundo. Una singular demora normalmente ocurre cuando se cambia de modo virtual a modo

usuario, esto da a lugar una latencia adicional. Generalmente de 10 a 20 ciclos por segundo, eso

como decíamos en procesadores pipeline de alto rendimiento. La familia x86 pertenece a los

10 Un solo procesador, el cual puede realizar simultáneamente operaciones de cálculos en determinadas secciones, con diferentes estadios de completitud. Los procesadores pipeline se basan en el principio de dividir los cálculos entre una cantidad de unidades funcionales que operan simultáneamente existiendo superposición

32

procesadores pipeline y por lo general son ocupados tanto en las máquinas virtuales como en las

máquinas físicas.

3.3.2 Virtualización impura

La virtualización impura requiere cambiarse de modo no-privilegiado, a instrucciones sensitivas

para ejecutarse en la máquina virtual, esto se puede ver en la Figura 3.4. Esto sucede de manera

transparente, mediante la técnica de traducción a código binario, aquí el código ejecutable se

escanea en tiempo de carga y cualquier instrucción que cause problemas se sustituye por

instrucciones que hacen una excepción (o proporciona virtualización por otros medios, tales como

el mantenimiento de hardware virtual).

Figura 3.4 En la técnica de virtualización impura, se reemplazan las instrucciones en el código original por cualquiera de las instrucciones del hipervisor y salta a emulación a nivel de usuario.

Una alternativa es evitar las instrucciones problemáticas, que de aparecer en el código ejecutable

crean más problemas. Esto se puede hacer en tiempo de compilación mediante una técnica que se

utiliza antes de la virtualización. Como alternativa, el código fuente puede ser modificado

manualmente para quitar el acceso directo al estado privilegiado y sustituirlo por acceso a llamadas

explícitas del hipervisor llamadas Hypercalls. Este enfoque de virtualización se le conoce como

para-virtualización. La operación sigue siendo la misma que en la virtualización pura. El código se

ejecuta en resultados en modo de ejecución no privilegiado del procesador y un evento de

virtualización está a cargo del hipervisor. La para-virtualización y pre-virtualización tienen otra

ventaja: además de poder tratar con el hardware que no es adecuado para la virtualización pura, se

pueden reemplazar secuencias de muchas instrucciones sensibles por una sola llamada al hipervisor,

33

reduciendo así el número de procesos, que cambia entre el modo sin privilegios y con privilegios.

Como tal trabajo es impuro, la virtualización tiene el potencial para reducir la sobrecarga de

virtualización, que hace atractivo al hardware que sea completamente virtualizable [16].

3.4 Importancia de la Virtualización

La virtualización describe ampliamente la separación de un recurso a solicitud de un servicio. Con

la memoria virtual, por ejemplo, el software obtiene acceso a más memoria de máquina física a

través del intercambio de datos de almacenamiento en disco. Del mismo modo, las técnicas de

virtualización se aplican a una serie de capas de abstracción, en el cual se pasa de las capas de

hardware hasta las capas de software. En todas estas capas influye mucho el hipervisor, por

ejemplo, en lo que se refiere al hardware podemos encontrar: tarjetas de red, almacenamiento o

hardware adicional; y en lo referente al software podemos encontrar: al BIOS, los sistemas

operativos y otras aplicaciones.

Esta mezcla de tecnologías de virtualización o de infraestructura virtual no es perjudicial, ya que la

experiencia de los usuarios al interaccionar con lo virtual es semejante como cuando se actúa con

una máquina verdadera.

Sin embargo, la infraestructura virtual ofrece a los administradores la ventaja de manejar o

administrar los recursos de hardware y software eficientemente.

Características de los sistemas antes de la virtualización (ver Figura 3.5):

Una sola imagen del sistema operativo por máquina.

Software y hardware estrechamente acoplados.

Al ejecutar varias aplicaciones en la misma máquina a menudo crea conflictos.

Inflexibles y costosas infraestructuras.

Figura 3.5 Una computadora normal antes de la virtualización

34

Después de utilizar la virtualización pasa lo siguiente (ver Figura 3.6):

El hardware es independiente del sistema operativo y de las aplicaciones.

La máquina virtual puede ser suministrada y manejada por cualquier sistema.

Puede administrar sistemas operativos y a las aplicaciones como a una sola unidad,

encapsulándolos en máquinas virtuales.

Figura 3.6 Computadora después de la virtualización, con múltiples sistemas virtuales.

Usando la infraestructura virtual, se tienen muchas soluciones para empresas expertas en

Tecnologías de la información (IT), estas son las características que se pueden realizar con la

tecnología virtual:

Test de desarrollo y Optimización. Rápido aprovisionamiento de prueba y desarrollo de

información mediante la reutilización de los servidores preconfigurados. Con esto se pueden

encontrar errores en las máquinas físicas, entonces por esto, se hacen pruebas de velocidad de

procesamiento y mejora en el rendimiento de la memoria.

Alta disponibilidad. Reducir los costos y la complejidad de que no haya paros ni fallos en la

información, en lo que se refiere a que siempre esté disponible y se pueda recuperar ante

cualquier desastre. Esto se hace encapsulando los sistemas operativos en archivos individuales

que puedan ser replicados y restaurados en cualquier servidor como si no hubiera pasado nada.

Escritorios seguros. Evita problemas de que un usuario con pocos conocimientos altere la

configuración del equipo. Al tener una máquina virtual, en esta recaería todas las

modificaciones, problemas de virus, etc.

35

Consolidación de Servidores. Convertir muchos servidores físicos en virtuales. De este modo se

aprovecha el hardware disponible de la mejor manera posible.

Recuperación ante desastres. Las máquinas virtuales se pueden salvar muy fácilmente y

además su estado puede recuperar la información con rapidez.

Pruebas de aplicaciones. En muchas ocasiones se necesita un entorno limpio para probar una

aplicación. Usar una máquina virtual permite instalar un sistema operativo desde cero, probar la

aplicación y luego eliminar la máquina.

Ejecución de entornos completos sin instalación ni configuración. La posibilidad de disponer

de máquinas virtuales ya instaladas con todo el software necesario configurado, hace que no se

pierda el tiempo el tiempo en realizar las tareas de instalación y configuración de dicho

software.

Aplicaciones portátiles. Con el uso de las máquinas virtuales se pueden tener PC´s completos

listos para usar en dispositivos USB, lo que puede ser de mucha utilidad para tener un entorno

privado y usarlo en cualquier PC.

36

CAPÍTULO 4. Desarrollo e implementación

4.1 Diferencias entre clusters físicos y clusters virtuales

4.1.1 Clusters físicos

El trabajo consiste en realizar un cluster físico, trabajando para esto con equipo existente en el

Centro de Investigación y Desarrollo Tecnológico en cómputo (CIDETEC). El cual cuenta con

cuatro equipos de cómputo conectados a un medio de comunicación físico por medio de un switch

compartiendo recursos. Estos equipos de cómputo que se facilitan, tienen un procesador Pentium 4

a 1.5 GHz, con un disco duro de 80 Gb de almacenamiento. Cada equipo de cómputo cuenta con

tarjetas de red que se instalan en el bus PCI. Una de las tarjetas trabaja a una velocidad de 10/100

Mbps; la otra tarjeta trabaja a una velocidad de 1 Gbps y es la que se ocupa para la trasmisión de la

información.

Uno de los cuatro nodos (ver Figura 4.1), fue elegido para ser el nodo maestro. Este nodo maestro

trabaja para la comunicación con los demás nodos con tarjetas de red veloces. La tarjetas de red que

utiliza, una es de 10/100 Mbps y se conecta a internet en la red de la institución y la otra tarjeta de

red, es de 10/100/1000 Mbps y es la que conecta a los nodos esclavos; los nodos esclavos se

conectan por medio de la tarjeta de 10/100/1000 Mbps, con lo cual hace que la red entre los nodos

sea eficiente y rápida.

Figura 4.1 Esquema del cluster con 3 nodos y un nodo maestro.

37

El medio de comunicación es cable UTP categoría 5e, que conecta los nodos al switch. Se ha

elegido el sistema operativo Linux [5], en su distribución OpenSUSE en la versión 11.1 ya que el

parche Mosix es compatible con esta distribución. Esta instalación se hizo para cada uno de los

nodos, los cuales se configuran en red dentro del sistema, asignando las direcciones de red. El

cluster virtual es configurado de la misma manera que el cluster físico, pero la diferencia de éste

con el sistema físico, es que depende del hardware virtual con el que se cuenta dentro de la máquina

virtual, la cual es Virtual Box en su versión 3.0.2 de la empresa Sun Microsystems. Igual que en los

nodos físicos, en la máquina virtual se instalaron y configuraron cuatro nodos virtuales con el

sistema operativo Linux en su distribución OpenSUSE 11.1 [27], configurado en una red interna en

la cual los nodos son capaces de intercomunicarse vía red compartiendo recursos de software y

hardware.

4.1.2 Cluster Virtual

Al igual que el cluster físico la creación del cluster virtual implica tener 4 nodos conectados por

medio de hardware virtual, como tarjetas de red virtual, procesadores, discos duros, cantidad de

memoria, USB, etc.

En Virtual Box se puede escoger la marca de tarjeta de red y también el tipo de conexión interna

para comunicar los hosts entre sí.

Algunas marcas que maneja la máquina virtual de Virtual Box [17] son: Intel PRO/1000 MT

Desktop, PC net-Fast III, entre otras (ver Figura 4.2).

Aquí no existe un dispositivo central llamado switch, sino que internamente la conexión

virtualizada toma el lugar de la red física, pero sin dispositivos ni cables de por medio.

Figura 4.2 Configuración de la tarjeta de red en Virtual Box.

38

A su vez los discos duros y las memorias virtuales toman un papel importante antes de instalar un

sistema operativo, ya que estos dispositivos pueden tomar el tamaño de almacenamiento requerido

para las funciones del sistema operativo. Por ejemplo, en lo referente a la memoria RAM, podemos

tomar diferentes tamaños de memoria que pueden ser desde los 4Mb hasta los 2048 Mb. Los discos

duros se pueden configurar en la máquina virtual y su capacidad puede ser modificada por el

Administrador del sistema virtual, desde 4 Mb hasta los 2 Tb de espacio.

Ya teniendo los nodos configurados con el tipo de red, se elige el sistema operativo Opensuse 11.1

y se escoge el disco duro virtual, que anteriormente se había configurado su tamaño. La instalación

y configuración del sistema operativo Opensuse, se puede hacer en un disco montado en la unidad

física de la computadora o bien mediante una imagen de disco con extensión *.nrg o *.iso.

4.2 Diferencias entre el cluster virtual y cluster físico

Las diferencias entre el cluster virtual y el cluster físico son notables a simple vista, pero en lo

referente a las velocidades del procesador, como a las capacidades del disco duro y la memoria

RAM dependen en las máquinas físicas de su plataforma, que pueden ser de 32 y 64 bits. La

máquina virtual depende de estas plataformas para su funcionamiento. La ventaja de las plataformas

es que cada máquina virtual puede acoplarse a sus características físicas, haciendo que una máquina

virtual de 32 bits pueda funcionar en una máquina física de 64 bits.

Los clusters físicos cuentan con dispositivos que se encuentran físicamente instalados en una placa

base y sus características imponen una velocidad de procesamiento y de acceso a la memoria RAM,

además de que el disco duro puede almacenar la información que se requiera a una velocidad de

lectura/escritura que depende de la placa base. Todos estos dispositivos de hardware trabajan

conjuntamente con el microprocesador, con lo cual al trabajar a la velocidad de procesamiento,

todos los dispositivos son compatibles con el procesador y la placa madre si es un sistema a 64 bits.

En el cluster físico se han implementado 4 computadoras con características similares y estas son:

1.- Cuatro nodos interconectados con un enlace con un SWITCH Enterasys a 1000Mbps.

2.- Procesadores CELERON CORE DÚO, 2 Gb de memoria RAM, ya cada uno con un disco duro

de 160 Gb.

3.- Sistema operativo Linux OpenSUSE versión 11.1 de Novel.

39

4.- El nodo maestro (nodo0), cuenta con 2 tarjetas de red eth0 y eth1, en donde eth1 tiene salida a

internet por medio del numero IP 148.204.67.192. Este nodo incluye los servicios de servidor web

Apache2 y Openssh para poder acceder al cluster desde internet.

5.- El middleware de conexión a nivel de kernel MOSIX [25].

4.2.1 Características del cluster virtual.

Para la creación del cluster virtual se cuenta con una máquina de buen desempeño en cuanto a

procesamiento y memoria se refiere, ya que debe ser lo más parecido al cluster físico.

El cluster virtual llamado marc2 cuenta con las siguientes características:

1.- Un computadora anfitrión TOSHIBA L505D-S5983, con las siguientes características:

a) Windows 7 home Premium 32 bits

b) Procesador AMD Athlon II Dual Core

c) Memoria RAM 4 Gb.

2.- Software Virtual, Virtual Box versión 3.02

a) Cada nodo virtual cuenta con 300 Mb de memoria Ram.

b) Cada nodo virtual cuenta también con disco duro virtual de 10Gb.

3.- Sistema operativo Linux OpenSUSE 11.1

4.- Middleware Mosix kernel-mosix-latest.i586 y mosix-utils-latest.i386 RPM.

5.- Para la conexión a internet Apache2 y Openssh.

6.- Gcc y g++ para la compilación de programas en lenguaje C a correr en el cluster.

El procedimiento de instalación en el cluster físico fue el siguiente:

1.- Se conectaron en red, utilizando cable UTP cat 5e y conectores RJ45 al switch Enterasys en cada

uno de los nodos.

2.- Se instaló el sistema operativo OpenSuSE 11.1 en cada uno de los nodos.

3.- Se configuraron las direcciones IP y los nombres de cada equipo.

4.3 Diferencias entre cluster físicos y cluster virtual.

Entre las diferencias más notables en la creación del cluster, está la de costos entre ambos cluster.

Para distinguir la viabilidad en el desarrollo de este proyecto ver la tabla 4.1.

40

Cluster físico Cluster virtual

Equipo Costo Equipo Costo

1 Switch Enterasys $24,508.00 Computadora personal, procesador AMD

Athlon II, Dual Core M300, Memoria

DDR2 4Gb, disco duro 320 Gb.

$8700.00

10 metros de cable UTP $55.00

4 PC (ensambladas), procesador Celeron

core dúo, memoria Ram 2 Gb, disco duro

80 Gb, etc. Cada una costó $2999.00.

$11, 996.00

$36,559.00 $8700.00

Tabla 4.1 Diferencia de costos entre el cluster fisico y el cluster virtual.

La diferencia de costos entre el cluster fisico y el cluster virtual es notoria en cuanto al costo que

está más relacionado al hardware. La diferencia entre el cluster físico y el cluster virtual es de

$27,859.00. Por lo anterior se puede decir que es más barato construir un cluster virtual, que un

cluster físico.

4.3 Instalación y configuración del software en la máquina virtual y

máquina física.

Para la creación del cluster tanto físico como virtual se instalaron y configuraron los mismos

componentes de software, la única diferencia fue que en el cluster virtual se debe tener una máquina

anfitriona y esta máquina anfitriona necesita una máquina virtual y para esto se eligió Virtual Box

versión 3.02, la cual puede contener su propio hardware según la arquitectura con la cual se vaya a

trabajar como la AMD e INTEL, además se pueden importar los discos duros de las máquinas

virtuales que se necesiten.

4.3.1 Pasos para instalar Virtual box para el cluster virtual

VirtualBox viene en diferentes paquetes y la instalación depende de su plataforma de su tarjeta

madre y el sistema operativo que se está utilizando. Virtual Box tiene la opción para instalarse en

cualquier sistema operativo. El arranque del software virtual trae consigo la creación de la máquina

virtual que alberga al sistema operativo de nuestra elección.

41

Si queremos tener una máquina virtual podemos acceder al asistente que nos ayuda a crearla

dependiendo del sistema operativo y su versión.

Podemos también escoger la memoria base (ver Figuran 4.3) con el cual va a trabajar nuestra

máquina virtual.

Posteriormente se puede crear el disco duro que va a utilizar el sistema y este disco duro puede ser

de tamaño fijo o dinámico, al crear el disco duro se guarda con un nombre de disco duro y este

almacena toda la configuración del sistema operativo y los programas instalados en éste. Las

imágenes de disco también se puede separar de una máquina virtual en particular, por lo que incluso

si se elimina una máquina virtual se puede guardar la imagen o copiarlo a otro host y crear una

nueva máquina virtual ahí. Al crear el disco duro también se especifica el tamaño de éste (ver

Figura 4.4), dependiendo de la instalación se puede escoger el tamaño del disco duro, que puede

llegar hasta los 2 Tb de tamaño.

Figura 4.3 Selección de la memoria RAM en la máquina virtual de Virtual Box.

Figura 4.4 Configuración del disco duro virtual en Virtual Box.

42

Después de haber creado la máquina virtual se pueden configurar algunas otras características que

se necesitan para la creación del cluster como: la red, el tipo de arranque para la instalación, el

configurar el USB y otras características que pueden ser útiles como la cantidad de memoria para la

tarjeta de video virtual.

Por ejemplo para poder instalar un sistema operativo se puede hacer a través de un CD insertado en

la unidad de CD-ROM. También puede hacerse mediante un archivo de imagen de disco (ver figura

4.5), el cual pueden ser ISO, NRG, VCD, BIN, IMG, etc.

El modo de arranque es otra de las funciones importantes de la máquina virtual, ya que se puede

iniciar desde el disco duro o desde la unidad de CD-ROM y generalmente la opción que se

selecciona es la de arrancar (bootear) desde la unidad de CD-ROM.

Las máquinas virtuales que se instalaron para el cluster tienen la necesidad de conectarse en red (ver

Figura 4.6), entonces existen diferentes formas de conectar la red, estos tipos de conexión son:

Red interna. Sirve para conectar internamente máquinas con la misma IP y la misma

mascara de subred, pero sin poder conectarse a la red.

Red NAT. Generalmente se ocupa para traducción IP’s de un tipo de red a otra. En la

instalación del nodo maestro es necesario tener 2 tarjetas de red, por lo que se instaló una

tarjeta con NAT y otra con red interna.

Red Adaptador Puente (Bridge).

Adaptador solo Anfitrión.

Figura 4.5 Selección de una imagen de disco (ISO, NRG,etc), para instalar sistema operativo.

43

El nodo maestro del cluster tiene dos tarjetas de red como se había comentado antes, una tarjeta con

conexión NAT y otra tarjeta con conexión de red interna. La segunda conexión de red interna sirvió

para hacer la conexión de los nodos de red. Cada uno de los nodos de la red tiene una configuración

con una tarjeta de red interna y en las cuales se configuraron las IP’s de red interna necesarias para

la comunicación del cluster. Es necesario también escoger una buena tarjeta de red virtual, para el

caso de los nodos se escogió la tarjeta de red Intel PRO/1000 MT Desktop.

La configuración e instalación de virtual box para la creación de máquinas virtuales con OpenSUSE

11.1, fue necesario para la máquina anfitriona que tendría al cluster virtual. Para el buen

funcionamiento del cluster tanto físico como virtual es necesario instalar el sistema operativo

OpenSUSE, para computadoras con procesador i386 (procesador intel) a 32 bits en cada una de las

máquinas; para su caso se tuvo que instalar la versión OpenSUSE 11.1 para que los RPM´s de

Mosix puedan coincidir con el kernel del sistema operativo.

4.3.2 Instalación de Opensuse y configuración de la red.

Instalando y configurando OpenSuSE.

Generalmente se instala desde el disco booteable de OpenSUSE 11.1, y comienza el gestor de

instalación [29].

Automáticamente desde este modo de instalación, se puede dar una configuración al sistema y los

alcances que se quiere con el sistema operativo OpenSUSE 11.1. Por ejemplo el idioma de

OpenSUSE (ver Figura 4.7).

Figura 4.6 Seleccionar el tipo de conexión de Red en Virtual Box.

44

También se puede ver el tipo de instalación y la configuración de la partición en el disco duro (ver

Figura 4.8), además del tipo de partición, como son: ext2, ext3 o ext4. Se seleccionó el formato de

partición es ext3, debido a su manejo y compatibilidad con otro formatos de archivos de Linux y ya

que todas las distribuciones de Linux la utilizan como el formato de partición. Su nuevo sucesor es

ext4.

Y toda la instalación requiere de otros parámetros, como: el nombre del equipo y la contraseña con

lo cual vamos a reconocerlos en la red tanto física como virtualmente. En la creación de este cluster,

se ha tomado el nombre de nodo para cada equipo conectado en la red.

Después de la instalación es necesaria más herramientas de software para el buen trabajo del

sistema operativo, como son los programas gcc, make, g++, ssh, apache etc. Toda instalación se

hace desde el gestor de arranque de OpenSUSE (ver Figura 4.9).

Figura 4.7 Instalando OpenSUSE 11.1, configurando idioma.

Figura 4.8 Particionar el disco duro en formato ext y configurando el tamaño de la instalación.

45

Configuración de la Red en OpenSuSe

La configuración de la red en OpenSuse se puede hacer de dos formas, utilizando el gestor de

instalación y configuración de la red YAst (Yet another Setup Tool, Otra Herramienta de

Configuración Más, Figura 4.10), otra forma de configuración es mediante la terminal de comandos

en Opensuse y también la opción de configuración por el gestor de conexión de red (Figura 4.11).

Figura 4.9 Gestor de Software de OpenSUSE.

Figura 4.10 Configuración de Red por YaST.

46

Para la configuración de la red es necesario la tarjeta de red, que por default se configura al

instalarse OpenSUSE y posteriormente la configuración de la dirección IP y la máscara de subred

para cada uno de los nodos en la red (Figura 4.12).

Para identificar a estos se escogieron números IP’s pertenecientes a la clase C11

, de la dirección

192.168.10.1/24 a la 192.168.10.4/24, ya que es la clase que soporta menor cantidad de

computadoras conectadas.

11 La red de clase C, es la red que puede aceptar 256 redes, y generalmente es utilizado por compañías pequeñas, escuelas y usuarios. Las direcciones que utilizan van desde la 192.168.0.0 hasta la 192.168.255.255.

Figura 4.12 Configuración de direcciones IP en OpenSUSE.

Figura 4.11 Configuracion por conexión de Red.

47

La configuración de la dirección IP se hace en cada uno de los nodos, también se tiene que

configurar el nombre del equipo para reconocerlo en la red, esto se hace desde el directorio

/etc/hosts, este archivo se edita, se le pone su dirección IP y los nombres de los nodos como se van

a reconocer en la red.

Ejemplo:

192.168.10.1 nodo0

192.168.10.2 nodo1

192.168.10.3 nodo2

192.168.10.4 nodo3

Después de hacer la configuración de la dirección IP en cada uno de los nodos, se puede utilizar el

comando ifconfig (en Opensuse solo funciona como superusuario “root”), si la dirección está

asignada a la tarjeta de red, que generalmente se determina por default a eth0. El ifconfig muestra

cada interfaz instalada y su respectiva dirección IP:

inet addr:192.168.10.1 Bcast:192.168.10.255 Mask:255.255.255.0

Posteriormente para ver si hay conexión entre los nodos conectados en red, se utiliza el comando

ifconfig en modo root, debido a que solamente así funciona ifconfig:

nodo0@linux-3mjj~>ifconfig

Después utilizamos una utilidad del protocolo ICMP (Protocolo de Control de Mensajes de

Internet) y esta utilidad es el ping con el cual se puede verificar el estado de la conexión, velocidad

de transmisión y la calidad de la red en la se está conectado.

Para ver los nodos en la red entonces se utiliza la terminal y escribimos ping (echo request), que es

una utilería del protocolo ICMP y nos da una respuesta de señal exitosa de conexión con otro nodo,

de otra forma nos da un mensaje de error de no respuesta.

nodo0@linux-3mjj~>ping nodo1

PING nodo1 (192.168.10.2): 56(84) bytes of data.

64 bytes from nodo1(192.168.10.2): icmp_seq=1 ttl=64 time=0.085 ms

64 bytes from nodo1(192.168.10.2): icmp_seq=1 ttl=64 time=0.093 ms

48

4.4 Instalación de Mosix

Para instalar Mosix, es necesario tener los archivos de instalación y de configuración, los cuales se

obtienen de la página de los creadores de Mosix [20], los archivos necesarios para la instalación

deben buscarse dependiendo del sistema operativo y también por la versión del sistema operativo,

en este podemos encontrar un apartado para la instalación del kernel en todas las distribuciones de

Linux que se conocen. En el caso de la distribución OpenSUSE se pueden obtener los archivos de

instalación RPM12

. En el caso del cluster se escogió la versión de OpenSUSE 11.1 y los archivos

que se instalaron fueron de la última versión de Mosix, la 2.28.0 [25].

Los archivos recomendados para la instalación es el kernel-mosix-2.6.27.33_2.27.1-6.4.i586.rpm

que es necesario para el funcionamiento del kernel de Mosix y del kernel del sistema operativo

Linux y también un archivo necesario para el funcionamiento es el archivo mosix-utils-2.27.1.0-

1.i386.rpm, que contiene otras características de funcionamiento de migración de Mosix [22].

La instalación de estos archivos de forma automática se hace:

pc0@linux-ipvw:~/Escritorio/kernelmosix> rpm -ihv kernel-mosix-latest.i586.rpm

pc0@linux-ipvw:~/Escritorio/kernelmosix> rpm -ihv mosix-utils-latest.i386.rpm

Al hacer esta instalación Mosix instala propiedades básicas de conexión entre kernels de Mosix,

pero no se apropia completamente del kernel de Linux.

Para ver el funcionamiento de Mosix, es necesario reiniciar para que el gestor de arranque Grub,

reconozca al kernel de Mosix como el primer sistema de arranque (Figura 4.13).

12 RPM Package Manager (o RPM, originalmente llamado Red Hat Package Manager, pero se convirtió en acrónimo recursivo) es una herramienta de administración de paquetes pensada básicamente para GNU/Linux. Es capaz de instalar, actualizar, desinstalar, verificar y solicitar programas. RPM es el formato de paquete de partida del Linux Standard Base.

49

Después de haber reiniciado se tiene que proseguir con la instalación de Mosix, para su

funcionamiento correcto en el sistema operativo elegido. En la terminal de OpenSUSE se utiliza el

comando mosconf, el cual sirve para configurar automáticamente la operatibilidad de Mosix:

pc0@linux-ipvw:~/mosconf

Y se tiene acceso al menú de configuración de Mosix:

MOSIX CONFIGURATION

==================

=================================

1. Which nodes are in this cluster (ESSENTIAL)

2. Authentication (ESSENTIAL)

3. Logical node numbering (recommended)

4. Queueing policies (recommended)

5. Freezing policies

6. Miscellaneous policies

7. Become part of a multi-cluster organizational Grid

En este menú se escoge la opción 1 para configurar la cantidad de nodos a instalar en Mosix. Y se

tiene que escoger la opción n, para configurar los nodos:

There are no nodes in your cluster yet:

=======================================

To add a new set of nodes to your cluster, type 'n'.

To save and exit, type 'q'. (to abandon all changes and exit, type 'Q')

Figura 4.13 Gestor de arranque GRUB, iniciando con kernel Mosix.

50

Después de haber metido los nodos hay que guardar esta configuración y se presiona la tecla q. Y se

puede ver el archivo generado por la configuración:

pc0@linux-ipvw:~/etc/mosix/pico mosix.map

192.168.10.1 4 p

Mosix.map nos muestra el contenido creado en la primera parte del menú de mosconf la cantidad

de nodos del cluster y utiliza la letra p para el manejo de los procesadores de cada uno de los nodos.

La dirección IP 192.168.10.1 se puede asignar, como IP principal y no es necesario configurar las

otras direcciones IP´s, porque el numero 4 significa que están activos. También se recomienda crear

el archivo manualmente y puede representarse así:

192.168.10.1 1 p

192.168.10.2 1 p

192.168.10.3 1 p

192.168.10.4 1 p

Esta configuración es para cada uno de los nodos conectados en el cluster, utilizando mosconf o

manualmente creando el archivo mosix.map.

Posteriormente se tiene que configurar la seguridad de cada uno de los nodos y para esto se tiene

que ejecutar mosconf y escoger la opción 2.

What would you like to configure?

=================================

1. Which nodes are in this cluster (ESSENTIAL)

2. Authentication (ESSENTIAL)

3. Logical node numbering (recommended)

4. Queueing policies (recommended)

5. Freezing policies

6. Miscellaneous policies

7. Become part of a multi-cluster organizational Grid

Configure what :- 2

Generalmente las 2 primeras opciones del menú de configuración de mosconf aparecen con la

palabra ESSENTIAL, que nos indican que es obligatoria su configuración para un buen desempeño

del cluster. Por tanto al escoger la opción 2, su configuración de autenticación es con una clave

cifrada con el algoritmo RSA. Esta clave debe ser la misma en cada uno de los nodos, ya que al

migrar los procesos se debe estar seguro de que nadie pueda tener acceso a los mismos. Es

51

recomendable que en todos los nodos se tenga la misma clave cifrada, en el caso del cluster se

escogió una clave relacionada con el mismo: nodos.

Después de la configuración se generan 2 archivos con las claves secretas de los nodos del cluster,

estas son: secret (para configurar cuanta secreta del servidor) y ecsecret (cuenta secreta de los

clientes).

La configuración posterior y no tan urgente es la opción 3:

What would you like to configure?

=================================

1. Which nodes are in this cluster (ESSENTIAL)

2. Authentication (ESSENTIAL)

3. Logical node numbering (recommended)

4. Queueing policies (recommended)

5. Freezing policies

6. Miscellaneous policies

7. Become part of a multi-cluster organizational Grid

Configure what :- 3

Logical node numbering, es recomendable para la configuración de una dirección IP para

reconocimiento en el nodo maestro o bien se pueden configurar los nombres de los nodos. La

configuración es en cada uno de los nodos al entrar a esta opción y se crea un archivo llamado

userview.map, el cual tiene un parecido a mosix.map:

/etc/mosix/userview.map

Cuando abrimos posteriormente este archivo se puede ver la configuración del nodo a configurar:

/etc/mosix/pico userview.map

Y nos muestra lo siguiente:

1 192.168.10.1 4

Donde el 1 significa que es un solo nodo con la dirección de inicio, en este caso comienza con la

dirección 192,168.10.1, y el 4 que son 4 nodos con numeración consecutiva al primer nodo. Es

decir el nodo que le sigue es el nodo con la dirección IP 192.168.10.2 y así consecutivamente.

También es necesario configurar el nodo central, también conocido como nodo maestro. Este nodo

central generalmente se recomienda al nodo de inicio, es decir al que comienza con el primer

número IP de la conexión del cluster. Este nodo maestro es el que maneja la cola de procesos y es

desde este nodo donde se decide a que nodo se puede migrar el proceso [23].

52

What would you like to configure?

=================================

1. Which nodes are in this cluster (ESSENTIAL)

2. Authentication (ESSENTIAL)

3. Logical node numbering (recommended)

4. Queueing policies (recommended)

5. Freezing policies

6. Miscellaneous policies

7. Become part of a multi-cluster organizational Grid

Configure what :- 3

En el menú de configuración del archivo mosconf, se selecciona la opción 4, Queueing policies

(políticas de cola). Se seleccionó como nodo principal al nodo0, es decir al que tiene el número

192.168.10.1. Esta dirección debe ser configurada en cada uno de los nodos del cluster. El archivo

generado es /etc/mosix/queue.conf, el contiene la configuración del nodo central, y el cual es:

C 192.168.10.1

Donde la C significa que esta dirección IP es el nodo central.

Si se requiere monitoreo de todos los nodos conectados en red, utilizando el comando mon se

requiere crear un archivo llamado mosip, el cual debe contener el nombre del nodo que se va a

monitorear.

Por ejemplo:

192.168.10.1 para el nodo maestro, donde se requiere monitorear a los demás nodos. Después de

toda la configuración realizada con mosconf, es necesario reiniciar a cada nodo configurado para un

buen funcionamiento.

53

CAPÍTULO 5. Pruebas de Desempeño

5.1 Requerimientos para el cluster físico y virtual

Requerimientos del clúster físico

Cuatro nodos interconectados con un enlace con un SWITCH Enterasys a 1000Mbps.

Procesadores CELERON CORE DÚO, 2 Gb de memoria RAM, cada uno con un disco duro de 160

Gb.

Sistema Operativo Linux OpenSuSE versión 11.1 de Novel.

El nodo maestro (nodo0), cuenta con 2 tarjetas de red eth0 y eth1, donde eth1 tiene salida a internet

por medio del número IP 148.204.67.192. Este nodo incluye los servicios de servidor web Apache2

y Openssh, para poder acceder al clúster desde internet.

El middleware de conexión a nivel de kernel MOSIX.

Requerimientos del clúster virtual

El clúster virtual llamado marc2 cuenta con los siguientes requerimientos:

1. Software Virtual, Virtual Box versión 3.02 [7].

a) Cada nodo virtual cuenta con 300 Mb de memoria RAM.

b) Cada nodo virtual cuenta también con disco duro virtual de 10Gb.

c) Una tarjeta de Red GigabitE virtual, configurado en modo interno.

2. Sistema operativo Linux OpenSUSE 11.1

3. Middleware Mosix kernel-mosix-latest.i586 y mosix-utils-latest.i386 RPM.

4. Para la conexión a internet Apache2 y Openssh.

5. gcc y g++ para la compilación de programas en lenguaje C a correr en el cluster.

El procedimiento de instalación en el cluster físico fue el siguiente:

1. Se conectaron en red, utilizando cable UTP cat 5e y conectores RJ45 al switch Enterasys

cada uno de los nodos.

2. Se instaló el sistema operativo OpenSUSE 11.1 en cada uno de los nodos.

3. Se configuraron las direcciones IP y los nombres de cada equipo.

4. Se instalaron gcc y g++ en cada nodo.

5. Se configuró el nodo maestro con Apache2 y OpenSSH.

6. Se instalaron los archivos RPMs de Mosix en cada nodo.

7. Se configuró el nodo maestro y los nodos clientes con el comando mosconf.

54

8. Se ejecutaron programas y se monitorizaron con el comando mon.

El procedimiento de instalación en el cluster virtual fue el siguiente:

1. Configuración de las tarjetas de red en cada una de las máquinas virtuales con red Interna

para la comunicación entre nodos.

2. Instalación del Sistema Operativo OpenSUSE 11.1 en cada uno de los nodos.

3. Configuración de las direcciones IP y los nombres de cada equipo.

4. Instalación del software gcc y g++ en cada nodo.

5. Configuración del nodo maestro con Apache2 y OpenSSH.

6. Instalación de los RPMs de Mosix en cada nodo.

7. Configuración del nodo maestro y los nodos clientes con el comando mosconf.

8. Ejecución de los programas y monitorización de los eventos con el comando mon.

5.2 Metodología

Para desarrollar las pruebas, fue necesario hacer pruebas de balanceo y de carga en cada uno de los

nodos conectados en red y que serían ejecutados por Mosix [4]. Para esto se buscaron los

algoritmos que por su complejidad matemática responden a un tiempo de retardo, estos algoritmos

son los algoritmos de factorial, un algoritmo con 3 bucles anidados (Stress), algoritmo que calcula

el Pi por el método de Leibniz y un algoritmo que calcula el ordenamiento de las torres de Hanoi.

Se realizan en cada uno de los algoritmos las pruebas que se realizaron fueron en base a muestras

numéricas que en promedio de diez corridas por muestra, arrojaron diferentes tiempos en cada uno

de los equipos en los que fueron ejecutados como: en una computadora (secuencial), el cluster fisico

y en el cluster virtual. Además de su análisis de Speedup, para ver la ganancia en tiempos

comparados entre los tiempos secuenciales y los clusters físicos y virtuales.

5.2.1 Pruebas utilizando el algoritmo de Factorial

Matemáticamente el factorial se denota como el producto de un número n positivo, que multiplica

decrementalmente a un número antecesor hasta llegar a la unidad.

Ejemplo

n!= 7.

7!= 7 x 6 x 5 x 4 x 3 x 2 x 1

7!= 5040.

55

En caso de obtener el factorial de 0! El resultado de este es 1.

El factorial se ocupa en muchas disciplinas de las matemáticas, especialmente en combinaciones,

algebra y análisis combinatorio. En el estudio de la criptografía, es ocupado el factorial para las

permutaciones, en el algoritmo DES.

Para obtener el factorial de un número, es necesario desarrollar un algoritmo que utilice un ciclo

repetitivo y en este ciclo es necesario utilizar elementos recursivos para poder así sacar el resultado

del factorial de cierto número entero positivo incluyendo el cero.

Algoritmo y complejidad computacional.

Algoritmo Factorial

Var

Real largo: f;

Entero n, i;

Escribir(“Dame un numero para calcular:”); ---O(1)

Leer(n); ---O(1)

Desde i=n hasta 1 decremento 1 hacer ---O(n!)

f=f*i; ---O(1)

Fin desde ---O(1)

Escribe(“El factorial del numero es de”, f); ---O(1)

Fin.

El estudio del algoritmo de Factorial por consumir cierto tiempo en arrojar el resultado del factorial

su complejidad computacional que se analizó es de complejidad O(n!), con lo cual podemos decir

que tiene n iteraciones.

El código en lenguaje C del algoritmo del factorial es el siguiente:

#include <stdio.h>

int main( )

{

long double f=1;

long int n=2;

int i;

printf("Calculando el factorial de %d:",n);

for (i=n; i>=1; i--)

{

f=f*i;

printf("%ld %.2Lf \n ->",i,f);

}

return 0;

}

56

Para compilar este programa se necesita abrir la terminal y todo se realizará desde el nodo principal,

ya que en el nodo principal es donde se ejecutan los programas, utilizando gcc.

$gcc factorial.c –o factorial

Al no encontrar ningún error de compilación, se realiza el ejecutable y se puede hasta ver el tiempo

de ejecución de este programa.

$time ./factorial

Para ejecutar un programa de factorial en todo el clúster es necesario utilizar el comando mosrun

migrando los procesos de cada uno de los nodos a un nodo libre:

$mosrun time ./factorial

O en su caso para ejecutarlo en algún nodo o conjunto de nodos:

$mosrun –j1-3 ./factorial /*Ejecutar en los nodos del 1 al 3

$mosrun –np ./factorial /* ejecuta en todos los nodos

5.2.2 Análisis de tiempo de ejecución del algoritmo Factorial, en secuencial, paralelo

físico y paralelo virtual

Las muestras que se tomaron en cuenta (Tabla 5.1), para desarrollar el algoritmo de factorial, fueron

de acuerdo al alcance de los tipos de datos que el lenguaje c puede alcanzar.

CALCULOS DE TIEMPOS EN EL ALGORITMO DE FACTORIAL

Muestras T. secuencial T. Cluster fisico T. Cluster virtual T. Speedup fisico T. Speedup virtual

5 0.002 0.001 0.001 1.00 1.00

8 0.002 0.001 0.001 1.00 1.00

20 0.003 0.001 0.002 2.00 0.50

27 0.003 0.002 0.002 0.50 0.50

33 0.003 0.002 0.002 0.50 0.50

40 0.003 0.002 0.003 0.50 0.00

50 0.003 0.002 0.003 0.50 0.00

58 0.004 0.003 0.003 0.34 0.34

62 0.004 0.003 0.003 0.34 0.34

70 0.004 0.003 0.003 0.34 0.34

89 0.01 0.003 0.004 2.34 1.51

105 0.03 0.003 0.004 9.03 6.53

115 0.031 0.004 0.005 6.78 5.23

145 0.038 0.005 0.006 6.64 5.37

163 0.043 0.011 0.014 2.95 2.11

Tabla 5.1 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo del Factorial.

57

Utilizando las muestras del 5 al 163, se pueden notar los resultados de tiempos que secuencialmente

se desarrollaron en un solo nodo, sin ninguna conexión o software que lo paralelizara, se puede ver

mediante la gráfica su desempeño (Figura 5.1).

De la misma forma las muestras antes utilizadas fueron llevadas al algoritmo del factorial,

ejecutándolas en el cluster físico, y este nos arroja el siguiente resultado gráfico (Figura 5.2), dando

una mejoría de tiempo en referente a su homologo secuencial.

Tiempo secuencial Factorial

Figura 5.1 Gráfica de prueba secuencial aplicado al algoritmo de Factorial.

Figura 5.2 Gráfica de prueba en cluster físico, aplicado al algoritmo de Factorial

Tiempo cluster fisico en Factorial

58

El cluster virtual nos visualiza una gráfica (Figura 5.3) de los tiempos en que las muestras se

ejecutaron en el algoritmo de Factorial, fueron relevantes para comparar al equipo secuencial y el

virtual. La gráfica muestra este funcionamiento del algoritmo de forma virtual.

Para calcular las diferencias de tiempo entre el cluster físico y el cluster paralelo, se tiene una

fórmula llamada fórmula de Speedup. Si el Speedup calculado es mayor que los tiempos anteriores

se puede decir que lo optimo es paralelizar el algoritmo de Factorial, se puede ver la diferencia

mediante la gráfica (Figura 5.4).

Tiempo cluster virtual Factorial

Tiempo secuencial Factorial Tiempo cluster fisico Fact.

Tiempo Speedup Fisico Factorial

Figura 5.3 Gráfica de prueba en cluster virtual, aplicado al algoritmo de Factorial

Figura 5.4 Gráfica de comparacion entre tiempos secuencial, cluster fisico y el speedup aplicado al algoritmo de Factorial.

59

Se aplica la fórmula del cálculo del speedup en el nodo secuencial vs el cluster virtual y se ve la

diferencia de tiempo y speedup es menor al speedup aplicado entre el cluster físico y el nodo

secuencial (Figura 5.5).

Esta fórmula de speedup hace referencia a la diferencia que existe entre el tiempo secuencial del

programa que calcula el algoritmo factorial y el tiempo en que se tarda en correr en el cluster físico.

Y con esto se puede hacer una comparación de qué cluster utilizar para el desempeño de programas

que utilicen el algoritmo del Factorial.

5.3 Análisis del algoritmo de Stress utilizando tres bucles anidados

Bucles Repetitivos.

Las estructuras repetitivas o bucles, se utilizan como su nombre lo indica “repetir un número de

veces” una declaración o un conjunto de instrucciones. Un bloque de instrucciones, puede contener

asignaciones, operaciones, sentencias y más bucles repetitivos.

Tipos de bucles

En los lenguajes de programación se conocen 3 tipos diferentes de ciclos o bucles repetitivos, los

cuales son: el ciclo para (for), mientras (while) y hacer mientras (do while).

Tiempo secuencial Factorial Tiempo cluster virtual Fact.

Tiempo Speedup virtual Factorial

Figura 5.5 Gráfica de comparacion entre tiempos secuencial, cluster virtual y el speedup aplicado al algoritmo de Factorial.

60

Bucle repetitivo Para. Es un bucle que se ejecuta un número determinado de veces y es controlado

por un contador.

Para (cond 1, cond 2, contador)

inicio

Instrucciones

Fin para

Bucle repetitivo mientras. Es un bucle que evalúa una condición al inicio del bucle, mientras esta

condición sea verdadera trabaja en el ciclo y si es falsa la condición, el ciclo termina.

Mientras (condición)

Inicio

Instrucciones

Fin.

Bucle repetitivo Hacer Mientras. Se caracteriza por evaluar la condición al final del ciclo, por lo

tanto, si la primera vez al ejecutarlo la condición es falsa, se ejecutará al menos una vez.

Hacer

Instrucciones

Mientras (condición);

Bucles anidados. Son útiles para el manejo de arreglos bidimensionales y multidimensionales. Se

caracterizan por el manejo de bucles internos, el bucle externo controla a los internos. Puede utilizar

a los ciclos repetitivos, para, mientras y hacer mientras; o una combinación de ellos.

Para (cond1, cond 2, cont)

inicio

Para (cond3, cond4≤cond 2, cont)

Inicio

Instrucciones.

Fin_para

Fin_Para.

61

El manejo de 3 ciclos repetitivos anidados depende de lo que se vaya a realizar dentro de esos

bucles, ya sea la ejecución de un proceso sumador, restador o multiplicativo donde el tiempo de

ejecución suele ser muy alto. En la prueba de desempeño se ha desarrollado un algoritmo iterativo

con 3 bucles que trabajan a la n según sea el índice de retardo en este bucle anidado, a esta prueba

se le llamó Stress, porque según el número de iteraciones depende de hasta n y mientras n se vaya

incrementando, más lento se va haciendo el programa.

Algoritmo Stress

Var

Entero n,i ,j, k;

Escribir(“Dame un numero para el límite del los ciclos:”);

Leer(n); ---O(1)

Desde i=1 hasta n incremento 1 hacer ---O(n)

Desde j=1 hasta i incremento 1 hacer ---O(n)

Desde k=1 hasta j incremento 1 hacer ---O(n)

Escribe(“numero “, n);

Fin desde k;

Fin desde j;

Fin desde i;

fin.

Su complejidad computacional es n cubica O(n3), con lo cual podemos decir que su complejidad

se duplica según vaya subiendo la cantidad de n, lo cual hace que se ralentice el programa.

El código en c, del algoritmo de Stress.

#include <stdio.h>

{

int n,i,j,k;

n=100;

for (i=1; i<=n; i++) {

for(j=1; j<=i; j++)

{

for(k=1; k<=j; k++)

{

printf(“numero %i“, n);

}

}

}

}

62

5.3.1 Análisis de tiempo de ejecución del algoritmo Stress en secuencial, paralelo físico

y paralelo virtual

El algoritmo de Stress, es un algoritmo que dada su complejidad computacional O(n3), al ejecutarlo

en un solo nodo puede tener un retardo de ejecución, debido a sus tres ciclos anidados que utiliza

este algoritmo, al utilizar una muestra cada vez mayor, su complejidad computacional aumenta

considerablemente. Las muestras se escogieron de un valor de 25 a 100 (Tabla 5.2), debido a que

en el algoritmo mientras el valor de n sea más alto más sobrecarga a la computadora, más el análisis

para escoger entre ejecución secuencial o paralela.

CALCULOS DE TIEMPOS EN EL ALGORITMO DE STRESS

Muestras T. Secuencial T. Cluster fisico T. Cluster virtual T. Speedup Fisico T. Speedup Virtual

25 0.004 0.002 0.002 1.004 1.004

31 0.014 0.003 0.003 3.680666667 3.680666667

39 0.039 0.003 0.004 8.04 8.789

46 0.078 0.003 0.004 15.07 15.876

50 0.08 0.007 0.007 9.023 9.678

52 0.098 0.007 0.008 10.45 11.348

68 0.185 0.01 0.013 13.54 13.41576923

80 0.245 0.162 0.171 0.757345679 0.677748538

91 0.337 0.175 0.182 1.262714286 1.188648352

100 0.396 0.293 0.31 0.747535836 0.673419355

Tabla 5.2 Muestras, tiempos calculados secuencialmente en cluster fisico y cluster virtual con el algoritmo de Stress.

Las muestras se ejecutaron en un solo nodo, para dar los tiempos secuenciales para este algoritmo

de Stress, la gráfica nos muestra (Figura 5.6), el comportamiento a través del tiempo de este

algoritmo.

Tiempo secuencial Stress

Figura 5.6 Gráfica de prueba secuencial aplicado al algoritmo de Stress.

63

Los resultados de la ejecución de estas muestras que se realizaron en el cluster fisico arrojan una

gráfica (Figura 5.7), con un comportamiento de velocidad y mejora ante su referente el nodo

secuencial.

En el cluster virtual implementado en virtualbox y con los 4 nodos trabajando se puede observar en

la gráfica (Figura 5.8), el desempeño mostrado por el algoritmo de Stress y su comparación, es

relevante si se observa su comportamiento referente al nodo secuencial.

Tiempo cluster fisico Stress

Tiempo cluster fisico Stress

Figura 5.7 Gráfica de prueba en cluster físico, aplicado al algoritmo de Stress.

Figura 5.8 Gráfica de prueba en cluster virtual, aplicado al algoritmo de Factorial

64

Análisis de muestras de tiempo secuencial, tiempo paralelo físico y el resultado del speedup. El

speedup que se muestra en esta comparación de tiempos puede verse en la gráfica (Figura 5.9), el

tiempo obtenido con la fórmula del speedup nos arroja los tiempos de las mejoras del análisis

paralelo, contrario al análisis secuencial que arroja el algoritmo de Stress.

Análisis de muestras de tiempo secuencial, tiempo paralelo virtual y el resultado del speedup entre

estos tiempos. El speedup virtual en el programa ejecutable con el comando mosrun, nos da el

resultado que se muestra en la gráfica (Figura 5.10) que continuación se visualiza.

Tiempo secuencial Stress Tiempo cluster fisico Stress

Tiempo Speedup Fisico Stress

Tiempo secuencial Stress Tiempo cluster virtual Stress

Tiempo Speedup virtual Stress

Figura 5.9 Gráfica de comparacion entre tiempos secuenciales, cluster fisico y el speedup, aplicado al algoritmo de Stress.

Figura 5.10 Gráfica de comparación entre tiempos secuencial, cluster virtual y el speedup aplicado al algoritmo de Stress.

65

5.4 Cálculo de Pi por medio del Algoritmo de Gregory- Leibniz

En las matemáticas el valor de Pi tiene aplicaciones en el campo del cálculo y la física. Existen

muchos métodos para encontrar su valor exacto, entre ellos el cálculo de PI por el método de

Gregory – Leibniz. Tanto Leibniz como James Gregory, usaron para llegar a su resultado una serie

de sumatorias y así la serie se expresa como:

Esta expresión converge en una serie infinita, que al finalizar da como resultado π/4.

La formula de PI de Leibniz, requiere que dado un numero n, pueda llegar al valor deseado de Pi. Si

n es un número cercano a 3, 000,000. El valor más cercano es:

3.141592453589793238464643383279502784197169399134454111...

Con esto se puede crear su algoritmo y traducirlo posteriormente a un lenguaje de programación

que pueda representar casi en su totalidad el número pi.

Complejidad computacional del algoritmo de Pi por el método de Gregory- Leibniz:

Algoritmo Leibniz

Flotante largo suma=0.0, suma1=0.0, suma2=0.0, k,k1,n=100000;

k=2*n; ---O(1)

k1=-3; ---O(1)

k2=-1; ---O(1)

Mientras (k1<(k-3)) hacer ---O(log n)

inicio

k1=k1+4; ---O(1)

suma1= suma1+1/k1; ---O(1)

fin_mientras;

Escribe("La suma1 es", suma1);

Mientras (k2<(k-3)) hacer --- O(log n)

inicio

k2=k2+4; ---O(1)

suma2= suma2+1/k2; ---O(1)

fin_mientras;

Escribe("La suma2 es ",suma2); ---O(1)

66

suma = 4*(suma1-suma2); ---O(1)

Escribe("El valor de PI de Leibniz es de:",suma);

Fin.

La complejidad computacional de este algoritmo es de O(n log n), podemos hablar de un algoritmo

cuasi-lineal, ya que su tiempo se eleva según el numero de iteraciones que se lleven a cabo en los

ciclos repetitivos mientras.

Traducción a lenguaje C del algoritmo Pi por el método de Gregory-Leibniz

#include <stdio.h>

#include <stdlib.h>

main( )

{

long double suma =0.0,suma1=0.0, suma2=0.0, k, k1,k2, n=1000000;

//aquí se modifica la numeración

k=2*n;

k1=-3;

k2=-1;

while (k1<(k-3)) //primera sumatoria

{

k1=k1+4;

suma1= suma1+1/k1;

}

printf("La suma1 es %f \n",suma1);

while(k2<(k-3)) //segunda sumatoria

{

k2=k2+4;

suma2= suma2+1/k2; }

printf("La suma2 es %f \n",suma2);

suma=4*(suma1-suma2); //sumar las 2 primera sumatorias y multiplicarlos por 4 ya que es el

valor de ¼ deseado

}

printf("El valor de PI es de %.90Lf \n", suma);

}

5.4.1 Análisis de tiempo de ejecución del algoritmo PI por el método de Gregory-

Leibniz en secuencial, paralelo físico, paralelo virtual y su Speedup

Análisis Secuencial

El análisis hecho a este algoritmo, el cual es de los tradicionales para su valoración en tiempo de

ejecución, llevó a un muestreo entre 1500 y 98, 000,000. El algoritmo de Pi se ha utilizado como

una prueba de ejecución en diversos clusters del mundo. Para mostrar los resultados cercanos al

67

valor de pi, es necesario utilizar un tipo de datos para mostrar flotantes largos, se utiliza un Long

double en lenguaje de programación en C. En la tabla 5.3, se muestran los tiempos que dieron como

resultado de la ejecución del algoritmo de PI de Gregory-Leibniz, ya sea secuencialmente, en el

cluster fisico, cluster virtual y los diferentes tiempos de la formula de Speedup.

CALCULOS DE TIEMPOS EN EL ALGORITMO DE PI GREGORY-LEIBNIZ

Muestras T. Secuencial T. Cluster fisico T. Cluster virtual T. Speedup Fisico T. Speedup Virtual

1500 0.002 0.001 0.001 1.002 1.002

5800 0.002 0.001 0.002 1.002 0.002

7000 0.002 0.002 0.002 0.002 0.002

8500 0.004 0.002 0.002 1.004 1.004

22000 0.004 0.002 0.003 1.004 0.337333333

91000 0.004 0.003 0.003 0.337333333 0.337333333

147000 0.004 0.003 0.004 0.337333333 0.004

789000 0.016 0.013 0.015 0.246769231 0.082666667

1000000 0.025 0.016 0.017 0.5875 0.495588235

5000000 0.1 0.08 0.088 0.35 0.236363636

10000000 0.185 0.164 0.17 0.31304878 0.273235294

98000000 1.775 1.555 1.675 1.9164791 1.834701493

Tabla 5.3 Muestras, tiempos calculados secuencialmente en cluster fisico y cluster virtual con el algoritmo PI Gregoy-Leibniz.

Con las muestras tomadas, se llevo a cabo la ejecución en solo nodo, dando así el resultado

secuencial que se muestra en la siguiente gráfica (Figura 5.11).

Tiempo secuencial Pi- Leibniz

Figura 5.11 Gráfica de prueba secuencial aplicado al algoritmo de PI de Gregory-Leibniz.

68

En el cluster físico se llevo a cabo la ejecución programa PI de Leibniz, corriendo las muestras que

se utilizaron en el cluster virtual y se diferencia en los tiempos que muestra la gráfica (Figura 5.12).

Al ejecutar el algoritmo de Pi en el cluster virtual, en los tiempos tomados se observa (Figura 5.13),

que es mejor el tiempo paralelo obtenido.

Tiempo cluster fisico Pi- Leibniz

Tiempo cluster virtual Pi- Leibniz

Figura 5.12 Gráfica de prueba en cluster fisico, aplicado al algoritmo de Pi de Gregory-Leibniz.

Figura 5.13 Gráfica de prueba en cluster virtual, aplicado al algoritmo de Pi de Gregory-Leibniz.

69

La fórmula del speedup aplicable para comparar los tiempos entre el cluster fisico y el nodo

individual que calcula secuencialmente el cluster virtualizado. Al aplicar esta fórmula se puede ver

(Figura 5.14) que la mejora resulta suficiente para escoger al cluster paralelo sobre la ejecución de

programas en el nodo secuencial.

También se calcula el speedup para ver la comparación de los tiempos entre el cluster virtual y el

nodo secuencial. Los cuales toman una gráfica (Figura 5.15) parecida a la obtenida en el speedup de

el cluster físico.

Tiempo secuencial Pi-Leibniz Tiempo cluster fisico Pi-Leibniz

Tiempo Speedup Fisico Pi-Leibniz

Tiempo secuencial Pi-Leibniz Tiempo cluster virtual Pi-Leibniz

Tiempo Speedup virtual Pi-Leibniz

Figura 5.14 Gráfica de comparacion entre tiempos secuencial, cluster físico y el speedup, aplicado al algoritmo de Pi de Gregory-Leibniz.

Figura 5.15 Gráfica de comparación entre tiempos secuencial, cluster virtual y el speedup aplicado al algoritmo de Pi de Gregory-Leibniz.

70

5.5 Algoritmo recursivo de las Torres de Hanoi

El juego de las torres de Hanoi, se compone de tres torres (A,B,C), y dependiendo del número de

anillos, estos se pueden mover de la torre A a la torre C en el menor tiempo posible. No se mueve

más de un anillo a la vez, y no se puede poner un anillo grande encima de otro más pequeño.

Solución.

El juego es siempre posible y requiere el doble del tiempo, cada vez que se añade un anillo a la torre

original. Si se puede resolver el problema de 3 anillos estos tienen que llegar a la solución de

ordenamiento en 7 movimientos. Y si aumenta el número de anillos, el número de movimientos

aumenta, haciendo más lento el proceso. Se dice que el número más alto de anillos que se puedan

utilizar es de 64 anillos, ya que tardaría hasta millones de años en solucionar el problema.

Complejidad computacional en el algoritmo de las Torres de Hanoi:

Algoritmo Torres

Inicio

Entero n, n_moves;

Hacer Escribe(“Ingresa el tamaño de la torre”);

Lee(n);

Mientras (n <= 0); ---O(n)

n_moves=move_tower(n,1,2); ---O(1)

Escribe("La solucion requiere %d movimientos.\n", n_moves);

Fin.

Función entero move_tower (entero n, entero from, entero to)

{

entero aux;

entero n_moves; si (n == 1) Entonces ---O(1)

inicio

Escribe("Moviendo anillo [1] para poste no. a poste no.", from, to);

Fin_si

aux = 6 - from - to; ---O(1)

n_moves = move_tower (n - 1, from, aux); ---O(1)

Escribe("Moviendo anillo [ ] de poste . a poste no. ", n, from, to);

n_moves++; ---O(1)

n_moves += move_tower (n - 1, aux, to); ---O(1)

retorna(n_moves);

}

71

La complejidad de este algoritmo es O(n).

Al traducir el algoritmo a lenguaje C, para ser compilado por gcc.

#include <stdio.h>

#define MAX_LINE 80

int move_tower (int n, int from, int to);

int main ()

{

char in[MAX_LINE];

int n; int n_moves;

do

{

printf ("Ingresa el tamaño de la torre: ");

scanf ("%s", in);

n = atoi(in);

} while (n <= 0);

n_moves = move_tower (n, 1, 2);

printf ("La solucion requiere %d movimientos.\n", n_moves); return (0);

}

int move_tower (int n, int from, int to)

{

int aux;

int n_moves;

if (n == 1)

{

printf ("Moviendo anillo [1] para poste no. %d a poste no. %d\n", from, to);

return (1);

} aux = 6 - from - to;

n_moves = move_tower (n - 1, from, aux);

printf ("Moviendo anillo [%d] de poste . %d a poste no. %d\n", n, from, to);

n_moves++;

n_moves += move_tower (n - 1, aux, to);

return (n_moves);

}

5.5.1 Muestras y tiempos secuencial, paralelo físico, paralelo virtual y ganancia en el

speedup, con el algoritmo de Torres de Hanoi.

Las muestras que se tomaron para ejecutar el algoritmo de las torres de Hanoi (Tabla 5.4), fueron

imprescindibles, ya que mientras más alta se la muestra, el algoritmo se puede ejecutar con lentitud.

La muestra más alta que hace el algoritmo sea casi imposible de resolver es el numero 64, ya que

72

aun sea el equipo más veloz del mundo, la solución para la muestra con el numero 64 tardaría casi

un millón de años, en resolverse.

CALCULOS DE TIEMPOS EN EL ALGORITMO DE LAS TORRES DE HANOI

Muestras T.Secuencial T. Cluster fisico T. Cluster virtual T. Speedup Fisico T. Speedup Virtual

2 0.002 0.001 0.001 1.002 1.002

3 0.002 0.001 0.001 1.002 1.002

5 0.002 0.001 0.002 1.002 0.002

7 0.002 0.001 0.002 1.002 0.002

10 0.085 0.025 0.03 2.485 1.918333333

12 0.348 0.22 0.235 0.929818182 0.828851064

14 0.904 0.809 0.897 1.021428925 0.91180379

15 2.896 1.31 2.001 4.106687023 3.343276362

17 11.612 5.223 5.258 12.83524335 12.82044428

19 26.547 18.397 21.201 26.99000701 26.79915792

Tabla 5.4 Muestras, tiempos calculados secuencialmente, en cluster fisico y cluster virtual con el algoritmo de las Torres de Hanoi.

Un inconveniente en las torres de Hanoi es su naturaleza recursiva, con lo cual el retardo en el

tiempo de ejecución de las muestras empleadas secuencialmente en la ejecución en una sola

computadora nos deja ver que se consume un tiempo demasiado alto, la gráfica nos visualiza este

resultado (Figura 5.16).

Tiempo secuencial Torres de Hanoi

Figura 5.16 Gráfica de prueba secuencial aplicado al algoritmo de las Torres de Hanoi.

73

De la misma forma se hicieron las pruebas necesarias en el cluster físico para hacer notar la

diferencias de tiempo entre éste y el nodo secuencial. Los tiempos en que se ejecutaron se muestra

(Figura 5.17) en la gráfica en una línea ascendente a través del tiempo.

El cluster virtual ejecutándose en cuatro máquinas virtuales, solicita gran demanda de memoria,

además de que el sistema anfitrión soporte gran cantidad de procesos trabajando. Al ejecutarse las

muestras en el cluster virtual se puede ver en la gráfica una ligera diferencia entre el cluster fisico y

el cluster virtual. En la gráfica se muestra el resultado obtenido (Figura 5.18).

Tiempo cluster fisico Torres de Hanoi

Tiempo cluster virtual Torres de Hanoii

Figura 5.17 Gráfica de prueba en cluster fisico, aplicado al algoritmo de las torres de Hanoi.

Figura 5.18 Gráfica de prueba en cluster virtual, aplicado al algoritmo de las torres de Hanoi.

74

En la figura 5.19, se muestra el resultado del speedup aplicado al cluster fisico y su comparación

con el nodo secuencial para notar la diferencia de tiempos entre estos.

La aproximación de los tiempos que el speedup nos mostró y resultaron al ejecutar el programa de

la torre de Hanoi en el cluster virtual y comparándolo con el nodo secuencial, resulta en una gráfica

cercana al speedup que se realizó en el cluster físico (Figura 5.20).

Tiempo secuencial Torres de Hanoi Tiempo cluster fisico Torres de Hanoi

Tiempo Speedup Fisico de Torres de Hanoi

Tiempo secuencial Torres de Hanoi Tiempo cluster virtual Torres de Hanoi

Tiempo Speedup Fisico de Torres de Hanoi

Figura 5.19 Gráfica de comparación entre tiempos secuenciales, cluster fisico y el speedup aplicado al algoritmo de las torres de Hanoi.

Figura 5.20 Gráfica de comparación entre tiempos secuenciales, cluster virtual y el speedup aplicado al algoritmo de las torres de Hanoi.

75

5.6 Monitorización de un programa en ejecución

Todos los programas que se ejecutaron ya sea en forma secuencial, como en forma paralela física o

paralela virtual; fueron monitoreadas con el comando mon para programas en paralelo y para

monitorear en forma secuencial, se utiliza el programa monitor del sistema, el cual ayuda a ver el

funcionamiento de cada uno de los nodos en el cluster.

En la siguiente figura, se muestra el desempeño de manera secuencial del algoritmo de las Torres de

Hanoi, se observa el trabajo de la red y como el CPU del nodo maestro trabaja a un 60% de su

capacidad (ver Figura 5.21).

Para monitorear paralelamente como ya se ha mencionado, es necesario utilizar el comando mon y

con este comando podemos ver sus procesos en migración de nodo a nodo.

Figura 5.21 Monitor del sistema, mostrando el trabajo del CPU, la red, al momento de trabajar con el cluster.

76

En la Figura 5.22 se muestra el algoritmo de Stress, ejecutándose con el mosrun en una terminal y

el comando mon monitoreando los procesos en otra terminal.

Figura 5.22 Monitoreo de los recursos del procesador, capacidad de la memoria y trabajo en red del Algoritmo de las Torres de Hanoi en cluster paralelo físico.

77

Capitulo 6: Conclusiones y trabajo a futuro

6.1 Conclusiones

Este trabajo está basado en Mosix, el cual es un software que contiene un conjunto de parches, entre

ellos el parche para el kernel del sistema operativo en el cual se está instalando. Se puede ver tanto

en el cluster virtual como en el cluster físico de una buena conexión en red de alta velocidad y de

una buena capacidad de memoria RAM para trabajar óptimamente. Las pruebas de desempeño que

se realizaron en cada uno de los cluster nos arrojaron resultados favorables en lo relacionado al

tiempo de ejecución. En el cluster físico en comparación al cluster virtual, el desempeño obtenido

es ligeramente mayor al que se realizó en el cluster virtual, debido al consumo de memoria de todas

las máquinas virtuales, que en la realidad el tamaño de memoria no se compara al de las máquinas

físicas. Cabe mencionar que las empresas que utilizan máquinas virtuales, utilizan servidores como

anfitriones con una buena capacidad de memoria y un procesador potente para realizar las

operaciones.

En la prueba de desempeño se observó el comportamiento de cada uno de los algoritmos ejecutados

tanto física como paralelamente. De los algoritmos que se ejecutaron, los más lentos fueron los

recursivos, como: el cálculo del factorial y las torres de Hanoi, los cuales en el estudio de su

complejidad computacional el resultado dado es O(n!), con lo cual nos demuestra el retardo en la

ejecución. En todos los casos en los que se hicieron las pruebas de desempeño tanto física como

virtualmente, el algoritmo con un mejor desempeño fue el algoritmo por el método de Gregory-

Leibniz.

El desempeño virtual en algunas de las ejecuciones obtuvo un tiempo elevado que no se esperaba,

debido a que la ejecución tardó más de lo que se hace en el cluster físico.

Mosix no es solamente un programa que forma parte de un sistema operativo, también es un

programa que trabaja silenciosamente y que cuando se está ejecutando algún programa en paralelo

la carga de trabajo lo migra de nodo en nodo buscando un nodo disponible para su ejecución. Tanto

en el cluster físico como en el cluster virtual se pueden añadir más nodos, con esto se puede hacer

más potente el trabajo del cluster, sin embargo la desventaja de Mosix es que trabaja con licencias.

En este trabajo se utilizó una licencia gratuita para conectar hasta 6 nodos, con lo cual hace que el

desempeño en algunas ocasiones no sea el esperado. Si se quiere expandir a mas de 6 nodos (lo cual

es recomendable), se tiene que comprar una licencia según el número de nodos que se quieren

anexar al cluster. Con esto el desempeño de un trabajo ejecutado en paralelo se espera sea eficiente

y en menor tiempo.

78

De la elaboración del proyecto en donde se ha creado el cluster virtual, se concluye que cumple con

las expectativas esperadas, como lo es la construcción del mismo y que al ser comparado con el

cluster físico, los tiempos de ejecución fueron óptimos. En comparación con otros clusters que se

han realizado con Mosix de forma física [26], se puede decir que el cluster virtual realiza las

operaciones de balanceo y alto desempeño en forma óptima. En lo relacionado a la virtualización,

no se encontraron trabajos acerca de clusters virtuales, debido a que aún se están desarrollando

aplicaciones y sus beneficios [34].

6.2 Trabajos a Futuro

Con el desarrollo de este trabajo quedaron algunas expectativas en el desarrollo de cluster para el

uso de la investigación científica. En el caso del Tecnológico de Estudios Superiores de Jocotitlán,

donde se está desarrollando un cluster bajo el kernel de un sucesor de Mosix y este es el kernel de

Openmosix, el cual es de licencia libre y con el cual se pueden crear cluster con mucho más nodos

conectados en red, con la posibilidad de trabajar con mucho más software de prueba, así como más

distribuciones de Linux. Este cluster que cuenta con 4 nodos, será utilizado para la investigación

relacionada al análisis químico y problemas físicos que se relacionaran con estudios del entorno y

de la comunidad. Por otra parte también se necesita trabajar en un proyecto de investigación

relacionado a la criptografía con procesamiento de imágenes, con el cual se está haciendo la

investigación pertinente para correr un programa con 3 tipos diferentes de análisis criptográficos.

Con las técnicas de virtualización se trabajará en aplicaciones de clientes ligeros, los cuales al ser

implementados ayudarán a evitar costos muy altos en compra de equipo, que a cualquier institución

le reditúa en ahorro de miles de pesos. También el estudio de sistemas genéticos y médicos, en el

cual se incursionará en un futuro no muy lejano [24].

79

Referencias

[1] S. Weygant, Peter., Clusters for high availability, 2a. ed., Edit . Hewlett-packard Profesional.,

2003,345pp.

[2] G. Blank, Andrew., TCP/IP jumpstart: Internet protocol basics., Edit. ohn Wiley and Sons., año 2002., 336 pp.

[3] Marcus, Evans; Stern Hal, BluePrints for high availability: design resilient distributed systems,

2a. ed., Edit John Wiley & Sons, 2000- 344 pp.

[4] D. Sloan, Joseph,. High performance Linux clusters with OSCAR, Rocks, openMosix, and

MPI., 2a. ed. Edit. O'Reilly Media, Inc., 2005 - 350 pp.

[5] Bookman Charles., Building And Maintaining Linux Clusters., Edit. Sams Publishing, año

2003, 265 pp.

[6] Kopper, Karl., The Linux Enterprise Cluster: build a highly available cluster with commodity

hardware and free software., 2a Ed., No Starch Press, año 2005, 430 pp.

[7] Mitchell Mark , Oldham Jeffrey, Samuel Alex., Advanced Linux programming., 2a Ed., Edit, Sams Publishing., año 2001., 340 pp.

[8] Kaminsky, Alan., Building Parallel Programs: SMPs, Clusters, and Java., Edit. Cengage

Learning., año 2009., 878 pp.

[9] J. Chevance, René., Server architectures: multiprocessors, clusters, parallel systems, Web servers, and storage solutions, Edit. Digital Press., año 2005., 739 pp

[10] Geist, Al., PVM: parallel virtual machine : a users' guide and tutorial for networked parallel

computing., Edit. MIT Press., año 1994, 279 pp.

[11] Gropp William, Lusk Ewing, Skjellum Anthony., Using MPI: portable parallel programming

with the message-passing interface, Edit. MIT Press, año 1999.,371 pp.

[12] Snir, Marc., MPI--the Complete Reference: The MPI core, 1a Edicion., Edit. MIT Press., año 1998., 448 pp.

[13] E. Culler David, Pal Singh Jaswinder, Gupta Anoop., Parallel computer architecture: a

hardware/software approach., Edit. Gulf Professional Publishing., año 1999., 1025 pp.

[14] N. Bhuyan Laxmi, Zhang Xiaodong., Multiprocessor performance measurement and evaluation., Edit. IEEE Computer Society Press., año 1995., 477 pp.

[15] M. Shatz Sol, Wang Jia-Ping., Tutorial: distributed-software engineering., Edit.IEEE

Computer Society Press., año 1989., 279 pp.

[16] Romero Alfonso., Virtualbox 3.1., Edit. Packt Publishing, Limited., año 2010., 348 pp.

[17] Becker Dirk., VirtualBox: Installation, Anwendung, Praxis., Edit. Galileo Press., año 2009.,

321 pp.

[18] Lahoz-Beltrá Rafael., Bioinformática: simulación, vida artificial e inteligencia artificial., Edit.

Ediciones Díaz de Santos., año 2004., 574 pp.

[19] Boursas Latifa, Carlson Mark, Hommel Wolfgang., Systems and virtualization management:

standards and new technologies : second international workshop., Edit. SVM 2008, Munich, Germany., October 21-22, 2008.

80

[20] Barak Amnon, G. Wheeler Richard, International Computer Science Institute., MOSIX: an

integrated UNIX for multiprocessor workstations., Edit. International Computer Science Institute., año 1988., 16 pp.

[21] Barak Amnon, Guday Shai, G. Wheeler Richard., The MOSIX distributed operating system:

load balancing for UNIX., Edit. Springer-Verlag., año 1993., 221 pp.

[22] Milojicic Dejan, Douglis Frederick, Paindaveine Yves, Hewlett-Packard Laboratories., Process

migration., Edit. Hewlett-Packard Laboratories., año 1999., 48 pp.

[23] Milicchio Franco, A. Gehrke Wolfgang., Distributed services with OpenAFS: Edit. Springer

KK Japón., año 2007., 395 pp.

[24] Kötter Rolf,. Neuroscience databases: a practical guide., Edit Springer.,año 2003., 310 pp.

[25] Barak A., The evolution of the MOSIX Multi-computer UNIX System., Edit. Hebrew

University of Jerusalem. Dept. of Computer Science., Univ., 1989.

[26] Barak A., Running distributed applications under the MOSIX multi-computer system.,

Revision A. Barak, Hebrew University of Jerusalem. Dept. of Computer Science, R. Ben-Nattan, S.

Guday, L. Picherski, O. Sasson, E. Siegelmann., Univ., año 1989 ., 41 pp.

[27] M. Surhone Lambert, T. Timpledon Miriam, F. Marseken Susan., OpenSUSE: Operating

System, Linux Kernel, O penSUSE Project, Novell, SUSE Linux Distributions., Edit. Betascript

Publishers., año 2009., 108 pp.

[28] Roger Whittaker, Davies Justin., OpenSUSE 11.0 and SUSE Linux Enterprise Server Bible., Edit. John Wiley & Sons., año 2008., 840 pp.

[29] Kofler Michael., Linux 2010: Debian, Fedora, OpenSUSE, Ubuntu. 9., revisión ampliada y

mejorada., Edit. Pearson Education.,a ño 2009., pp 1216 páginas.

[30] Lottiaux Renaud, Dionnet Christine, Vallée Geoffroy, Gallard Pascal, Boissinot Benoît.,

OpenMosix, OpenSSI and Kerrighed., Edit IRISA., año 2004.

[31] W. Lucke Robert., Building clustered Linux systems., Edit. Prentice Hall PTR., año 2004., 606

pp.

[32] A. Patterson David, L. Hennessy John., Estructura y diseño de computadores., Editorial

Reverté, S.A., año 2000., 425 pp.

[33] Pages Montanera Enric, Gestion sostenible de clústers de recursos virtuales,memoria de proyecto de ing, 83 págs,Universidad Autonoma de Barcelona,2009.

[34] Barak Ammnon, The Mosix Organizational Grid A white Papper,Deparment of Computer

Science The Hebrew University of Jerusalem, Israel,August 2005.

81

ANEXOS

ANEXO A: Instalación de Mosix en otras distribuciones no SUSE.

Instalación de MOSIX

1. Obtener la distribución Mosix de http://www.mosix.cs.huji.ac.il/ vía ftp, la distribución usada en

este cluster es MOSIX-0.93.0.tar.gz.

2. Ejecutar el comando:

$ tar -xzvf MOSIX-0.93.1.tar.gz

en el directorio de su preferencia (/tmp por ejemplo)

3. Ir al directorio /usr/src/linux y ejecutar:

$ tar -xvf /tmp/kernel.new.2.2.10

(se asume que el directorio linux, es aquel desde el cual se configura el kernel del sistema).

4. Ejecutar:

$ patch -p 0 /tmp/patches.2.2.10

Hasta ahora lo que se ha hecho es agregar el Mosix como una opción mas del kernel del sistema.

5. Configurar el kernel del sistema:

* Seleccionar dentro del item nuevo (Mosix) además de las opciones preestablecidas, la

opción “prevent the -mosix extension in kernel name”'.

6. Compilar el nuevo kernel con los comandos:

$ make dep; make clean; make bzImage

$ make modules; make modules_install

7. Regresar al directorio /tmp y ejecutar:

$ ./mosix_install

y responder algunas preguntas:

* Specify in which run-levels (2-5) to run mosix [2345]:

Selecionar la opción por omisión presionando Enter, que especifica todos los niveles posibles.

* We can automaticaly add MOSIX to your Boot Loader Chose one from the list below:

1 LILO

2 GRUB

3 None

([1]/2/3):

Selecionar la opción 3, no añadir Mosix al loader automáticamente.

82

* Would you like MOSIX for LINUX to be your default boot kernel ([Y]/n):

Responder no, ya se ha compilado el kernel manualmente.

* If you already have a compiled MOSIX kernel from another node and the configurations

are the same, you need not compile the kernel again. Do you need to compile the kernel on this

node ([Y]/n)?:

Responder no, no se necesita compilar el kernel de nuevo.

* Are the pre-compiled Linux v2.2.10 kernel sources Available ([Y]/n)?:

Responder no, de esta manera precompila la instalación existente.

* This type of installation - without kernel sources, requires a pre-compiled MOSIX kernel

and modules. There should be a file on the node and directory where you previously compiled the

kernel named ``kernel_files.tgz'', which includes these files.

Path of the kernel_files.tgz file (``'' to skip the kernel installation)[]:

Seleccionar “”, no instalar nada en el kernel porque ya se ha hecho manualmente.

* se reciben dos mensajes de error: falla tune.c y mon.c ( si se utiliza la distribución Red Hat

6.0 no ocurre este error). La solución a este problema es:

Crear dos enlaces simbólicos:

ln s /usr/include/mosix /usr/src/linux/include/mosix

ln s /usr/include/mos /usr/src/linux/include/mosix

o buscar tune.c y editarlo, cambiar la palabra "HOWMANY" por cualquier otra por

ejemplo "HOWMANYp" y "signal.h" por "/bsd/signal.h", luego en el directorio donde se encuentre

tune.c ejecutar:

make install

o buscar mon.c y editarlo cambiando "signal.h" por "/bsd/signal.h", luego en el directorio donde se

encuentre tune.c ejecutar:

make install

8. Arrancar de nuevo el sistema.

9. Ejecutar la línea:

$ depmod -a 2.2.10

10. Ejecutar:

$ versionate

11. Correr por primera vez mosix para crear el mosix.map:

* Al ejecutar:

mosix start

83

Se mostrará un mensaje de error, puesto que aún no se ha configurado mosix.map, la cual es una

fila que luce como:

#Mosix #IP number of nodes

a la cual se va a agregar:

#Mosix #IP number of nodes

1 159.90.200.25 8

#Mosix, es la máquina inicial del cluster (1).

#IP es la dirección ip de la primera máquina de la red interna del cluster (159.90.200.25).

number of nodes, es el tamaño del cluster (8).

12. Editar el archivo /etc/rc.d/rc.local agregando antes de la línea de arranque de gpm:

if [ x /usr/local/bin/mosix ];

then /usr/local/bin/mosix start

fi

13. Ejecutar el comando:

$ cp mosix.init /usr/local/bin/mosix

14. Editar el archivo /usr/local/bin/mosix sustituyendo las líneas de comando /bin/grep por

/usr/bin/grep.

15. Cambiar la permisología:

$ chmod 755 /usr/local/bin/mosix

16. Arrancar de nuevo el sistema.

84

ANEXO B : Comandos Esenciales Utilizados En Mosix. Comando Mon, monitor de nodos.

$ mon -[opción]

El monitor de carga mon despliega un gráfico de barras, normalmente muestra la carga en los

nodos. Alternativamente, muestra la velocidad de los procesadores o la memoria disponible versus

la memoria total.

Las opciones disponibles son las siguientes:

-v Selección de numeración vertical. Este permite que la carga de muchos nodos sean mostradas en

cualquier momento.

-w Selección de numeración horizontal. Esto permite ver los nodos que están activos en cualquier

momento.

-t Despliega el conteo de los nodos operacionales

-d Despliega los nodos que se están operacionales y también los no operacionales.

Mientras se ejecuta mon se pueden pulsar las siguientes teclas:

h Muestra la ventana de ayuda.

Enter Redibuja la ventana.

v selecciona numeración vertical.

w Selecciona numeración horizontal.

a Selecciona numeración automática. La numeración vertical debe ser seleccionada si desea hacer

diferencia entre capacidad de ver la carga de todos los nodos o no. En caso contrario la numeración

horizontal seleccionada.

s Muestra la velocidad de los procesadores en lugar de la carga. 10000 unidades representan una

pentium-2 a 400MHz. Para nodos SMP, esta opción también muestra el número de nodos.

m Despliega memoria lógicamente usada versus memoria total: La memoria usada es mostrada

como una barra sólida mientras que la memoria extendida con signos +.

r Muestra la memoria no libre versus memoria total: La memoria usada es mostrada como una

barra sólida mientras la memoria total es extendida con signos+. La memoria se muestra en

megabytes.

u Muestra el porcentaje de utilización del procesador.

l Muestra la carga de nuevo.

d Muestra también los nodos que no responden.

D Detiene el despliegue de los nodos que no responden.

t Cambia mostrando el conteo de los nodos operacionales.

85

y Muestra el yardstick: esta es la velocidad de los procesadores típicos en el cluster MOSIX, 10000

unidades representan un Pentium-2 a 400MHz.

Right-Arrow Mueve un nodo a la derecha (cuando no todos los nodos pueden verse en la pantalla).

Left-Arrow Mueve un nodo a la izquierda (cuando no todos los nodos pueden verse en la pantalla).

n Mueve una pantalla a la derecha (cuando no todos los nodos pueden verse en la pantalla).

p Mueve una pantalla a la izquierda (cuando no todos los nodos pueden verse en la pantalla).

q salir de mon.

Para más información refiérase a las páginas de manual tecleando man mon, en la terminal.

Comando mps, da un reporte del status de los procesos multicomputadoras.

$ mps -[opción]

Aqui mencionaremos algunas opciones:

l Formato largo.

u formato de usuario: dado el nombre de usuario y inicia.

j Formato de tareas: pgid sid.

s Formato de señal.

v Formato vm.

m Muestra información de la memoria.

f Formato de árbol para la línea de comando.

a Muestra los procesos de otros usuarios.

x Muestra los procesos sin control terminal.

Comando mosrun. Ejecuta programas en el cluster mosix, dependiendo de sus opciones de

ejecución.

La principal ventaja de MOSIX es que los procesos pueden migrar y ejecutar en equipos (nodos)

distintos, de aquél en que comenzó, con el fin de mejorar el rendimiento. Los procesos de migración

son en forma automática y transparente, por lo que normalmente no es necesario saber dónde están

sus programas de ejecución.

Su nombre de usuario desde el shell, y por lo tanto todos los otros programas y scripts, se ejecuten

de forma estándar. Los programas de Linux, no se ven afectados por MOSIX, hasta que se solicite

para ejecutar algo bajo MOSIX, a través del comando “mosrun":

86

mosrun {options} {program} [arguments]

Dos directivas se usan para ejecutar "mosrun":

a) Por dónde empezar su programa.

b) Y la migración de procesos.

De forma predeterminada, el programa se inicia en el equipo de inicio de sesión (nodo maestro) y

permite que se migre a otros nodos del clúster al que pertenece el equipo (pero no a los nodos de

otros grupos en caso de que su grupo es parte de un multi-cluster). Los siguientes atributos

utilizados por mosrun sirven para ejecutar un programa y son:

-h Para poner en marcha a una hora en el equipo en el inicio de sesión de éste.

-r {host} Inicio de ejecución en un equipo dado.

-r {IP adress} inicio en el equipo con la dirección IP obtenida.

- {Número} inicio en cualquier numero de nodos, (definido por el administrador de sistemas).

-j {lista} elegir al azar de la lista separada por comas.

-b MOSIX permiten elegir el mejor nodo para empezar la ejecución.

Las siguientes directivas de control para utilizar en la ejecución de un programa a ejecutar (incluido

su proceso-hijo) puede ser utilizado para migrar de un nodo a otro:

- G Deja que el programa se pueda migrar dentro de un conjunto multi-cluster.

(Una clase de números puede seguir a la "G": clase números son generalmente suministrados por el

sistema de administrador).

-L prevenir las migraciones automáticas (excepto en caso de emergencia, las migraciones regresan a

su equipo de inicio de sesión).

-l Esta opción permite las actualizaciones automáticas (esta opción es útil cuando "mosrun" es

llamado por un script de shell y que se ejecuta en "mosrun-L").

-m {MB} Permite las actualizaciones automáticas sólo a los equipos con la cantidad dada de

memoria libre en megabytes. Esta opción también afecta a la inicial a la sesión en "b" (arriba) y cola

(abajo).

87

ANEXO C. Complejidad Computacional.

En el análisis computacional y en la creación de programas es necesario la medición de la

complejidad de los algoritmos, ya que dependiendo de esa complejidad será el tiempo en el que se

va a ejecutar el algoritmo en un lenguaje de programación. Algunos algoritmos dependiendo de los

ciclos repetitivos, sentencias, arreglos, etc; influyen en que consuma recursos de memoria y

recursos del procesador.

De este análisis depende si se puede paralelizar un algoritmo o realizarlo secuencialmente.

Analisis de Orden de complejidad.

Los algoritmos pueden medir su orden de complejidad, dependiendo del numero de entradas

ocupados en el algoritmo, y este análisis nos arroja una tabla de las complejidades que los

algoritmos puedan desarrollar.

Valor de n Orden de complejidad

O(1) Orden constante

O(log n) Orden logarítmico

O(n) Orden lineal

O(n log n) Orden cuasi-lineal

O(n2) Orden cuadrático

O(n3) Orden cúbico

O(na) Orden polinómico

O(2n) Orden exponencial

O(n!) Orden factorial