1

INSTITUTO POLITÉCNICO NACIONAL

UNIDAD PROFESIONAL INTERDISCIPLINARIA DE INGENIERIA Y CIENCIAS SOCIALES Y

ADMINISTRATIVAS Sección de Estudios de Posgrado e investigación

CONSTRUCCIÓN DE UNA MÁQUINA PARALELA PARA CENTROS DE

INVESTIGACIÓN.

TESIS QUE PARA OBTENER EL GRADO DE

MAESTRO EN CIENCIAS EN INFORMÁTICA

P R E S E N T A

JESÚS ANTONIO ALVAREZ CEDILLO

MÉXICO D.F. 2006

2

3

CARTA CESION DE DERECHOS En la Ciudad de México, D.F. el día 23 del mes de Marzo del año 2006, el que suscribe Jesús Antonio

Álvarez Cedillo alumno del Programa de Maestría en Ciencias en Informática con número de registro

A010396, adscrito a la Sección de Estudios de Posgrado e Investigación de la UPIICSA-IPN,

manifiesta que es autor intelectual del presente trabajo de Tesis bajo la dirección de Dr. Miguel Lindig

Bos y cede los derechos del trabajo intitulado CONSTRUCCIÓN DE UNA MÁQUINA PARALELA

PARA CENTROS DE INVESTIGACIÓN, al Instituto Politécnico Nacional para su difusión, con fines

académicos y de investigación.

Los usuarios de la información no deben reproducir el contenido textual, gráficas o datos del trabajo sin

el permiso expreso del autor y/o director del trabajo. Este puede ser obtenido escribiendo a la siguiente

dirección jaalvarez@ipn.mx. Si el permiso se otorga, el usuario deberá dar el agradecimiento

correspondiente y citar la fuente del mismo.

INSTITUTO POLITECNICO NACIONAL COORDINACION GENERAL DE POSGRADO E INVESTIGACION

4

A Dios: Por su infinita gracia, por haberme dado una vida hermosa y plena, una familia maravillosa y por dejarme encontrar una esposa inteligente y comprensiva y por darme sólo el poco de entendimiento y sabiduría que me han permitido llegar a este punto.

5

A Mi Esposa: Como una pequeña muestra de agradecimiento por todo lo que me ha dado y enseñado.

6

A mis Hermanos: Por el gran apoyo que siempre me han brindado, por su gran nobleza y por la fuerza que cada uno me ha inspirado para seguir adelante en momentos difíciles

7

A mis Padres: Como reconocimiento a su apoyo incondicional y comprensión y como muestra de un esfuerzo conjunto para alcanzar una meta más. Los Amo.

8

A mis profesores y compañeros: Especialmente a mi director de tesis Dr. Miguel Lindig Bos por sus consejos, apoyo y por creer en mí, así como por su orientación magnífica para terminar este trabajo, y al M. En C. Eduardo René Rodríguez Ávila por su atinadas correcciones

9

“CONSTRUCCIÓN DE UNA MÁQUINA PARALELA PARA CENTROS DE INVESTIGACIÓN “

RESUMEN.

Debido a la situación económica actual de nuestro país y ante la imposibilidad de que los centros de investigación cuenten con los recursos adecuados y herramientas para desarrollar proyectos no teóricos, se hace prioritario aplicar nuevas técnicas y desarrollar nuevas herramientas que debido a su bajo costo, puedan ser implementadas y no necesiten de largos procesos para su adquisición.

Es en este marco de referencia donde se ubica la creación de una computadora diseñada

especialmente para la investigación, que explote él cómputo distribuido y el procesamiento paralelo y que pueda ser operada bajo una instrucción mínima por investigadores de cualquier parte y de cualquier rama de la ciencia, que busquen explotar el procesamiento paralelo con un desempeño alto o considerable.

Es necesario considerar que en México el tema del súper cómputo no ha sido explotado

adecuadamente, ya que por lo general un equipo con estas características sólo lo tienen las grandes empresas comerciales por su alto costo, por la misma razón, es casi imposible que un centro de investigación pueda adquirir este recurso cuando el equipo cuesta millones de dólares.

Un investigador que cuente con este tipo de herramientas podrá auxiliar sus

investigaciones aplicando el procesamiento recursivo y paralelo, para realizar pruebas prácticas de los modelos que genere, podrá realizar simulaciones y proponer ambientes de prueba.

Por otro lado, contar con una máquina paralela que soporte los estándares de programación

de facto de la industria, permitirá a los centros de investigación, crear programas de aplicación real inclusive para otras plataformas que soporten el estándar sobre súper computadoras comerciales de marca. Estos programas contribuirán al desarrollo de nuevos investigadores que a su vez aportarán con sus descubrimientos al desarrollo tecnológico y económico del país.

Es necesario destacar que el software libre en el mundo ha comenzado a ganar terreno a

partir de la creación del sistema operativo Linux , hecho que ha permitido a millones de programadores y científicos del mundo poder generar nuevas aplicaciones gracias a un ambiente común y de acceso total sobre los códigos de programación.

10

“CONSTRUCTION OF A PARALELL MACHINE FOR RESEARCH CENTERS”

ABSTRACT.

Due to the current economic situation of our country and the imposibility for research centers to get adecuate resources and tools to develop non-theoretical projects, it becomes a priority to apply new techniques and to develop new tools that they may be readily implemented, due to their low cost and short adquisition times.

It is under this frame of reference where the design of a high-performance computer

becomes desirable, specifically oriented toward research problems, based on distributed and parallel processing concepts and requiring a minimum of instruction in its use for researchers of any specialty that wish to exploit recursive processing with high levels of performance.

It is necessary to recall that in Mexico the subject of supercomputing has not been

explored in depth since, in general, this type of equipment is only available to very large corporations due to its high cost of many thousands of dollars. For the same reason, is almost impossible to be aquired by a public or government research center.

A researcher that counts with this tools is able to improve his work by applying recursive

and parallel processing, to apply tests to the models that its generates, to run detailed simulations and to develop test environments.

On the other hand, the availability of a parallel machine that runs de facto industry-

standard software would allow research centers to develop new application software compatible with other platforms, including commercially availlable high-performance machines. These application programs would aid in the education of new researchers which, in turn, due to the results of their work would contribute to the technological and economic growth of the country.

It is necessary to highlight that the importance of free software has been steadyly growing

since the introduction of the Linux operating system. This fact has permitted that millions of programmers and scientists in the whole world can generate and share new applications, thanks to a common environment and total access to source code.

11

GLOSARIO DE TÉRMINOS ACCESO DEDICADO. Servicio que proporciona conectividad, en la misma localidad, entre los inmuebles del cliente y un punto de presencia de un Operador, de forma tal que el cliente pueda utilizar los servicios proporcionados por dicho Operador. ADDRESS. (Vea Dirección). ALGORITMO: Conjunto finito de pasos estructurados en el tiempo, acorde a un conjunto finito de reglas que proveen la solución a un problema o indica la falta de ésta. ANCHO DE BANDA. Medida de capacidad de comunicación o velocidad de transmisión de datos de un circuito o canal analógico. Cuando se trata de transmisiones analógicas, el ancho de banda es la diferencia entre las frecuencias superior e inferior en un rango dado. Se mide en ciclos por segundo o hertzios (Hz). En las transmisiones digitales, el ancho de banda se mide en bits por segundo (bps) y cuanto más grande sea este número, más rápida será la transmisión. La velocidad es importante para los dispositivos de entrada/salida ya que un bus con un ancho de banda escaso puede limitar sus capacidades. ARP. Address Resolution Protocol. Protocolo que se utiliza para averiguar la dirección del enlace correspondiente a la dirección IP. ARPANET. Advanced Research Projects Agency Network [Red de la Agencia de Proyectos Avanzados de Investigación]. Red desarrollada en 1969 por parte del Departamento de Defensa de los Estados Unidos en la experimentación de una amplia red que funcionara a pesar de que parte de la red quedara fuera de servicio. Desapareció en 1990 propiciando la aparición de la tecnología de conmutación de paquetes y del protocolo TCP/IP. Dio origen a Internet. ASCII. American Standard Code for Information Interchange [Codificación Americana Normalizada para el intercambio de Información]. Norma mundial para la codificación usada en las computadoras a fin de representar los caracteres requeridos para la comunicación entre máquinas. Hay 128 códigos normalizados ASCII, cada uno de los cuales se puede representar con un número binario de 7 dígitos. Este código le asigna 8 bits a cada carácter. ASÍNCRONO. Tipo de comunicación que envía datos usando control del flujo sin necesidad de sincronizar entre una terminal origen y un terminal destino. AUTENTICACIÓN. Proceso de validación de la conexión del usuario que determina el permiso de acceso a los recursos del servidor.

12

BAJA LATENCIA. Un periodo de tiempo muy corto, el cual está destinado a la transmisión y recepción de los datos desde que son emitidos por el puerto transmisor y hasta que alcanzan al puerto receptor. BANDA AMPLIA. Ruta/circuito de comunicaciones de capacidad media. Suele indicar una velocidad de 64 kbps a 1.544 Mbps. BANDA ANCHA. Ruta/circuito de comunicaciones de gran capacidad. Normalmente implica una velocidad superior a 1.544 Mbps. BANDA BASE. Método de transmisión de datos en una red que utiliza el ancho de banda completo para una transmisión individual. Ejemplo: Ethernet, realiza una única transmisión en cada momento. BANDWIDTH. (Ver Ancho de Banda). BIND. Berkeley Internet Name Domain. [ Nombre de dominio internet Berkeley]. Una de las primeras implementaciones del sistema de nombres de dominio de Internet. BIOS. Basic Input Output System. [ Sistema Básico de Entrada/Salida ]. Programa que se encuentra en la mayoría de los ordenadores y que controla el proceso de arranque de la máquina y otras funciones básicas como el funcionamiento del teclado o las unidades de disco. Los ordenadores antiguos almacenaban el BIOS en un chip que no se podía borrar, mientras que en los más modernos, el programa se puede actualizar, ya que se guarda en un chip que se puede borrar y reprogramar. BIT. Binary digit. [Dígito binario]. Unidad elemental de la información. Puede ser 0 ó 1. Físicamente, el bit se puede representar como un transistor en una célula de memoria, un punto magnetizado en la superficie de un disco o como un pulso enviado a través de un circuito. Cuando se combinan formando varios bytes, también llamados palabras, pueden representar grandes cantidades de información. En la mayoría de los sistemas, ocho bits consecutivos forman un byte, que es equivalente a un carácter alfanumérico. Las transmisiones se suelen medir en bits por segundo (bps), lo que indica el número de bits que pasan por un determinado punto en un segundo. BOOTP. Boot Protocol. Protocolo usado para arrancar estaciones de la red de forma remota. BROWSER. [ Navegador ]. Programa que permite visitar sitios en Internet. BYTE. Conjunto de 8 bits (por estandar de úso). Es la mínima cantidad requerida para representar cada símbolo alfanumérico.

13

CLUSTER. [Lit. racimo]. Es un grupo de sectores de un disco (normalmente de dos a ocho) que se trata como una entidad por el sistema operativo o la controladora de disco. Este término se refiere a veces a un grupo de terminales informáticos conectados a un sistema. DAEMON (Demonio). Programa que se ejecuta de modo independiente al navegador. Los Demonios pueden realizar varias tareas administrativas como las de construir índices, resúmenes y retroenlaces. En Unix se utiliza el término por el de servidor debido a que los servidores operan de modo independiente. DATAGRAMA. Paquete individual de datos que es enviado a un equipo receptor sin ninguna información que lo relacione con ningún otro posible paquete. DHCP. Dynamic Host Configuration Protocol. [ Protocolo de configuración de equipo dinámico]. Método que asigna automáticamente direcciones IP a clientes de una red. DIRECCIÓN IP. Dirección de 32 bits del protocolo Internet asignada a un ordenador conectado a Internet. La dirección IP tiene un componente del propio ordenador y un componente de la red. Este número tiene el formato de cuatro grupos de hasta tres dígitos binarios, cada uno con valores de cero a doscientos cincuenta y cinco, separados por un punto. DNS. Domain Name System. [Sistema de Nombres de Dominio]. Base de datos distribuida que gestiona la conversión de direcciones de Internet expresadas en lenguaje natural a una dirección numérica IP. ETHERNET. Tipo de red local que usa la configuración en BUS, que no puede sobrepasar los 2000 metros de longitud. FAST ETHERNET. Versión de Ethernet que permite transferencias de datos entre 10 y 100 Mbps u usa protocolo CSMA/CD. FTP. File Transfer Protocol. [Protocolo de transferencia de archivos]. Es el método común de enviar archivos entre computadoras en Internet. GUI. Graphical User Interface. [ Interfaz gráfica de usuario ]. Se trata de una interfaz que utiliza símbolos gráficos, llamados íconos, y menús para gestionar los recursos de un ordenador. Se puede trabajar por medio de un ratón o un teclado y está diseñada para resultar más fácil de usar y más intuitivo que una interfaz basada en caracteres (texto), como el MS-DOS, que requiere que se introduzcan órdenes escritas a través del teclado. Actualmente, los dos sistemas operativos más

14

utilizados que operan mediante una interfaz gráfica de usuario son Windows , X11 y MacOS. Unix es un sistema basado en caracteres que también permite la incorporación de una interfaz gráfica de usuario, entre otros. HOST. [Anfitrión]. Es una computadora en una red. Antes se denominaba con el término "nodo" que se utiliza en el lenguaje de definición de documentos. Muchas veces se usa como sinónimo de servidor. HTTP. Hipertext Transfer Protocol. [ Protocolo de transferencia de hipertexto ]. Es un conjunto de estándares que permite a los usuarios de la Web intercambiar información. Es el método que se utiliza para transferir documentos desde el sistema donde se almacenan las páginas hasta los usuarios individuales. IP . (Ver DIRECCIÓN IP ). ISO. International Standard Organization. [ Organización Internacional de Estándares ]. Fundada en 1947 reúne asociaciones de unos 90 países y su objetivo es establecer los estándares internacionales, incluidos para la comunicación de datos LINUX. Es un sistema operativo multitarea y multiusuario de 32 bits para PC desarrollado inicialmente por Linus Toorvald, modificado y mejorado por programadores de todo el mundo. Su distribución es gratuita. NFS. Protocolo desarrollado por Sun Microsystems para permitir que una computadora pueda acceder a los archivos de otro equipo como si éstos fueran propios. NODO. Su definición original es la de punto donde convergen de dos líneas. En informática, el término se refiere muchas veces a una máquina conectada a Internet, aunque lo normal es que se hable de un punto de confluencia en una red. NFTS. NT File System. Sistema de archivos propio de Windows NT, que permite nombres largos, reduce la fragmentación de archivos, proporciona tolerancia a fallos e incrementa el sistema de seguridad. OSI. Open Systems Interconnection. [ Interconexion de Sistemas Abiertos ]. Modelo de referencia de interconexión de sistemas abiertos propuesto por la organización de normalización ISO. Divide las tareas de la red en siete niveles. PING. Packet Internet Grouper. [ Buscador de Paquetes Internet ]. Programa utilizado para comprobar si un servidor está disponible. Envía paquetes de control para comprobar si el servidor esta activo y los

15

devuelve. PLATAFORMA. Conjunto de tecnologías que obedecen a un estándar sobre las cuales los procesos corren en forma natural independientemente de su arquitectura PROTOCOLO. Conjunto de reglas y normas que determinan cómo se realiza un intercambio de datos, asegurando que los datos recibidos son idénticos a los datos enviados. PUERTO. Dispositivo físico o lógico que forma parte de la infraestructura de una red y que funge como interfase entre el equipo de datos del Usuario y la red . RARP. Reverse Address Resolution Protocol. [ Protocolo de Resolución de Dirección inversa ]. Protocolo de bajo nivel para la asignación de direcciones IP a maquinas simples desde un servidor en una red física. RED. Sistema de elementos interrelacionados que se conectan mediante un vínculo dedicado o conmutado para proporcionar una comunicación local o remota (de voz, vídeo, datos, etc.) y facilitar el intercambio de información entre usuarios con intereses comunes. SERVIDOR. En una red, es un ordenador que proporciona servicios a otros equipos (estaciones) . TCP/IP. Transfer Control Protocol/Internet Protocol. [ Protocolo de control de transmisiones / Protocolo Internet ]. Es el protocolo estándar de comunicaciones en red y transporte del modelo OSI, utilizado para conectar sistemas informáticos a través de Internet ( Vea también DIRECCIÓN IP ). TELNET. TELe NETwork. [ Tele Red ]. Programa de red que ofrece una forma de conectarse y trabajar desde otro equipo. Utiliza una conexión a un servidor por medio de la cual el ordenador cliente del usuario emula una terminal virtual. UNIX. Sistema operativo multitarea y multiusuario de gran importancia en el desarrollo y evolución de Internet. WAN. Wide Area Network. [ Red de Área Amplia ]. Red de ordenadores conectados entre sí, dispersos geográficamente, localizados a gran distancia.

16

ÍNDICE

INTRODUCCIÓN.....................................................................................................................................1

1.1 Antecedentes Teóricos Básicos ...........................................................................................................6

1.2 Posix (Portable Operating System Interface) ....................................................................................8

1.3 El Sistema Operativo Linux................................................................................................................9

1.4 El Paradigma Cliente Servidor.........................................................................................................11

1.5 Direcciones IP ...................................................................................................................................12

1.6 Taxonomía de arquitecturas.............................................................................................................15

1.6.1 Clasificación de Flynn ...................................................................................................................... 15

1.6.2 Sistema único flujo de instrucciones sobre un único flujo de datos................................................ 15

1.6.3 Sistemas SIMD (Single Instruction stream, Multiple Data stream) ............................................... 16

1.6.4 SIMD con CPU particionada ........................................................................................................... 16

1.6.5 SIMD con múltiples ALU................................................................................................................ 17

1.6.6 Sistemas MISD (Multiple Instruction stream, Single Data stream). .............................................. 18

1.6.7 Sistemas con un flujo de múltiples instrucciones que operan sobre múltiples datos MIMD (Multiple Instruction stream, Multiple Data stream) .............................................................................. 18

1.7 Categorías de Computadoras Paralelas ...........................................................................................19

1.7.1 Multiprocesadores ............................................................................................................................ 19

1.7.2 UMA (Uniform Memory Access) ..................................................................................................... 20

1.7.3 Sistema de Multiprocesador NUMA (Non Uniform Memory Access) ........................................... 21

1.7.4 Sistema COMA (Cache Only Memory Access) ............................................................................... 21

1.7.5 Multicomputadoras .......................................................................................................................... 22

2.1. La conjetura de Minsky ...................................................................................................................25

2.2. Ley De Amdahl.................................................................................................................................26

2.3. Granularidad....................................................................................................................................29

2.3.1 Paralelismo de grano fino................................................................................................................. 30

2.3.2 El paralelismo de grano medio......................................................................................................... 30

2.3.3 Paralelismo de grano grueso y muy grueso ..................................................................................... 30

2.3.4 Paralelismo independiente .............................................................................................................. 30

2.4. Redes específicas ..............................................................................................................................34

2.4.1 Red Crossbar .................................................................................................................................... 34

2.4.2 Memorias Multipuerto ..................................................................................................................... 35

2.5 Estrategias de software de los MIMD. .............................................................................................37

2.5.1 Técnicas de compilación................................................................................................................... 37

17

2.5.2 Arquitecturas paralelas de granularidad fina................................................................................. 42

2.5.3 Estrategia Doacross scheduling........................................................................................................ 43

2.5.4 Estrategia Doall loop scheduling...................................................................................................... 44

2.5.5 Estrategia de balance de carga......................................................................................................... 44

2.5.6 MPI (Messaging passing interface) Intercambio de paso deMensajes .......................................... 45

2.5.7 PVM(Paralell Virtual Machine) Maquina Virtual Paralela........................................................... 49

2.6 El estudio del rendimiento. ...............................................................................................................53

2.6.1 Factores que influyen en el rendimiento.......................................................................................... 53

2.6.2 Tiempo de respuesta (Turnaround Time) ....................................................................................... 54

2.7 Algoritmos paralelos. ........................................................................................................................56

2.7.1 Método De Diferencias Finitas......................................................................................................... 56

2.7.2 Método de expansión de Taylor ....................................................................................................... 57

2.7.3 Aproximación De Diferencia Para Derivadas Parciales. ................................................................ 60

3.1 Pensamiento y la filosofía de construcción......................................................................................61

3.2 Aspectos generales de la programación en paralelo........................................................................63

3.2.1 Tipo de Hardware ........................................................................................................................... 63

3.2.2 Tipo de red de Comunicación .......................................................................................................... 67

3.2.3 El sistema operativo. ........................................................................................................................ 68

3.3 Elección de componentes para la construcción de la maquina paralela........................................70

3.3.1 Tipo de carga del sistema operativo para la máquina paralela. ..................................................... 71

3.3.2. Aplicaciones y Programas. .............................................................................................................. 72 3.3.2.1 Servicios requeridos ...........................................................................................................................................72

3.3.2.1.1 El servidor RPL. .........................................................................................................................................72 3.3.2.1.2 El servidor DHCP (dynamic host configuration protocol). ........................................................................73 3.3.2.1.3 El servidor TFTP (trivial ftp). ....................................................................................................................74 3.3.2.1.4 El servidor NFS..........................................................................................................................................74 3.3.2.1.5 El servidor RSH..........................................................................................................................................75

3.4 Proceso de construcción ...................................................................................................................75

3.4.1 Construcción física ........................................................................................................................... 75

3.4.2 Construcción Lógica......................................................................................................................... 80

3.4.3 Instalación del nodo principal.......................................................................................................... 82

3.4.4 Diseño e implementación de la máquina paralela ........................................................................... 86 3.4.4.1 Intercambio de mensajes ...................................................................................................................................89 3.4.4.2 Sincronización....................................................................................................................................................89

3.4.5 Experimentos y optimización. ...................................................................................................... 96 3.4.5.1 Performance de Red .........................................................................................................................................96 3.4.5.2 Transmisión de información (throughput) de MPICH .....................................................................................99 3.4.5.3 Benchmark Time ..............................................................................................................................................101

18

LISTA DE FIGURAS Y TABLAS DESCRIPCIÓN

Página

_________________________________________________________________

Figura 2.- Sistema SIMD. Fuente: Organización de computadoras Andrew S. Tanenbaum ............16

Figura 3.- Sistemas MISD Fuente: Organización de computadoras Andrew S. Tanenbaum............18

Figura 4.- Sistema MIMD Fuente: Organización de computadoras Andrew S. Tanenbaum. ...........19

Figura 5.- Sistemas UMA Fuente: Organización de computadoras Andrew S. Tanenbaum ............20

Figura 6.- Cluster Jerárquico Fuente: Organización de computadoras Andrew S. Tanenbaum.......21

Figura 7.- Sistema Coma. Fuente: Organización de computadoras Andrew S. Tanenbaum.............22

Figura 8.- Ejemplo de incremento de velocidad obtenido con la ley de Amdahl usando varios procesadores ............................................................................................................................................28

Figura 9.- Gráfico generado con Upshot donde expresa el nivel de computación, de comunicación y en espera para 8 procesadores................................................................................................................29

Figura 10.- La interconexión de red usando memoria de puertas múltiples . .....................................32

Figura 11.- Sistema de memoria compartida con un elemento de proceso con memoria local ..........32

Figura 12.- Esquema de un módulo de procesamiento.........................................................................33

Figura 13.- Interconexión a través de un bus común. ..........................................................................34

Figura 14.- Red Crossbar .......................................................................................................................34

Figura 15.- Comunicación entre procesadores usando una memoria de 4 puertos ............................35

Figura 16.- Red multietapa....................................................................................................................35

Figura 17.- Red Multietapa estrictamente no bloqueante.....................................................................36

Figura 18.- Red Multietapa estrictamente no bloqueante reconfigurable. ..........................................37

Figura 19.- Grafo de dependencia. Los arcos están rotulados con (Tk,Ck) ........................................40

Figura 20.- Arquitectura de Multiprocesador de memoria compartida. ..............................................43

Figura 21.- Comunicaciones en PVM. ..................................................................................................51

Figura 22.- Ejemplo del Proceso de Carga Remota ..............................................................................72

Figura 23.- Esquema de Hardware de un beowulf. ..............................................................................76

Figura 24.- Diagrama a bloques de un cluster tipo beowulf.................................................................76

Figura 25.- El nodo Integral. .................................................................................................................78

Figura 26.- Esquema principal de la máquina paralela propuesta. .....................................................79

Figura 27.- El modelo en hardware propuesto final de la máquina paralela......................................80

Figura 28.- Diagrama de flujo de la carga de los nodos integrales en el sistema operativo (parte 1)..................................................................................................................................................................84

Figura 29.- Diagrama de flujo de la carga de los nodos integrales en el sistema operativo (parte 2)...................................................................................................................................................................85

Figura 30.- Se muestra hasta el momento de como se establece la comunicación de los procesos en

19

la máquina paralela simulando un broadcast. ......................................................................................94

Figura 31.- Throughput para tamaño de sockets por default sobre TCP , donde (F)ast, (E)thernet, (B)onding, M(PICH), (G)igabit. ...........................................................................................................98

Figura 32.- Gráfico de saturación..........................................................................................................99

Figura 33.- Gráfico de firma ethernet..................................................................................................100

Figura 34.- Se muestra el tiempo de ejecución de los comandos de lectura rm -f, du -sk, ls -R, grep -r y find -name...........................................................................................................................................102

20

LISTA DE TABLAS

DESCRIPCIÓN Página

__________________________________________________________________ Tabla 1. Procesos y granularidad de la sincronización .......................................................................................................29

Tabla 2. - Muestra la relación entre la granularidad del algoritmo.......................................................................................31

Tabla 3. - Cadena para el ciclo representado. ........................................................................................................................40

Tabla 4. Segundo ciclo. ..........................................................................................................................................................41

Tabla 5. Tercer Ciclo..............................................................................................................................................................41

Tabla 7 .Relación entre factores de rendimiento y atributos del sistema................................................................................56

Tabla I. Argumentos de funciones MPI. ..................................................................................................................................VI

Tabla II. Correspondencia entre tipos de datos en MPI, Fortran y C. ..................................................................................VII

1

INTRODUCCIÓN

Las súpercomputadoras son máquinas de gran tamaño físico que tienen la capacidad de

realizar millones de operaciones por segundo, pero al igual que cualquier computadora, está limitada a hacer lo que se le ordene. Las órdenes que les damos a las computadoras son los programas. Los programas tradicionalmente le ordenan a la computadora que realice una secuencia de operaciones en un orden determinado, y no puede realizar una operación hasta haber terminado la anterior. Ejecutar un programa escrito con un enfoque tradicional en una súper computadora es un desperdicio, ya que un sólo programa no puede aprovechar la existencia de múltiples procesadores. Esto se debe a que la mayoría de los programas se desarrollan pensando que serán ejecutados en una computadora personal con un sólo procesador, tradicionalmente la secuencialidad de los programas y la estructura básica de los lenguajes de programación.

Para aprovechar las capacidades multiprocesador de las supercomputadoras, es necesario dividir las tareas en bloques que puedan ser ejecutados simultáneamente. Esto es conocido como programación de multihilos(multithreads). Los hilos van a realizar distintas tareas necesarias en un programa. Por ejemplo una parte del programa (hilo) puede dedicarse a producir algún objeto y otra parte del programa puede dedicarse a consumir esos objetos. Para hacer que los programas funcionen de esta manera, se utilizan distintas técnicas que le indican a las máquinas cuales son las partes del programa que pueden ejecutarse simultáneamente.

Para que exista la comunicación entre procesos por medio de paso de mensajes, existe un

estándar llamado MPI (Message Passing Interface). Existen diferentes implementaciones de MPI, como por ejemplo MPICH, que es una implementación abierta de MPI. MPI permite la paralelización de programas tanto para máquinas con múltiples procesadores como para clusters. Las aplicaciones desarrolladas utilizando MPI pueden ser transportadas de una máquina paralela a un cluster sin que MPI cause algún tipo de conflicto.

El súper cómputo tiene múltiples aplicaciones de carácter puramente científico, otras en la industria del entretenimiento, en el gobierno, y también dentro de las empresas. La computadora más poderosa del mundo es la BlueGene de IBM1 actualmente es utilizada para realizar análisis molecular, modelado económico, investigaciones en química y genética. Esta máquina se encuentra en Estados unidos y puede alcanzar un desempeño de hasta 183.5 TFLOPS.

Una de las industrias que ha acercado más al súpercómputo al público en general, es la industria de los efectos especiales. Como un ejemplo, Pixar studios que utiliza computadoras Silicon Graphics y Sun para la realización de sus excelentes animaciones. A últimas fechas, Pixar también ha estado utilizando clusters Linux para el desarrollo de sus animaciones.

Sin embargo la capacidad que da el súper cómputo es aplicado también a áreas como la medicina, la física, la química y muchísimas especialidades más.

Con el fin de dar respuesta al propósito institucional antes mencionado y apoyar a la investigación en el IPN por medio de la oferta de una infraestructura de cómputo de alto rendimiento, surgió Marc1 (Máquina de esfuerzo final hecha en cluster), de este proyecto se genera esta tesis de titulación de la

1 Fuente: www.top500.org, lista de junio del 2005.

2

maestría en Informática de UPIICSA bajo el nombre de "Construcción de una máquina paralela para centros de investigación " y es respaldada por el CIDETEC bajo el proyecto "Construcción de una computadora paralela del TIPO cc-numa", proyecto que en la actualidad esta trabajando sin problemas y dando servicio a investigadores del instituto.

Ahí se desarrollo un prototipo de una máquina paralela del tipo “cluster” con las siguientes

características:

- 8 nodos de cómputo interconectados por enlaces de 1000 Mb/s - 2 procesadores Pentium III operando a 1.2 GHz en cada nodo - 256 MB de RAM y disco duro de 80 GB por nodo - Sistema operativo LINUX (Mandrake 10.1 rc2) - Servicios de servidor http, ftp y telnet, accesibles por Internet

Adicionalmente, se revisa y en su caso se desarrollan los programas necesarios para su funcionamiento y administración así como se adapta a los lenguajes de programación de “facto” para el área. Así entonces, esta tesis de grado busca el siguiente objetivo: a) Diseñar y construir una máquina de procesamiento paralelo utilizando material de cómputo en desuso, o viejo, en buenas condiciones.

Para facilitar el logro de este objetivo general, se establecen metas parciales, desagregadas en tres objetivos específicos. 1.- Diseñar y construir un prototipo de una máquina paralela tipo cluster. 2.- Establecer y afinar la máquina paralela para su óptimo rendimiento. 3.- Adaptar el prototipo para que responda a los estándares de programación y que busque ser compatible a otros sistemas.

El presente documento es la memoria de los trabajos desarrollados en cumplimiento de los objetivos señalados; en esta INTRODUCCIÓN, se da la información general del proyecto.

En el capítulo ANTECEDENTES GENERALES, se delimita el marco de referencia en el que se desarrolla este trabajo partiendo de la situación actual, así como el entorno que tienen que presentar los investigadores y las alternativas que toman.

En el capítulo PRINCIPIOS DE PROCESAMIENTO PARALELO, se delimita el marco teórico en el cual se basa el presente trabajo y bajo el cual se establecen las reglas para el diseño y la construcción, así como hago referencia a los procesos, características y entorno en los cuales son válidas esas condiciones teóricas y son clasificadas desde lo más general a lo más particular.

En el capítulo CONSTRUCCIÓN DE LA MÁQUINA PARALELA, que es el que

3

contiene la descripción detallada del trabajo técnico y de desarrollo tecnológico, se contemplan cuatro partes:

• Filosofía de Construcción, incluye que es lo que se quiere llegar a hacer y por que debe de

construirse. • Aspectos de Hardware, que comprende todo lo relacionado al diseño de los elementos que

permitirán la construcción y el alto desempeño. • Aspectos del Software, comprenden la elección correcta del sistema operativo, los programas y

servicios que deberá de tener la máquina para responder con alto desempeño. • Procesos de ensamble, incluyen los comentarios propios del diseño, así como el desarrollo,

ensamble, problemas y pruebas realizadas a la máquina paralela Al final se integran las CONCLUSIONES Y RECOMENDACIONES. Adicionalmente, incluye también un GLOSARIO DE TÉRMINOS y la BIBLIOGRAFÍA utilizada en el trabajo junto con un apartado de ANEXOS que incluye algunos datos técnicos referentes a los tipos de conexión y aspectos básicos de las pruebas y de programación.

4

CAPÍTULO 1. ANTECEDENTES GENERALES

En México, la educación en general y la investigación se encuentran definidas en sus características

por la dinámica de la estructura socioeconómica de nuestro país en la que se insertan tales actividades. De esta forma se asigna a la investigación los recursos económicos sobre la base de un presupuesto fijo. Los subejercicios en el gasto público y los recortes a los presupuestos federales dañan a organismos como el Instituto Politécnico Nacional, que carecen del margen de maniobra que tienen las universidades autónomas y que dependen de las políticas del gobierno federal.

Por otro lado, la interrelación que existe entre educación e investigación es esencial para la

comprensión de la práctica de la investigación. La evolución de los distintos paradigmas que alumbran el camino de la investigación en las diferentes ramas de la ciencia constituye, desde luego, otro referente vital en la comprensión de los logros y obstáculos que cada ciencia particular enfrenta en su desarrollo, así como atender a las características del individuo cuyas capacidades se construyen histórica y genéticamente. Estas características actúan a su vez en la práctica de la investigación impulsándola o frenando su desarrollo. Es decir, para una comprensión cabal de la práctica de investigación es necesario engarzar dialécticamente los procesos macro y micro que la determinan.

La comprensión cabal de la actividad de investigación que requiere desde luego incorporar el planteamiento general arriba señalado y extraer en cada situación histórica la interrelación con otros ámbitos como el político, el cultural y el económico. El discernimiento de las interrelaciones complejas que históricamente se van construyendo entre los diferentes ámbitos y factores mencionados constituye un ejercicio de difícil ejecución, necesario sin embargo para entender la dinámica de la actividad de investigación en nuestro país. El acercamiento a este conocimiento integral permitirá entender las particularidades de la investigación en el ámbito urbano y regional.

A partir de esta conceptualización se desarrollan las siguientes reflexiones, cuyo objetivo terminal es la comprensión de los problemas y exigencias que se presentan en el proceso de investigación de la problemática arquitectónica, urbana y regional.

En México la preocupación central de obtener el desarrollo económico y la industrialización que en general ha caracterizado las diferentes estrategias de desarrollo implementadas desde la instauración del grupo hegemónico, surgido de la revolución, en el poder, no ha traído, como ocurrió en los orígenes de la industrialización, un desarrollo acelerado de la ciencia. Este aspecto es determinado por las condiciones estructurales de dependencia y subdesarrollo en que se mueve nuestro país, situación aún prevaleciente pese a los reiterados discursos que nos tratan de ubicar como un país desarrollado.

Tal situación estructural se ha traducido en el ámbito científico y técnico en un proceso permanente de transferencia, generalmente mecánica, de los adelantos técnicos y científicos logrados en otros países y que la industrialización de nuestro país requiere para su fortalecimiento. Las consecuencias de esta transferencia, tradicionalmente denunciadas por académicos e investigadores desde diversas disciplinas y enfoques, han sido puntualizadas actualmente a la luz de la perspectiva del desarrollo sustentable.

La corriente de pensamiento del desarrollo sustentable incorpora una nueva concepción del

desarrollo basada en tres planteamientos centrales: que se oriente a la satisfacción de las necesidades

5

sociales, empezando por la eliminación de la miseria; que sea autógeno e independiente, esto es, basado en las propias fuerzas de la sociedad que lo emprende, y que esté en armonía con el medio ambiente. Esta corriente ha construido sus planteamientos a partir de una crítica permanente a las consecuencias de la transferencia tecnológica derivadas de una concepción de desarrollo tradicional, basado en la maximización de las ganancias y el excedente económico. Son recurrentes los señalamientos en torno a la expoliación de nuestros recursos, el deterioro del medio ambiente, la crisis de energéticos y alimentos, la destrucción de la cultura local de las comunidades, etc.

La aplicación de tecnología que bajo esta concepción tradicional de desarrollo se efectúa en nuestro país, tiene pautas que van desde la transferencia de los rezagos tecnológicos que, por ejemplo, en el campo han tenido resultados atroces para la agricultura, suelos, agua y aire, con la utilización de sustancias y métodos de fumigación ya desechados en los países que los exportan, hasta la utilización de ciertas técnicas por parte del Estado mismo en la implementación de sus planes globales. La aplicación de técnicas inadecuadas para resolver cualquier tipo de problemática en nuestro país llega incluso a la transferencia de los técnicos mismos, como puede constatarse actualmente en la elaboración de planes y programas de desarrollo.

El patrón de distribución de la inversión pública federal se mantiene sin alteraciones fundamentales para años más recientes. En este caso se encuentra especificada la asignación al sector educativo que recibe en general montos mucho menores que los destinados a los dos sectores priorizados: industria y comunicaciones y transportes. Destacan ligeros incrementos en dos momentos, el primero al iniciar su administración Echeverría Álvarez, y el otro a inicios del sexenio de López Portillo.

La atención a la ciencia, la educación y el arte queda por lo tanto relegada en la medida en que no impactan de inmediato el proceso de desarrollo que, a juicio de sus dirigentes, requiere el país. Esta situación se ha agravado con el recorte del presupuesto en materia social que la implementación del modelo neoliberal ha establecido como base para salir de la crisis.

La escasez de recursos tanto en el ámbito científico como en la educación en general alimenta la existencia de condiciones precarias que se combinan con el escaso desarrollo alcanzado en ambos campos, configurando al parecer un círculo vicioso de precariedad. La estructura educativa en general se orienta a la formación de individuos capacitados técnicamente para incorporarse a las actividades productivas, en cualquiera de sus niveles, por lo que prevalece la debilidad o franca ausencia de espacios para la adquisición de conocimientos acerca del proceso de la investigación. Los resultados: un nulo o precario conocimiento teórico y metodológico tanto de parte de los egresados del nivel de licenciatura de las diversas disciplinas como de los propios profesores. La abundancia de trabajos que difícilmente podrían considerarse tesis, es una muestra de las deficiencias señaladas.

El descuido de la investigación como función relevante de la educación, en México se explica

además por las propias características de la actividad que requiere para su realización de una preparación que sólo se adquiere a través de largos procesos de formación teórica y de práctica de la investigación; además de otras cualidades más escasas aún como son la imaginación, la creatividad, la disciplina, la perseverancia.

En tales condiciones la investigación que se realiza en nuestro país, por los pocos individuos

comprometidos en una actividad de poca redistribución económica, presenta como rasgos endémicos: la

6

dispersión, el individualismo y la factura artesanal. Tales rasgos no se presentan desde luego de la misma manera y con la misma intensidad.

La parcelación de la ciencia actúa en ello en razón de dos factores: El primero, recurrentemente señalado, es la forma cerrada de pensamiento que nos ha heredado la división de la ciencia en estancos del conocimiento. Sin dejar de reconocer el papel de este fenómeno en un momento histórico en la aceleración del desarrollo científico, podemos afirmar que actualmente sólo reproduce la fragmentación y el aislamiento en que se mueven los investigadores.

Un segundo factor, derivado del primero, es la situación que guardan las ciencias sociales respecto a las naturales. Ambas se encuentran en la actualidad inmersa en un proceso de diversificación que resulta de mayor magnitud en las ciencias sociales, y que se expresa en la generación de subdivisiones menores con estructura y desarrollo diferentes. El desarrollo y características peculiares de cada disciplina científica marcan también a la investigación, de tal forma que en algunas los rasgos anotados son más acentuados que en otras.

1.1 Antecedentes Teóricos Básicos

En el mercado de las empresas mundiales, existen grandes monopolios de software

propietario los cuales cobran derechos de uso por una cantidad monetaria que en algunos casos es fija y se denomina licenciamiento” [ 2 ], esta práctica es muy utilizada actualmente en programas comerciales, tales como una hoja de cálculo, hasta programas de administración de recursos empresariales (ERP, por sus siglas en ingles).

La ley de Copyright (Derechos de autor), concede a los productores de software el poder para elegir las reglas que se impondrán sobre su producto a todos los demás consumidores, cómo utilizarlo, con qué recursos, bajo que condiciones e inclusive bajo que fallas deberá de trabajar éste, esté o no de acuerdo. La bandera de la globalización y la alta tecnología han impuesto modas que distan de ser las más productivas y las mejores opciones que permitan explotar la tecnología de la información.

Cuando los usuarios de los programas carecen de las libertades que definen al Software, este no podrá saber qué está haciendo, no pueden comprobar si hay puertas traseras, no pueden vigilar si sé está expuesto a posibles virus y gusanos, no se puede saber qué información personal está siendo manipulada. Y si este software está mal, no se podrá reparar y se tendrá que esperar a que el productor ejerza su poder para hacerlo.

Las discusiones sobre derechos y reglas para el software a menudo se han concentrado solamente en los intereses de los programadores, si consideramos que pocas personas en el mundo programan comercialmente y aún menos los que son dueños de empresas de software propietario. Y si consideramos que el mundo actual necesita utilizar software, entonces los productores de software controlan el modo en que el mundo trabaja, hace negocios, se comunica y se entretiene.

Afortunadamente existen varias asociaciones mundiales que permiten que un usuario decida qué hacer con el software que se utiliza, un ejemplo de esto es el GNU. Este proyecto ha desarrollado un sistema completo de software libre llamado GNU (GNU Not Unix) que es compatible con Unix (surge con relación a un documento inicial de Richard Stallman al cuál se le llama

2 Esta práctica es muy común en el mundo del software propietario.

7

Manifiesto GNU), y ha sido traducido a otros idiomas. Se escogió como nombre "GNU" porque cumplía algunos requisitos; primero, era un acrónimo recursivo de "GNU No es Unix"; segundo, ya existía esa palabra en inglés donde Gnu significa Ñu, y tercero, porque era divertido decirla (o cantarla).

Otra asociacion mundial es GPL(), cuya política principal es él darle al usuario el control del uso del software, al tiempo que lo protege de otros que quisieran controlar sus decisiones y manipular sus acciones.

La palabra free "libre" se refiere a libertad de elección y no a su precio, en inglés se usa

la misma palabra para libre y gratuito sin embargo no son la misma cosa, de manera que es posible pagar o no, un precio por obtener software GNU pero la diferencia radica en que una vez que se obtiene el software, se podrán ejercer tres libertades específicas para usarlo: a) Se tendrá la libertad de copiar el programa y distribuirlo. b) Se tendrá la libertad de modificar el programa como se desee, por tener acceso completo al código fuente y librerías c) Se tendrá la libertad de distribuir una versión mejorada ayudando así a construir la comunidad.

Este proyecto fue concebido en 1983 como una forma de devolver el espíritu cooperativo que prevalecía en la comunidad computacional en días pasados, al eliminar los obstáculos impuestos por los dueños de software propietario.

En 1971, cuando Richard Stallman[ 3 ] comenzó su carrera en el MIT (Instituto de Tecnología de Massachusetts), trabajó en un grupo que usaba software libre exclusivamente. Incluso compañías informáticas frecuentemente distribuían software libre. Los programadores eran libres de cooperar unos con otros, y frecuentemente lo hacían. En los 80, casi todo el software era propietario, lo cual significa que tenía dueños que prohibían e impedían la cooperación entre usuarios y surgieron grandes monopolios.

Cada usuario de computadoras necesita para que su computadora funcione de un sistema

operativo; si no existe éste entonces no es posible ni siquiera comenzar a usar una computadora sin recurrir a un software propietario. Así que el primer elemento en la agenda del software libre es un sistema operativo libre. Un sistema operativo no es sólo opcionalmente el núcleo; si no que también incluye compiladores, editores de texto, software de correo y muchas otras cosas. Por todo esto, escribir un sistema operativo completo es un trabajo bastante grande. Se necesitaron muchos años. Se decidió hacer el sistema operativo compatible con UNIX porque el diseño en general ya estaba probado y era portable, y porque la compatibilidad hacía fácil para los usuarios de UNIX cambiar de UNIX a GNU.

El objetivo inicial de buscar un sistema operativo libre parecido al UNIX fue alcanzado

para el inicio de los 90s y se tenían los componentes principales completos, excepto uno: el núcleo. Linux surgió entonces como un núcleo libre, desarrollado por Linus Torvalds. La combinación de Linux con el ya casi completo sistema GNU permitió un sistema operativo completo, actualmente se estima que hay cientos de miles de personas que ahora usan proyectos GNU basados en Linux, incluyendo Slackware, Debian, Red Hat y otros.

3Richard Matthew Stallman: nació el 16/marzo/1953 y es la figura central del movimiento del software libre, fundador del proyecto GNU y la fundación para el software libre. Inventor del concepto copyleft y precursor de la licencia GLP de GNU (General Public License).

8

Sin embargo, el proyecto GNU no se limita a sistemas operativos ya que se aplicó también a todo el amplio espectro de software incluyendo el software de aplicación, también proporciona software para usuarios que no son expertos en computadoras, además de ofrecer juegos y otras recreaciones.

¿Hasta dónde puede llegar el software libre? No hay límites, excepto cuando las leyes como el sistema de patentes prohíben el software libre completamente. El objetivo final es el de proporcionar software libre para hacer todos los trabajos que los usuarios de computadoras quieran hacer y por lo tanto hacer el software propietario obsoleto. 1.2 Posix (Portable Operating System Interface)

Posix está formado por un conjunto de interfaces estándar de sistema operativo basadas

en el sistema operativo UNIX y desarrolladas bajo la supervisión de la IEEE. [4]. La necesidad de tener un estándar en común es muy importante ya que las compañías que usaban computadoras querían ser capaces de desarrollar programas que pudieran ser transportados entre diferentes sistemas de cómputo de varias manufacturas o plataformas, sin tener que volver a reprogramar. UNIX fue seleccionado como la base para un sistema de una Interfase estándar en parte porque era neutral en cuanto a la manufactura y era necesario desarrollar un sistema de común denominador.

Esto hace posible que al aprender un sistema operativo UNIX [5], cualquiera que este sea,

permitirá utilizar cualquier otro sistema UNIX distinto, sin muchos problemas y únicamente se deberá de aprender las particularidades.

La estructura del estándar de POSIX está definida por la palabra POSIX y un decimal a continuación del nombre, a continuación se muestran los más importantes: • POSIX.1 es el estándar para una Interfase de programa de aplicación en el lenguaje C. • POSIX.2 es el shell estándar y Interfase de utilidades (es decir, la Interfase de comandos del usuario

con el SO). • POSIX.3 es el estándar para la Interfase de PERL apegada a la norma IEEE 1003.1 • POSIX.4 para la administración de hilos (threads).

Recientemente, las interfaces POSIX.1 y POSIX.2 fueron incluidas dentro de una Interfase aún más grande conocida como X/Open Programming Guide 4.2, también conocida como la especificación UNIX Simple (Single UNIX Specification" y "UNIX 95").

El grupo de estándares abiertos, llamado en ingles “Open Group”, un grupo para

4 El IEEE (Institute of Electrical and Electronics Engineers), es una organización profesional técnica sin ánimo de lucro que incluye a más de 377,000 socios en 150 países. A través de sus socios el IEEE se ha convertido en una autoridad en varias áreas técnicas, desde ingeniería en informática hasta ingeniería en telecomunicaciones, pasando por otras como ingeniería biomédica o ingeniería eléctrica. Fuente http://www.ieee.org/. 5 Unix fue creado en los Laboratorios Bell de AT&T a comienzos de la década de 1970, el éxito del sistema operativo Unix ha dado lugar a una gran cantidad de versiones diferentes: los que recibieron el (en ese tiempo gratis) código del sistema Unix. Actualmente Unix® es marca registrada de X/Open.

9

estándares industriales y es el propietario de la marca registrada UNIX y puede por lo tanto, registrar sistemas operativos que formen parte o complementen mejoras a la Interfase de su sistema. El IBM OS/390 es un ejemplo de un sistema operativo que incluye una Interfase UNIX registrada. 1.3 El Sistema Operativo Linux

Linux es una versión de UNIX libremente distribuible e independiente, para plataformas

con máquinas x86, Motorola 68k, Digital Alpha, Sparc, Mips y Motorola Power PC. En la actualidad, este sistema operativo es utilizado por miles de usuarios para desarrollo de software, redes y para plataformas de usuarios finales. Entre los muchos sistemas operativos alternos que existen, se ha convertido en una opción interesante, independientemente de que estas vengan de UNIX o de las más conocidas donde se encuentra Windows y NT.

Linux es una implantación de la especificación POSIX con la cual cumplen todas las verdaderas versiones de UNIX, el núcleo de Linux no usa código de AT&T o de cualquier otra fuente propietaria, la mayoría de los programas disponibles para Linux es desarrollado por el proyecto GNU de la Free Software Foundation. Este soporta un amplio espectro de aplicaciones o paquetes de programación tales como X Window, Emacs, redes de datos bajo protocolos TCP/IP (incluyendo SLIP, PPP, ISDN), está disponible en Internet en cientos de servidores FTP y el núcleo del Linux está legalmente protegido por la licencia pública GNU (GPL).

Linux incluye compiladores, ensambladores, editores de texto, paquetes de correo electrónico, lectores de Noticias, navegadores, servidores y programas para la creación y edición gráfica, además maneja los archivos de forma jerárquica, de la misma forma que el sistema operativo DOS, con la diferencia que el DOS está diseñado para procesadores x86.

Linux fue creado originalmente por Linus Benedict Torvalds [6] en la Universidad de

Helsinki en Finlandia, sin embargo Linux ha sido desarrollado con la ayuda de muchos programadores a través de Internet, originalmente inició la creación del núcleo como su proyecto favorito, inspirado por su interés en MINIX, un pequeño sistema UNIX. El se propuso a crear lo que en sus propias palabras seria un mejor Minix que el Minix. El 5 de octubre de 1991, Linus anunció su primera versión "oficial" de Linux, la versión 0.02. Desde entonces, muchos programadores han respondido a su llamado, y han ayudado a construir Linux como el sistema operativo completamente funcional que es hoy.

La última versión estable es la versión 2.2, que soporta muchos más periféricos, desde procesadores hasta joysticks, sintonizadores de televisión y reconoce buena cantidad de tarjetas de sonido. Incluye también soporte para tipos de archivos para Macintosh HFS, UNIX UFS y en modo de lectura, HPFS de OS/2 y NTFS, de NT. Linux como producto final presenta las siguientes ventajas [7]:

6 Torvalds consideró el crear un sistema operativo para usarlo en forma alterna en su computadora. Cuando él terminó su sistema, colocó un mensaje en la Internet para alertar a otros usuarios del nuevo sistema. El creo un software libre para que otros pudieran modificarlo este se llamo Linux. 7 Fuente: Linux Kernel 2.6: the Future of Embedded Computing, Aseem R. Deshpande, Linux journal 23 mayo de 2004

10

• Precio bajo en distribución completa de venta (aproximadamente 100 Dólares Americanos) o gratis por medio de Internet.

• Estabilidad • Seguridad, es mucho más segura que otros servidores comerciales. • Compatibilidad, reconoce la mayoría de los otros sistemas operativos en una red. • Velocidad, es mucho más veloz para realizar las tareas. • Posee el apoyo de miles de programadores en el ámbito Mundial. • El paquete incluye el código fuente, lo que permite modificarlo de acuerdo a las necesidades del

usuario. • Ideal para la programación, ya que se puede programar en Linux para distintas plataformas, como

para Windows. • Un sistema escalable. • Se puede usar en casi cualquier computadora, desde una computadora con tarjeta madre 386. • Multitareas real. • Puede manejar múltiples procesadores. Incluso hasta 16 procesadores. • Maneja discos duros de hasta 16 TeraBytes. • Los fabricantes de Hardware le están dando su apoyo, como IBM y COMPAQ. • Vendedores y desarrolladores implementan un sistema de certificación para Linux. Sin embargo cuenta también con las siguientes desventajas: • Linux no cuenta con una empresa que lo respalde, por lo que no existe un verdadero soporte como

el de otros sistemas operativos. • Linux corre el riesgo de llegar a fragmentarse como fue el caso de UNIX. Linux cuenta con las siguientes características técnicas • Multitarea[8]:permite que varios programas o en su caso procesos reales puedan ejecutarse al

mismo tiempo. • Multiusuario: permite que varios usuarios estén utilizando la misma máquina al mismo tiempo. • Multiplataforma: corre en muchas CPU’s distintas tal es el caso de Intel, Mac y Alpha. • Bajo la plataforma Intel trabaja en modo protegido 386 [9]. • Tiene protección de la memoria entre procesos, de manera que uno de ellos no pueda colgar el

sistema. • Permite la carga de ejecutables por demanda: La lectura del disco es sólo de aquellas partes de un

programa que están siendo usadas actualmente. • Permite la política de copia en escritura que permite compartir las páginas entre ejecutables: Varios

procesos pueden usar la misma zona de memoria para ejecutarse y cuando alguno intenta escribir en esa memoria, la página (4Kb de memoria) se copia a otro lugar. Este método tiene dos beneficios: aumenta la velocidad y reduce el uso de memoria.

• Permite la memoria virtual usando paginación, lo cual involucra el no tener intercambio de procesos

8 Gracias a la multitarea, el rendimiento de las CPUs puede aumentar entre un 20 y un 25%. La multitarea tiene la misión de que la CPU realice varios trabajos simultáneamente vía hardware y no por simulación. 9 Dentro del modo protegido, el software puede realizar un cambio de tarea para entrar en tareas en modo 8086 virtual (V86 mode). Cada una de estas tareas se comporta como si fuera un 8086 el que lo está ejecutando, lo que permite ejecutar software de 8086 (un programa de aplicación o un sistema operativo).

11

completos a disco: una partición o un archivo en el sistema de archivos, o ambos, con la posibilidad de añadir más áreas de intercambio sobre la marcha.

• Un total de 16 zonas de intercambio de 128Mb de tamaño máximo pueden ser usadas en un momento dado con un límite teórico de 2Gb para intercambio.

• La memoria se administra como un recurso unificado para los Programas del usuario y para él caché de disco, de tal forma que toda la memoria libre puede ser usada para él caché y éste puede a su vez ser reducido cuando se ejecuten grandes programas.

• Utiliza las librerías compartidas de carga dinámica [10] y librerías estáticas. • Permite realizar los volcados del estado (core dumps) para posibilitar los análisis post-mortem,

permitiendo el uso de depuradores sobre los programas no sólo en ejecución sino también tras abortar éstos por cualquier motivo.

• Es casi totalmente compatible con POSIX, System V y BSD a nivel fuente. • Utiliza un módulo de emulación de iBCS2, casi completamente compatible con SCO, SVR3 y

SVR4 a nivel binario. • Permite la edición del código fuente, incluyendo el núcleo completo y todos los manejadores

(drivers), las herramientas de desarrollo y todos los programas de usuario; además todo ello se puede distribuir libremente.

Hay algunos programas comerciales que están siendo ofrecidos para Linux actualmente sin código

fuente pero todo lo que ha sido gratuito sigue siendo gratuito. 1.4 El Paradigma Cliente Servidor

Desde el punto de vista de una aplicación, el TCP/IP (Ver anexo A), al igual que muchos

otros protocolos de comunicación, implementa un mecanismo fiable para la transmisión de datos entre computadoras. En concreto, el protocolo TCP/IP permite que un programador pueda establecer comunicación de datos entre dos programas de aplicación, tanto si ambos se están ejecutando en la misma máquina, como en máquinas distintas unidas por algún camino físico (una red local, conexión telefónica directa entre computadoras, computadoras conectadas a Internet, etc.).

Hay que tener presente que el protocolo TCP/IP especifica los detalles y mecanismos para la transmisión de datos entre dos aplicaciones que se comunican pero no dictamina cuando ni por qué deben interactuar ambas aplicaciones, ni siquiera especifica como debería estar organizada una aplicación que se va a ejecutar en un entorno distribuido. Es tarea del diseñador de la aplicación distribuida el establecer un protocolo de comunicación y sincronización adecuado.

El esquema de programación más utilizado en la práctica para la implementación de aplicaciones distribuidas es el paradigma cliente - servidor. La motivación fundamental para el empleo del paradigma cliente - servidor surge cuando se presentan dos situaciones:

• Se hace referencia al mismo recurso y se presentan colisiones.

10 Un archivo DLL (sigla de Dynamic Link Library) es un pequeño programa que ejecuta alguna función. Estos archivos son muy útiles pero también suelen ser una causa de errores en Windows. Los archivos DLL ejecutan acciones o rutinas de uso frecuente en Windows, y un mismo archivo DLL puede ser usado por varios programas al mismo tiempo.

12

• Cuando se agotan los recursos físicos de un sistema.

Para entender dichos problema, imaginemos un programador de computadoras que inicia la ejecución de dos programas en máquinas distintas y que tiene la intención de que dichos programas se puedan comunicar entre sí. Una vez iniciado el primer programa; éste envía un mensaje. La conexión con la máquina a la cual va dirigido el mensaje se puede establecer en un intervalo de unos pocos milisegundos, por lo que el proceso recién enviado determina que su destino todavía no existe, con lo cual emite un mensaje de error y finaliza su ejecución. Mientras tanto, el programador inicia la ejecución del segundo proceso. Desafortunadamente, el segundo proceso no se puede comunicar con el primero ya que éste ha concluido su ejecución. Incluso si los dos procesos intentan establecer la comunicación continuamente éstos pueden ejecutarse tan rápidamente que la probabilidad de colisión es muy alta.

Muchos administradores hacen que ciertos programas de comunicaciones se inicien automáticamente cuando el sistema arranca, de este modo se aseguran que la computadora estará preparada para aceptar ciertas solicitudes de servicio. Después de iniciar su ejecución, cada uno de estos programas se queda en espera de la siguiente petición para el servicio que se espera dar. En el paradigma cliente - servidor se divide las aplicaciones en dos categorías, dependiendo de si la aplicación se queda en espera de conexiones o las inicia.

En general, una aplicación que inicia una comunicación con otra se le califica como cliente. Los usuarios finales invocan aplicaciones cliente cuando utilizan un servicio de red. Cada vez que se ejecuta una aplicación cliente, ésta contacta con el servidor, le envía una solicitud de servicio y espera la respuesta o resultados del servicio. El proceso cliente es el encargado de llevar a cabo la interacción con el usuario y de mostrar los resultados de las peticiones de servicio.

En la mayoría de las ocasiones los clientes son más fáciles de diseñar que los servidores, y

no suelen precisar privilegios especiales del sistema para poder funcionar. Un servidor es un programa que espera peticiones de servicio por parte de un cliente. El servidor recibe la petición del cliente, ejecuta el servicio solicitado y retorna los resultados al cliente. No existe una interacción directa entre el usuario y el servidor, de esto ya se encarga la aplicación cliente. 1.5 Direcciones IP

El concepto de números o direcciones IP se puede entender mejor si se establece una

analogía entre las computadoras y teléfonos. Del mismo modo que cada teléfono posee un único número a nivel mundial, cada computadora conectada directamente a la red Internet tendrá asignado un único número IP a nivel mundial. Por lo tanto, cualquier computadora del planeta puede conectar con cualquier otra computadora, siempre y cuando conozca su número IP y, además, exista un camino físico (formado en líneas telefónicas conmutadas, enlaces vía satélite, líneas de fibra óptica, etc.) que una a ambas computadoras para que puedan intercambiar información.

La comunicación entre computadoras se lleva a cabo mediante el intercambio de paquetes. La semántica de los conjuntos de bytes que recibe una computadora viene dictada por la aplicación a la cual van destinados. Los paquetes de información que se difunden a través de una red de computadoras son encaminados hacia un equipo o host concreto y dentro de dicho host a un puerto concreto.

13

Se puede pensar en un puerto como un canal de comunicación. Cada computadora dispone de un total de 65536 canales o puertos, los cuales pueden estar reservados o no estar activos. Para que un puerto esté activo es necesaria una aplicación que tome el control del mismo y sea capaz de administrar los paquetes de bytes que llegan por dicho puerto. Cuando un host recibe un paquete examina su cabecera o sección de información para averiguar a que puerto va destinado, si existe una aplicación escuchando dicho puerto, entonces se le pasan los bytes del paquete para que ésta los interprete y actúe consecuentemente. El host no responderá a peticiones de conexión encaminadas hacia un puerto para el cual no existe ninguna aplicación escuchando o esperando. Es decir, de los paquetes de bytes remitidos hacia una computadora en concreto, sólo se va a atender aquellos paquetes para los cuales existe una aplicación escuchando en el puerto al cual van encaminados.

Existe una serie de puertos estándares utilizados universalmente para varios servicios.

Algunos de ellos son:

Servicio Puerto Descripción FTP 21 Protocolo de transferencia de

archivos. Telnet 23 Permite el acceso a una cuenta en

un equipo remoto. SMTP 25 Para enviar correo electrónico. POP3 110 Protocolo para obtener correo

electrónico. HTTP 80 Protocolo para publicación

estándar en la Internet. NNTP 119 Grupos de noticias de Internet

GOPHER 70 Antiguo Servicio de acceso a información en modo texto.

Los programas de los servidores deben contener código que maneje situaciones de:

• Autenticación - Verificar la identidad del cliente. • Autorización - Determinar si un cliente dado posee permisos para acceder al servicio que

suministra. • Seguridad de datos - Garantizar que la información no es revelada, de manera no intencionada, a

clientes sin autorización. • Privacidad - Preservar la información de un usuario de accesos no autorizados. • Protección - Garantizar que las aplicaciones de red no puedan abusar de los recursos del sistema.

La distinción entre servicios estándares y no-estándares es importante únicamente cuando la comunicación se lleva más allá del entorno local. Dentro de un entorno dado, los administradores del sistema suelen definir los nombres de servicio de tal modo que el usuario final no puede distinguir entre servicios locales y servicios estándares. Los programadores que construyen aplicaciones en red que

14

serán empleadas por otros lugares repartidos a lo largo de todo el planeta deben entender en cuenta la distinción y tener cuidado para evitar la dependencia sobre servicios que están únicamente disponibles en el entorno local.

Aunque TCP/IP define muchos protocolos de aplicación estándares, la mayoría de los distribuidores de computadoras suministran solamente una parte de los programas cliente con su software TCP/IP. Muchas organizaciones diseñan aplicaciones personalizadas que emplean el protocolo TCP/IP para comunicarse entre sí. Las aplicaciones personalizadas no-estándares incluyen diversos servicios como puede ser la transmisión de imágenes y de vídeo para teleconferencia, transmisión de voz, todo tipo de servicios en línea, acceso a bases de datos distribuidas, control remoto de sistemas, etc.

Cuando los programadores diseñan software cliente - servidor, deben de escoger entre dos

tipos de interacción: orientada a conexión o no orientada a conexión. Si el cliente y el servidor utilizan UDP (User datagram Protocol), la iteración es sin conexión; por el contrario, si emplean TCP (Transfer Control Protocol), la iteración es orientada a conexión. Desde el punto de vista del programador de aplicaciones, la distinción entre el estilo sin conexión y orientado a conexión es crítica ya que determina el nivel de funcionalidad proporciona el sistema. TCP proporciona toda la funcionalidad necesaria para establecer una comunicación entre computadoras a través de Internet. Verifica que los datos lleguen al destinatario, y automáticamente retransmite paquetes que por cualquier motivo no llegan al destinatario o le llegan con errores. Comprueba la integridad de los datos para garantizar que no se corrompan durante su transmisión. Emplea secuencias de números para asegurar que los paquetes de datos llegan al destinatario en el orden correcto, los paquetes duplicados son eliminados automáticamente por el protocolo TCP. Proporciona un control de flujo para asegurar que el emisor no transmita datos más rápido de lo que pueden ser consumidos por el receptor. Finalmente, TCP informa tanto al cliente como al servidor si la red deja de estar operativa por algún motivo.

Por contraste, los clientes y servidores que emplean UDP no tienen garantías de que la información enviada a la red vaya a llegar realmente a su destinatario. Cuando un cliente envía una petición, esta puede perderse, ser duplicada, retardada o los paquetes de datos pueden llegar al destinatario fuera de orden. Del mismo modo, la respuesta del servidor puede perderse, duplicarse, retardarse o llegar desordenada. Los programas de aplicación cliente - servidor deben llevar a cabo las acciones oportunas para detectar y corregir tales situaciones de error.

Sin embargo, el empleo del protocolo UDP puede ser una alternativa interesante ya que permite un transporte de información más eficaz. UDP no introduce errores, únicamente se fundamenta en la red IP para transportar paquetes. Por el contrario, IP depende del hardware de red sobre el que se asienta y los gateways intermedios. Desde el punto de vista del programador, la consecuencia de emplear UDP es que este trabaja bien si la red sobre la que se asienta funciona bien. Por ejemplo, UDP funciona bien en un entorno local porque los posibles errores raramente se producen. Los errores se suelen producir cuando la comunicación se expande a una red de área extendida(WAN). Los programadores a veces cometen el error de elegir un protocolo sin conexión (UDP), construyendo una aplicación que hace uso del mismo, pero verificando el funcionamiento de la aplicación en una red de área local. Debido a que una red de área local raramente o nunca retrasa los paquetes, los pierde o los entrega fuera de orden, la aplicación da la sensación de que funciona correctamente. Sin embargo, si se hace una prueba en una red de área extensa, puede darse el caso de que el programa falle o genere resultados incorrectos.

Los principiantes, del mismo modo que los profesionales experimentados, prefieren emplear una comunicación orientada a conexión a la hora de diseñar sus aplicaciones de red. Un

15

protocolo orientado a conexión hace que la programación resulte más simple, y releva al programador de la responsabilidad de detectar y corregir errores de comunicación.

Por norma general, los programas de aplicación sólo utilizaran el UDP sí el protocolo de aplicación a implementar especifica que se debe de emplear el UDP (puede ser que el protocolo de aplicación haya sido diseñado para manejar errores que se puedan producir durante la comunicación).El protocolo de aplicación relega la seguridad de comunicación al hardware y no importa la pérdida de algunos paquetes de información. La aplicación no puede tolerar la sobrecarga (overhead) o retraso (delay) requerido por los circuitos virtuales TCP.

1.6 Taxonomía de arquitecturas

1.6.1 Clasificación de Flynn

Esta clasificación es clásica para definir la arquitectura de las computadoras con base en su flujo de instrucciones y datos. Flynn publicó su taxonomía por primera vez en 1966.

Se define como flujo de instrucciones al conjunto de instrucciones secuénciales que son ejecutadas por un único procesador y como flujo de datos al flujo secuencial de datos requeridos por el flujo de instrucciones. Con estas consideraciones, Flynn clasifica los sistemas en cuatro categorías:

1.6.2 Sistema único flujo de instrucciones sobre un único flujo de datos

SISD (Single Instruction stream, Single Data stream)

Los sistemas de SISD se caracterizan por tener un único flujo de instrucciones sobre un único flujo de datos, es decir, se ejecuta una instrucción detrás de otra. Este es el concepto de arquitectura serie de Von Neumann donde, en cualquier momento, sólo se ejecuta una única instrucción. Ver figura 1.

Figura 1.- Sistema SISD. Fuente: Organización de computadoras Andrew S. Tanenbaum

16

1.6.3 Sistemas SIMD (Single Instruction stream, Multiple Data stream)

Figura 2.- Sistema SIMD. Fuente: Organización de computadoras Andrew S. Tanenbaum

Los sistemas SIMD tienen un único flujo de instrucciones que operan sobre múltiples

flujos de datos. Ejemplos de estos sistemas los tenemos en las máquinas vectoriales con hardware escalar y vectorial (ver figura 2).

El procesamiento es síncrono, la ejecución de las instrucciones sigue siendo secuencial como en el caso anterior, todos los elementos realizan una misma instrucción pero sobre una gran cantidad de datos. Por este motivo existirá concurrencia de operación, es decir, esta clasificación es el origen de la máquina paralela.

El funcionamiento de este tipo de sistemas es el siguiente. La Unidad de Control manda una misma instrucción a todas las unidades de proceso (ALUs). Las unidades de proceso operan sobre datos diferentes pero con la misma instrucción recibida.

Existen dos alternativas distintas que aparecen después de realizarse esta clasificación:

• Arquitectura Vectorial con segmentación: Una CPU única particionada en unidades funcionales independientes trabajando sobre flujos de datos concretos.

• Arquitectura Matricial (matriz de procesadores): Varias ALU idénticas a las que el procesador de instrucciones asigna una única instrucción pero trabajando sobre diferentes partes del programa.

1.6.4 SIMD con CPU particionada

17

En los sistemas SIMD con CPU particionada, la CPU se diseña como un conjunto de unidades funcionales independientes que ejecutan simultáneamente varias operaciones aritmético/lógicas.

La CPU contiene un único procesador que procesa un único flujo de instrucciones liberando cada instante una. Debido a que las unidades funcionales operan independientemente, es posible liberar nuevas instrucciones antes de que finalice la ejecución de las instrucciones previas.

Ejemplos de este tipo de sistemas los encontramos en las computadoras CRAY monoprocesador, CYBER 205, FUJITSU, HITACHI, NEC SUPERCOMPUTERS, IBM 390 VF, IBM 9000 VF, ALLIANT FX/1 Y CONVEX C-1.

1.6.5 SIMD con múltiples ALU

En los sistemas SIMD con multiples ALU, es común en su funcionamiento utilizar el

modo bloqueado, donde es ejecutada o ignorada una misma instrucción para todas las ALU. Existe un único procesador que maneja el flujo de instrucciones del programa y que transfiere todas las instrucciones a las diferentes unidades aritmético/lógicas. Sus características principales son las siguientes:

• Cada ALU opera sobre un segmento diferente de datos del programa.

Ejemplo de funcionamiento del sistema con el siguiente bucle:

DO 2000 I=1,N A(I) = B(I) + C(I) 2000 CONTINUE

• El procesador asigna a cada ALU la operación de suma de B(I) con C(I) y siendo el almacenamiento

del resultado en A(I) pero pasando a cada ALU un valor diferente de I. En el caso de que haya menos ALU que iteraciones del bucle, el procesador ordenará la ejecución

hasta que estén procesados todos los valores de I.

En el caso de que haya más ALU que iteraciones, existirá un número de estas que no estén operativas durante la ejecución de las instrucciones del bucle. Una ALU inactiva o en OFF significa que: • La ALU recibe instrucciones pero las ignora • La ALU ejecuta cálculos pero no almacena ningún resultado.

18

1.6.6 Sistemas MISD (Multiple Instruction stream, Single Data stream).

Sistemas con múltiples instrucciones que operan sobre un único flujo de datos. Este tipo de sistemas no ha tenido implementación hasta hace poco tiempo. En la figura 3 se muestra este sistema. Figura 3.- Sistemas MISD Fuente: Organización de computadoras Andrew S. Tanenbaum Los sistemas MISD se contemplan de dos maneras distintas:

1. Varias instrucciones operando simultáneamente sobre un único dato.

2. Varias instrucciones operando sobre un dato que se va convirtiendo en un resultado que será la entrada para la siguiente etapa. Se trabaja de forma segmentada, todas las unidades de proceso pueden trabajar de forma concurrente.

Ejemplos de estos tipos de sistemas son los arreglos sistólicos o arreglos de procesadores.

También podemos encontrar aplicaciones de redes neuronales en máquinas masivamente paralelas.

1.6.7 Sistemas con un flujo de múltiples instrucciones que operan sobre múltiples datos MIMD (Multiple Instruction stream, Multiple Data stream)

Los sistemas con un flujo de múltiples instrucciones que operan sobre múltiples datos, empezaron a utilizarse a principios de los 80 y consiste en sistemas con memoria compartida que permiten ejecutar varios procesos simultáneamente (sistema multiprocesador).Ver figura 4.

Cuando las unidades de proceso reciben datos de una memoria no compartida estos

sistemas reciben el nombre de MULTIPLE SISD (MSISD). En arquitecturas con varias unidades de control (MISD Y MIMD), existe otro nivel superior con una unidad de control que se encarga de controlar todas las unidades de control del sistema.

19

Figura 4.- Sistema MIMD Fuente: Organización de computadoras Andrew S. Tanenbaum. 1.7 Categorías de Computadoras Paralelas

Clasificación moderna que hace alusión única y exclusivamente a los sistemas que tienen

más de un procesador (Por ejemplo las máquinas paralelas).

Existen dos tipos de sistemas teniendo en cuenta su acoplamiento. • Los sistemas fuertemente acoplados son aquellos en los que los procesadores dependen unos de

otros. • Los sistemas débilmente acoplados son aquellos en los que existe poca interacción entre los

diferentes procesadores que forman el sistema.

Atendiendo a esta y a otras características, la clasificación moderna divide a los sistemas en dos tipos:

• Sistemas multiprocesador (fuertemente acoplados) • Sistemas multicomputadora (débilmente acoplados).

1.7.1 Multiprocesadores

Un multiprocesador puede verse como una computadora paralela compuesta por varios

procesadores inter conectados que comparten un mismo sistema de memoria. Los sistemas multiprocesadores son arquitecturas MIMD con memoria compartida. Tienen un único espacio de direcciones para todos los procesadores y los mecanismos de comunicación se basan en el paso de mensajes desde el punto de vista del programador.

Dado que los multiprocesadores comparten diferentes módulos de memoria, pudiendo acceder a un mismo módulo varios procesadores, a los multiprocesadores también se les llama sistemas de memoria compartida. Dependiendo de la forma en que los procesadores comparten la memoria, se clasifican en sistemas multiprocesador UMA, NUMA y COMA.

20

1.7.2 UMA (Uniform Memory Access)

UMA se refiere como un sistema multiprocesador con acceso uniforme a la memoria. La

memoria física es uniformemente compartida por todos los procesadores, esto quiere decir que todos los procesadores tienen el mismo tiempo de acceso a todas las palabras de la memoria. Cada procesador tiene su propia caché privada y también se comparten los periféricos. Ver figura 5.

Figura 5.- Sistemas UMA Fuente: Organización de computadoras Andrew S. Tanenbaum

Los multiprocesadores son sistemas fuertemente acoplados (tightly-coupled), dado el alto grado en que se comparten los recursos (hardware o software) y el alto nivel de interacción entre procesadores, lo que hace que un procesador dependa de lo que hace otro.

El sistema de interconexión debe ser rápido y puede ser de uno de los siguientes tipos:

• Bus común • Red crossbar • Red multietapa

Este modelo es conveniente para aplicaciones de propósito general y de tiempo compartido por varios usuarios. Existen varias categorías de sistemas UMA de las cuales se mencionan las siguientes. • Sistema Simétrico: Cuando todos los procesadores tienen el mismo tiempo de acceso a todos los

componentes del sistema (incluidos los periféricos), reciben el nombre de sistemas multiprocesador simétrico.Los procesadores tienen el mismo dominio (prioridad) sobre los periféricos y cada procesador tienen la misma capacidad para procesar.

• Sistema Asimétrico: Los sistemas multiprocesador asimétrico, son sistemas con procesadores maestros y procesadores esclavos, en donde sólo los segundos pueden ejecutar aplicaciones y dónde en tiempo de acceso para diferentes procesadores no es el mismo. Los procesadores esclavos (attached) ejecutan código usuario bajo la supervisión del maestro, por lo tanto cuando una

21

aplicación es ejecutada en un procesador maestro dispondrá de una cierta prioridad.

1.7.3 Sistema de Multiprocesador NUMA (Non Uniform Memory Access)

Un sistema multiprocesador NUMA es un sistema de memoria compartida donde el

tiempo de acceso varía según donde se encuentre localizado el acceso.

El acceso a memoria, por tanto, no es uniforme para diferentes procesadores. Existen memorias locales asociadas a cada procesador y estos pueden acceder a datos de su memoria local de una manera más rápida que a las memorias de otros procesadores, debido a que primero debe aceptarse dicho acceso por el procesador del que depende el módulo de memoria local.

Todas las memorias locales conforman la memoria global compartida y físicamente distribuida y accesible por todos los procesadores.

Figura 6.- Cluster Jerárquico Fuente: Organización de computadoras Andrew S. Tanenbaum

Otro modelo NUMA que nace como la mezcla del modelo UMA explicado anteriormente

y el modelo NUMA anterior, es el cluster jerárquico, ver figura 6, en el que se combinan las memorias locales y las globales obteniendo una cierta escalabilidad del sistema. Los procesadores aparecen distribuidos en clusters (1 sistema UMA o un 1 sistema NUMA). Estos clusters están conectados a la memoria global compartida. El sistema en su totalidad es un sistema NUMA, ya que el acceso a memoria es no uniforme por parte de los clusters. La ventaja de estos sistemas con respecto a los sistemas UMA, es que el acceso a memoria local es mucho más rápido.

1.7.4 Sistema COMA (Cache Only Memory Access)

Los sistemas COMA son un caso especial de los sistemas NUMA. Este tipo de sistemas

22

no ha tenido mucha trascendencia, al igual que los sistemas SIMD. Las memorias distribuidas son memorias caches, por este motivo es un sistema muy restringido en cuanto a la capacidad de memoria global. No hay jerarquía de memoria en cada módulo procesador. Todas las caches forman un mismo espacio global de direcciones. El acceso a las caches remotas se realiza a través de los directorios distribuidos de las caches. Ver figura 7. Figura 7.- Sistema Coma. Fuente: Organización de computadoras Andrew S. Tanenbaum

Dependiendo de la red de interconexión utilizada, se pueden utilizar jerarquías en los directorios para ayudar a la localización de copias de bloques de caché.

1.7.5 Multicomputadoras

Los sistemas llamados multicomputadoras se pueden ver como una computadora paralela en el cual cada procesador tiene su propia memoria local. En estos sistemas la memoria se encuentra distribuida y no compartida como en los sistemas multiprocesador. Las computadoras se comunican a través de paso de mensajes, ya que éstos sólo tienen acceso directo a su memoria local y no a las memorias del resto de procesadores.

El diagrama de bloques de un sistema de multi computadora que coincide con el visto para los sistemas UMA, la diferencia viene dada porque la red de interconexión no permite un acceso directo entre memorias, sino que la comunicación se realiza por paso de mensajes.

La transferencia de los datos se realiza a través de la red de interconexión que conecta un subconjunto de procesadores con otro subconjunto. La transferencia de unos procesadores a otros se realiza por tanto por múltiples transferencias entre procesadores conectados dependiendo del establecimiento de dicha red.

Dado que la memoria está distribuida entre los diferentes elementos de proceso, estos

sistemas reciben el nombre de distribuidos. Por otra parte, estos sistemas son débilmente acoplados, ya que los módulos funcionan de forma casi independiente unos de otros.

CAPÍTULO 2. PRINCIPIOS DEL PROCESAMIENTO EN PARALELO

Las súpercomputadoras son herramientas para la creación y el desarrollo de simulaciones y

23

modelos de estados y procesos. Los usos y el aprovechamiento del rendimiento de estas potentes herramientas dependen fundamentalmente de la habilidad, la imaginación y esfuerzo de los investigadores. El uso de programas que explotan el diseño 3D por computadora de una gran variedad de sistemas físicos ha alcanzado el punto donde la realidad puede ahora ser simulada con un alto grado de fiabilidad. (Ver anexo 2).

Los modelos físicos de sistemas reales, ya sea la atmósfera, la turbulencia, el caos, la combustión en sistemas químicos, mecánicos, los vehículos automotores y aerospaciales, las máquinas, las moléculas de proteínas, los procesos industriales o económicos, etcétera., pueden ser suficientemente detallados para utilizarse para predicciones verídicas. De esta manera la computación avanzada es más y más un instrumento para el desarrollo de la sociedad y para la competitividad industrial a todos los niveles, y no está limitada a un sector industrial específico. El impacto en la sociedad de las súpercomputadoras no está limitado a sus beneficios en la industria, el comercio y los servicios.

Incluye al estudio de la propagación de enfermedades, el reconocimiento y traducción de lenguajes naturales, los cambios globales de clima o la compleja dinámica de los sistemas económicos. Es bien conocido que los principales problemas que afectan a nuestra sociedad son de naturaleza mundial y necesitan estudiarse y resolverse a esta escala. En muchos casos, la ausencia de datos completos, como los referentes a la atmósfera y la biosfera, o a la población mundial, hace que se desarrollen criterios subjetivos para realizar predicciones. Esto requiere la comprensión de sistemas muy complejos, cuyo comportamiento solamente puede ser totalmente asimilado y predecible con más precisión por medio de una modelización detallada empleando computadoras de altas capacidades.

Si el siglo XIX marcó el comienzo de la era moderna con la Revolución Industrial, ahora nos encontramos inmersos en otra revolución, la denominada revolución del conocimiento, que se centra en las denominadas tecnologías de la información. La máquina de vapor de entonces es “sustituida” por la computadora. El nombre de James Watt deja paso a otros como Charles Babbage, John von Neumann (considerado el padre de las computadoras modernas), Seymour Cray (fundador de le empresa Cray y padre de las súpercomputadoras) o el controversial Bill Gates. En pocos años la computadora ha ganado rapidez, habilidad, capacidad de almacenamiento de información, interfaces más amigables para el usuario, precios más baratos, pero estos pequeños avances no son suficientes cuando se trata de realizar tareas de investigación, control y análisis, por el volumen y complejidad de la información a tratar. Subimos entonces al escalón más alto, a la informática de alto rendimiento, donde se encuentran las potentes súpercomputadoras.

La evolución de las súpercomputadoras A principios de los años setenta, la aplicación

predominante de la computadora era el procesamiento de datos administrativos. Los banqueros, los administradores de universidades y los ejecutivos publicitarios se sorprendían ante la velocidad sensacional con que las grandes computadoras de millones de dólares procesaban datos. Los ingenieros y científicos se mostraban agradecidos por este tremendo logro tecnológico, pero distaban de estar satisfechos.

24

Cuando los ejecutivos empresariales hablaban acerca de la capacidad ilimitada, los ingenieros y científicos sabían que deberían esperar avances futuros antes de que pudieran usar las computadoras para manejar problemas complicados. Los ingenieros automotores aún no podían construir prototipos tridimensionales de automóviles en una computadora. Los físicos no podían investigar las actividades de un átomo durante una explosión nuclear. Las comunidades de ingenieros y científicos tenían una necesidad apremiante de computadoras más potentes.

En respuesta a esa necesidad, los diseñadores de computadoras empezaron a trabajar en lo que ahora se conoce como súpercomputadoras. Fundamentalmente, las súpercomputadoras manejan aplicaciones del tipo limitado al procesador.

Las aplicaciones limitadas a procesador, que son útiles para los ingenieros y científicos, requieren relativamente poco en lo que se refiere a entrada o salida. En las aplicaciones limitadas al procesador; la cantidad de trabajo que el sistema de computación puede realizar está limitada principalmente por la arquitectura de la computadora. Una tarea científica involucra el manejo de un modelo matemático complejo que, a menudo, requiere para su resolución de billones de operaciones.

A principios de la década de 1970, algunos de los trabajos científicos complejos de tipo limitado a procesador ocupaban durante días las grandes computadoras de las universidades más importantes. Por lo contrario, las macrocomputadoras, se orientan a aplicaciones limitadas de entradas y salidas; es decir, la cantidad de trabajo que el sistema de computación puede realizar está limitada principalmente por la velocidad de los dispositivos de entrada y salida.

Las supercomputadoras también utilizan técnicas especiales para evitar el calor en los circuitos y prevenir que se quemen debido a su proximidad. El conjunto de instrucciones de las supercomputadoras contiene las instrucciones de transferencias de datos, manipulación de datos y transferencia de control del programa de las computadoras convencionales. Esto se aumenta mediante instrucciones que procesan valores y combinaciones de escalares y vectores. Una súper computadora es un sistema de computación que se reconoce por su alta velocidad de cálculo, sus sistemas de memoria grandes y rápidos y un uso amplio de procesamiento paralelo. Está equipada con unidades funcionales múltiples y cada unidad tiene su propia configuración de arquitectura paralela. Aunque la súper computadora maneja aplicaciones de propósito general que se encuentran en todas las otras computadoras, está optimizada específicamente para el tipo de cálculos numéricos que involucran vectores y matrices de números de punto flotante.

Las supercomputadoras no son convenientes para procesamiento cotidiano normal de una

instalación de computadora típica. La parámetro mas común es la velocidad de una supercomputadora, ésta se mide sobre la base de la cantidad de operaciones matemáticas que hace por segundo. El término técnico para esta velocidad es FLOPS. Una de las primeras tareas asignadas a la computadora de los años cuarenta, la ENIAC, no fue para un uso muy humano, ya que se utilizó en los cálculos de diseño de la primera bomba atómica (Proyecto Manhattan), en concreto, para calcular las ondas de choque de

25

las explosiones de prueba. Sin la rapidez y la capacidad de cálculo de las computadoras, algunas disciplinas se habrían quedado en sus planteamientos teóricos, tal es el caso de la física de alta energía.

Hay experimentos en el CERN que hacen colisionar electrones y positrones y que producen tal cantidad de información que sin la ayuda de una súper computadora que sepa discriminar entre todos los sucesos no se habría podido comprobar experimentalmente las ideas teóricas. En la investigación espacial, la utilización de computadoras se convirtió en esencial. La nave Voyager 2, que fue lanzada el 20 de agosto de 1977 con la misión para explorar los planetas exteriores al sistema solar, iba equipada con seis computadoras diferentes, con capacidad de 540 Megas, algo portentoso para la época. Hoy en día, la existencia de las supercomputadoras que, naturalmente, trabajen en tiempo real, se ha convertido en una necesidad. Por ejemplo, son imprescindibles en las industrias del automóvil y la aeronáutica. En este caso los estudios de aerodinámica son una pieza fundamental para optimizar la forma del fuselaje o de las alas.

También se emplea en simulación de vuelos para el entrenamiento de los pilotos, etc. El análisis de la estructura del avión Boeing 777 se realizó completamente por una supercomputadora y también el diseño del avión invisible F-117. Otras aplicaciones son el diseño de nuevos productos farmacéuticos, componentes electrónicos, simulación de terremotos, estudio de la evolución de la contaminación en áreas extensas, predicción meteorológica y estudios del cambio climático o simulación de órganos corporales con el objetivo de reproducir su funcionamiento con representaciones en 3D de alta precisión a partir de métodos de resonancia magnética.

De esta forma, llamaremos computación paralela a las técnicas que descomponen un problema en subtareas y partes de estas tareas que pueden ser procesadas en diferentes máquinas o elementos de proceso al mismo tiempo. En la metáfora del cerebro como computadora, puede ser válido imaginar cierta similitud entre dicho órgano y la computadora. 2.1. La conjetura de Minsky

En cualquier sistema paralelo existe una norma aceptada para medir el incremento de la velocidad (speedup) de una aplicación cuya aplicación cae entre dos límites: (ln2N) y (Nln2N), donde N está definido por el número de procesadores. La primera de ellas, es conocida como la conjetura de Minsky, y la otra se ha considerado un límite superior general para las curvas maximas del incremento de la velocidad.

Es necesario establecer la aplicación en paralelo que deseamos medir, es necesario conocer que en su calculo aparecerán componentes seriales y paralelos de diversa complejidad. La complejidad que nos estamos refiriendo aquí es la medida algorítmica de la variación del tiempo de ejecución del programa en función del tamaño de los datos y del número de procesadores. Los componentes seriales pueden tener una complejidad, por ejemplo, de O (N2), donde N determina el tamaño del problema. Este componente serial tomará muy probablemente la misma cantidad de tiempo cuando está funcionado en un procesador o en varios de ellos. En relación a los componentes en paralelo, sin embargo, esto será una historia diferente, ya que al asumir que un procesador opera pedazos de N datos consumiendo un tiempo proporcional a O(N3), pero cuando los mismos pedazos de N datos se procesan en una red del N-procesadores, la complejidad es O (N2) , la cual es factible en su recostrcción práctica.

26

Es posible entonces encontrar una relación que muestre el grado de incremento de velocidad, la siguiente formula muestra esta relación:

Speedup = O(N)+ O(N³) ���� O(N)

O(N)+ O(N²)

Lo anterior determina que un programa serial se encuentra compuesto por un componente serial y una serie de componentes en paralelo formados en tantos pedazos como numero de procesadores existentes por lo que su complejidad sera mayor. La complejidad del componente en paralelo disminuye, cuando los procesos están ejecutandose en una máquina paralela, por lo que algoritmo paralelo divide el tamaño de los datos procesados entre el número de procesadores y el componente serial se puede hacer insignificante en la ecuación del incremento de velocidad.

Lo anterior nos indica que si existen algoritmos eficientes para procesar grandes cantidades de datos, entonces él vale la pena construir computadoras más grandes que puedan tratar problemas grandes, porque como aumentamos el tamaño de los datos y el tamaño de la máquina, podemos esperar que el speedup aumente.

2.2. Ley De Amdahl.

Esta ley es utilizada para poder evaluar el rendimiento de una computadora por medio de

la evaluación de sus tareas con base en sus tiempos de computación, de espera o inactividad y la latencia de la red.

En cualquier programa paralelizado existen dos tipos de código: el código paralelizado y

el código secuencial. Como es sabido existen ciertas secciones de código que ya sea por dependencias, por acceso a recursos únicos o por requerimientos del problema no pueden ser paralelizadas.

Estas secciones conforman el código secuencial, que debe ser ejecutado por un solo

elemento procesador. Es pues lógico afirmar que la mejora de rendimiento (R) de un programa dependerá completamente de:

El tiempo en el que se ejecuta el código serie.

El tiempo en el que se ejecuta el código paralelizable.

27

Donde Rh representa el rendimiento mas Alto de un proceso y RL el rendimiento mas bajo.

Esto genera la siguiente ecuación:

Esta es la llamada ley de Amdahl y fue descrita por Gene Amdahl en 1967. Las

implicaciones que trae esta ecuación son, a pesar de que no tenga en cuenta las características de cada sistema en concreto:

A) El rendimiento no depende completamente del número de procesadores que posea el sistema: en la mayoría de los casos dependerá del número de procesadores máximo que se aprovecharán simultáneamente para ejecutar un programa.

B) Cuanto mejor paralelizado esté un programa más susceptible será de aumentar su velocidad y

por tanto explotar el rendimiento del sistema paralelo que lo ejecute. Supongamos ahora que tenemos un programa que inicialmente no hemos paralelizado,

cuyos tiempos de ejecución son 12% y 88%, en serie y en paralelo respectivamente (observe la figura 8)

28

Figura 8.- Ejemplo de incremento de velocidad obtenido con la ley de Amdahl usando varios procesadores

Como se puede ver en la figura anterior, la parte no paralelizable del código impide que se

pueda escalar de forma lineal, llegará un momento que añadir nuevos procesadores no añadirá una ventaja real al sistema, porque todo lo que estará en ejecución será código secuencial. Por lo tanto para maximizar el aprovechamiento de los sistemas paralelos debe tenerse mucho cuidado con la forma de paralelizar las aplicaciones: cuanto más código secuencial tengan, más problemas de escalabilidad.

En relación al tiempo de ejecución de una tarea dentro de una máquina paralela el

tiempo de ejecución total de nuestro programa viene dado por Donde Tcomp = Tiempo de computación Tcomm = Tiempo de comunicaciones Tidle= Tiempo de espera o inactivo P=Numero de procesadores

Como el procesamiento de cada tarea, en la maquina paralela, es muy rapido,

generalmente en el orden de los milisegundos o microsegundos, es necesario recurrir a herramientas graficas que analizen el proceso al ejecutarse, en el caso de mpich, éste cuenta con aplicaciones como el upshot que genera los siguientes gráficos, obsérvese la figura 9.

29

Figura 9.- Gráfico generado con Upshot donde expresa el nivel de computación, de comunicación y en espera para 8 procesadores

2.3. Granularidad

La granularidad de sincronización, o frecuencia, entre procesos en el sistema, es una buena manera de caracterizar multiprocesadores y ubicarlos en un contexto con otras arquitecturas. Se pueden distinguir cinco categorías de paralelismo que difieren en el grado de granularidad. Estas categorías se encuentran listadas en la Tabla 1. Tamaño del Grano Descripción Intervalo de

sincronizaciones de instrucciones con base

en el numero de procesos

Fino Paralelismo inherente en el único flujo de instrucciones <20 Medio Procesamiento paralelo o multitarea dentro de una

aplicación individual 20-200

Grueso Multiprocesamiento de procesos concurrentes en un entorno multiprogramado

200-2000

Muy Grueso Proceso distribuido por los nodos de una red para formar un entorno de computación

2000 – 1 000000

Independiente Varios procesos no relacionados No aplica Tabla 1. Procesos y granularidad de la sincronización

30

2.3.1 Paralelismo de grano fino

El paralelismo de grado fino representa un uso mucho más complejo del paralelismo que es encontrado en el uso de hilos. Aunque muchos trabajos han sido hechos en aplicaciones altamente paralelas, es un área especializada y fragmentada, con muchos enfoques diferentes.

2.3.2 El paralelismo de grano medio En el paralelismote grano medio , una aplicación puede ser efectivamente implementada como una colección de hilos con un paralelismo simple. En este caso, el paralelismo potencial de una aplicación debe ser explícitamente especificado por el programador. Generalmente se necesitará un alto grado de coordinación e interacción entre los hilos de una aplicación, llevando a un nivel medio de sincronización.

2.3.3 Paralelismo de grano grueso y muy grueso

En el paralelismo de grano grueso, existe sincronización entre procesos pero a nivel muy grotesco. Esta clase de situación es fácilmente entendible como un grupo de procesos concurrentes ejecutándose en un monoprocesador multiprogramado y puede ser soportado en un multiprocesador con un pequeño o no cambio al software del usuario. En general, cualquier conjunto de procesos concurrentes que necesiten comunicarse o sincronizarse puede aprovechar el uso de las arquitecturas de los multiprocesadores. Un sistema distribuido puede ofrecer un soporte adecuado en caso de interacciones poco frecuentes entre los procesos. Sin embargo, si la interacción es algo más frecuente, la sobrecarga de comunicaciones a través de la red puede anular parte de la posible aceleración. En este caso, la organización del multiprocesador ofrece el soporte más efectivo.

2.3.4 Paralelismo independiente

Entre los procesos de paralelismo independiente, no existe una sincronización explícita.

Cada uno representa una separación, una aplicación independiente. El uso típico de este tipo de paralelismo es en los sistemas de tiempo compartido. Cada usuario está ejecutando una aplicación en particular, como un procesador de textos o una hoja de cálculo. El multiprocesador ofrece el mismo servicio que un procesador multiprogramado. Como hay más de un procesador disponible, el tiempo medio de respuesta a los usuarios será menor. Es posible alcanzar un aumento similar de rendimiento proporcionado a cada usuario una computadora personal o una estación de trabajo. Si van a compartirse archivos o alguna información, entonces se deben conectar los sistemas individuales en un sistema distribuido soportado por una red. Por otro lado, un único sistema multiprocesador ofrece, en muchos casos, un costo mejor que un sistema distribuido, pudiendo así mejorar los elementos físicos que lo conforman.

31

La tabla 2 muestra la relación entre la granularidad del algoritmo, el grado de acoplamiento del hardware y el modo de comunicación, y la diferencia entre procesamiento paralelo y distribuido. El procesamiento distribuido ocurre cuando los recursos de hardware cooperan pobremente en el proceso de un trabajo. Ejemplos de sistemas distribuidos son las redes de computadoras y algunas computadoras múltiples. Cuando los componentes de hardware cooperan fuertemente para procesar las tareas simultáneamente, estamos en presencia de un procesamiento paralelo.

Nivel de trabajo Distribuido Nivel de tarea Redes de computadoras Nivel de proceso Paso de mensajes Nivel de instrucción Paralelo Nivel de variable Multicomputadoras Nivel de bit Memoria compartida Multiprocesadores

Tabla 2. - Muestra la relación entre la granularidad del algoritmo.

Existe una diferencia importante entre multiprocesadores y computadoras múltiples. Una

computadora múltiple consiste de varias computadoras, cada una de ellas conformadas por su propio procesador, memoria, dispositivos de entrada, salida y sistema operativo. Mientras que un sistema multiprocesador tiene un único sistema operativo y sus procesadores comparten la memoria y los dispositivos de entrada y salida. Existen dos grandes conjuntos de modelos de arquitecturas basadas en multiprocesadores: una está basada en una arquitectura de procesadores fuertemente acoplados y la otra en procesadores débilmente acoplados.

Las diferencias entre ambas arquitecturas son las siguientes: en las estructuras fuertemente acopladas los procesadores se comunican a través de memoria central (lo que llamábamos memoria centralizada o compartida) por lo tanto la velocidad de comunicación estará acotada por el ancho de banda (bits/seg.) de la memoria. La interconexión puede realizarse a través de una red que comunique a los procesadores con la memoria o usando memoria de puertas múltiples. Ver figura 10.

Granularidad del algoritmo

Grado de acoplamiento Modo de comunicación

32

Figura 10.- La interconexión de red usando memoria de puertas múltiples .

Un factor que limita la expansión de estos sistemas está dado por la degradación de rendimiento global motivada por el aumento de colisiones al intentar acceder a la memoria cuando se aumenta el número de procesadores.

Una alternativa que intenta mejorar este conflicto es proveer a cada procesador de una memoria de trabajo local mapeada en la memoria global de manera que la mayoría de los accesos a datos y código sean locales a cada procesador. Esto disminuye los conflictos causados por colisiones al acceder a la memoria global, pero aumenta el riesgo de pérdida de consistencia de datos replicados en más de una memoria local.

Por otro lado están los sistemas débilmente acoplados, en los cuales los procesadores se comunican entre sí a través del uso de redes de comunicación mediante el paso de mensajes entre procesos (lo que llamábamos memoria distribuida). En este esquema cada procesador tiene su propio conjunto de puertas de entrada y de salida y su propia memoria local, formando entre los tres un módulo de procesamiento. De este modo, los procesos en distintos módulos de procesamiento pueden comunicarse entre sí mediante el intercambio de mensajes a través de un sistema de transferencia de mensajes (STM) Ver figura 11.

Figura 11.- Sistema de memoria compartida con un elemento de proceso con memoria local

33

El factor determinante del grado de acoplamiento está dado por la topología del

correspondiente sistema de transferencia de mensajes. En caso de colisión de dos o más procesadores al intentar acceder al bus de mensajes, el STM será el responsable de arbitrar el orden de los pedidos respondiendo a alguna disciplina de atención determinada. Esto determina que el STM deberá poseer una memoria de alta velocidad para almacenar los mensajes que le pase el procesador hasta que estos puedan ser enviados satisfactoriamente por la red.

En este tipo de arquitecturas el rendimiento global de la computadora estará dado por la confiabilidad esperable del sistema de mensajes, el cual deberá proveer un vínculo de comunicación de alta velocidad y además garantizar un tiempo de espera mínimo para mensajes en caso de conflictos.

El primero de los factores está íntimamente ligado al diseño propio del STM y a la tecnología electrónica utilizada, aunque algunos factores son deseables a la hora de implementar un STM real; como son el ancho de banda del canal de transferencia (bits/seg.) y la capacidad y velocidad de la memoria (buffer) de cada STM. El segundo factor está más relacionado con la distribución física de la red de intercomunicación, los casos más utilizados son los siguientes: a) Bus compartido.- Esta organización es la menos compleja y fácilmente reconfigurable. Los STM son pasivos y su función principal es la de arbitrar prioridades de acceso al recurso compartido (bus). En caso de colisiones los mecanismos de gestión determinarán el orden de atención de los mensajes colisionados. Algunos de estos mecanismos pueden ser colas tipo FIFO o encadenamiento, ver figura 12.

bus de transferencia de mensajes

Figura 12.- Esquema de un módulo de procesamiento. b) Desdoblamiento del bus de comunicación. Esta configuración alivia algunos de los problemas mencionados anteriormente, sin un apreciable incremento en la complejidad del sistema ni decremento en la confiabilidad del mismo. No obstante, una simple operación de transferencia, generalmente requiere el uso de los dos buses, por lo tanto no es mucho lo que se gana.Ver figura 13.

34

Figura 13.- Interconexión a través de un bus común. 2.4. Redes específicas

2.4.1 Red Crossbar

La red crossbar mostrada en la figura 14 se utiliza comúnmente en sistemas de memoria compartida; genera accesos simultáneos no bloqueantes a memoria y comunicación entre unidades funcionales. El switch (S) para proveer un máximo de transferencias simultáneas en cada punto del conmutador debe ser capaz de cambiar las transmisiones en paralelo y resolver posibles conflictos entre requerimientos de las unidades funcionales. Este tipo de conexión se usa generalmente con pocos procesadores ya que el número de switches es proporcional a O(N2), siendo N el número de procesadores. Figura 14.- Red Crossbar

S S S

S S S

S S S

P1

P2

P2

M1 M2 M3

35

2.4.2 Memorias Multipuerto

La disponibilidad de memorias multipuerto hace posible la construcción de redes de

interconexión en las cuales los procesadores se comunican a través de las memorias en lugar de buses. La única restricción es que los procesadores deben esperar en caso de acceder a la misma localidad de memoria, la cual es protegida a través de algún mecanismo de prioridades interno al sistema de memoria. La ventaja de este esquema es que los protocolos de comunicación entre unidades funcionales se reducen debido a que los datos pueden almacenarse temporalmente en la memoria ver figura 15.

Figura 15.- Comunicación entre procesadores usando una memoria de 4 puertos

Las redes multietapa son las más indicadas para la interconexión de muchos procesadores. Permiten la comunicación de una manera más general de procesador a procesador como de procesador a memoria. Ver figura 16.

Figura 16.- Red multietapa

…… ……

1 2

N

1 2 N

Etapa 1 Etapa 2 Etapa k

36

En general se distinguen cuatro tipos de redes multietapa

a. Estrictamente no bloqueantes: conecta cualquier entrada libre a cualquier salida libre (sin importar otras conexiones, ver figura 17.

Figura 17.- Red Multietapa estrictamente no bloqueante.

1

r

1

m

1

r

1 n

1 n

1 n

1 n

r x r

3 x 3

n x m m x n

2 x 4 4 x 2

12 inputs

12 outputs

37

b. No bloqueantes re configurables: pueden realizar todas las conexiones posibles reconfigurando conexiones existentes (si m >= n) .Ver figura 18.

Figura 18.- Red Multietapa estrictamente no bloqueante reconfigurable.

c. No bloqueantes de amplio espectro: pueden realizar todas las conexiones posibles sin bloqueo dependiendo de las reglas de ruteo usadas (en el caso anterior sí m >= 3n/2).

d. Interconexión Bloqueante. Pueden realizar algunas pero no todas las interconexiones entre entradas y salidas.

2.5 Estrategias de software de los MIMD.

2.5.1 Técnicas de compilación

La técnicas de Compilación , se refieren a aquellas técnicas usadas por las

implementaciones como recursos del procesador, que permiten explotar lo más posible el paralelismo en un programa de usuario. Generalmente en este tipo de estudios no se considerarán los recursos generales del sistema tales como cantidad de procesadores, disposición física de la memoria, presencia de memoria cache, etcétera, aunque debe tenerse en cuenta que estos parámetros realmente influyen fuertemente en el desempeño final del sistema. Conceptualmente, un compilador para MIMD debe analizar un programa para hallar porciones o bloques de código que puedan ejecutarse concurrentemente, para lo cual deben cumplirse al menos dos condiciones primordiales: que el sistema disponga de los recursos necesarios para la ejecución en paralelo de más de una tarea (disposición de varios procesadores, unidades de cálculo, etcétera) y que los bloques elegidos sean no dependientes entre sí.

0 1

2 3

4 5

6 7

0 1

2 3

4 5

6 7

38

Llamaremos bloque a toda secuencia de instrucciones sin saltos hacia afuera o hacia adentro del mismo, aunque en algunos casos sobrepasaremos los límites de un bloque y consideraremos el análisis al nivel de instrucciones particulares.El paralelismo real disponible en un programa está limitado por sus dependencias. Una dependencia entre dos sentencias de un programa es algún tipo de conflicto que evita que las sentencias puedan ejecutarse concurrentemente. Las dependencias pueden clasificarse en tres tipos: dependencias de recursos, de datos y de control.

Una dependencia de recursos entre dos instrucciones es consecuencia de las limitaciones de hardware disponible en un sistema de computación. Este tipo de dependencia ocurre cuando dos sentencias intentan simultáneamente usar el mismo recurso, tal como dos operaciones de multiplicar compitiendo por un único multiplicador o dos operaciones de referencia a memoria intentando acceder a un mismo puerto de memoria física.

Una dependencia de datos existe entre dos instrucciones cuando ambas apuntan a la misma posición de memoria o acceden a un mismo registro. Por ejemplo, una dependencia de flujo (read after write hazard) se da de la instrucción S1 a S2 en el siguiente fragmento de programa, ya que S2 necesita el valor de A producido por S1 antes de poder ejecutarse. S1 : A = B + C S2 : D = A - E

Dos instrucciones escribiendo en la misma localidad de memoria crean una dependencia de salida, como se ve a continuación: S1 : X = Y + Z S2 : C = X * 22 S3 : X = A - B

El proceso S1 debe ejecutarse antes que S3 puesto que S2 usa el resultado producido por S1 (una dependencia de flujo de S1 a S2). En este ejemplo se da también una dependencia entre S2 y S3, puesto que S2 lee el valor de X que es escrito por S3, en consecuencia S2 debe ejecutarse antes que S3.

Las dependencias de flujo son las únicas dependencias verdaderas en las que el resultado producido por la primera instrucción es usado como valor por la segunda instrucción. Por otro lado, las no dependencias y las dependencias de salida ocurren cuando el programador o el compilador rehúsan espacio de almacenamiento. En estos casos, renombrar variables es una buena política para eliminar estas dependencias. Por ejemplo, en lugar de usar un mismo arreglo para dos operaciones independientes en diferentes partes de un programa, el programador podría definir dos arreglos separados. Esto, por supuesto, incrementa el paralelismo a costa de un mayor gasto de memoria.

Una dependencia de control de la sentencia Si a Sj existe cuando la sentencia Sj debiera ser ejecutada sólo si Si produce un cierto resultado. Esta dependencia ocurre, por ejemplo, si Si es una sentencia condicional y Sj va a ser ejecutada al verificarse la condición verdadera de Si.

39

Al limitar la extracción de paralelismo a un bloque básico se limitará la aceleración máxima de un problema al proceso en paralelo de dos o cuatro bloques solamente (dadas las limitaciones de hardware). Sin embargo, si se traspasan los límites del bloque el paralelismo del programa entero resulta disponible para su explotación. Simulaciones realizadas en casos ideales muestran que programas de ingeniería o científicos tienen un alto grado de paralelismo, en cambio, la generalidad de los programas comunes tiene una tasa bastante baja.

Una aproximación eficiente para extraer este paralelismo potencial de los programas es concentrarse en el paralelismo disponible en los ciclos. Puesto que el cuerpo de un ciclo puede ejecutarse varias veces, es fácil a menudo encontrar grandes porciones de paralelismo en ellos. Una gran variedad de computadoras con arquitecturas paralelas y técnicas de compilación han sido propuestas para explotar el paralelismo a diferentes granularidades.

Antes de analizar las técnicas para explotar el paralelismo en un ciclo es útil analizar el máximo paralelismo existente en un ciclo independientemente de las restricciones de recursos del sistema de computadora en que se trabaja. De este modo podremos analizar el rendimiento máximo de cada técnica y compararlas entre sí sin optar por una arquitectura en particular. Por simplicidad de análisis supondremos que no existen dependencias de control dentro del ciclo que puedan ocasionar una bifurcación temprana fuera de él.

Sin embargo se pueden considerar operaciones condicionales enteramente contenidas dentro del ciclo. El máximo grado de paralelismo existente en un ciclo se encontrará limitado por la dependencia de sus datos y por la dependencia de recursos de la máquina en la que se ejecute. Las dependencias del programa pueden representarse con grafos orientados, donde cada nodo es una operación y los arcos representan dependencias entre operaciones. Asociaremos dos valores al arco k que va desde la instrucción Si a Sj de un ciclo. El primer valor del tiempoTk será el tiempo que la sentencia, el segundo valor expresado por Ck, será la cantidad de iteraciones luego de la ejecución de Si, en que se ejecutará Sj.

Las figuras siguientes numero 19, muestra su correspondiente grafo de dependencias.

For (i=1; i<=N ; y++) { S1 : A(i) = E(i-1) + 6 S2 : B(i) = A(i) * Z S3 : C(i) = B(i-1) + X S4 : D(i) = C(i) + Y S5 : E(i) = B(i) * D(i) }

40

Figura 19.- Grafo de dependencia. Los arcos están rotulados con (Tk,Ck) .

Los arcos punteados muestran dependencias que van de una iteración del ciclo a otra. Esas dependencias cruzadas en las iteraciones limitan el paralelismo máximo del ciclo, puesto que iteraciones posteriores dependen de resultados generados en iteraciones anteriores. De este modo, algunas iteraciones deben ser ejecutadas secuencialmente. Cuando una dependencia apunta hacia atrás relativa al orden en que aparecen las sentencias, un ciclo puede aparecer en el grafo de dependencia.

Por ejemplo, el grafo de dependencia de la figura anterior posee dos ciclos. El primero

consiste de las sentencias

S1(i) - S2(i) - S5(i) - S1(i+1).

Desenrollando completamente el ciclo, se puede convertir cualquier ciclo del grafo en una

cadena lineal de dependencias. La tabla 3 muestra esta cadena para el ciclo presentado:

Tiempo Sentencia 1 S1(1) 2 S2(1) 3 4 5 S5(1) 6 7 8 S1(2) 9 S2(2) 10 11 12 S5(2) 13 14 15 S1(3) ...

Tabla 3. - Cadena para el ciclo representado.

41

Las tres sentencias en el ciclo van a ser ejecutadas N veces, donde N es el número de iteraciones del ciclo. Cada repetición del ciclo requiere Tc = Σ Tk = 7 unidades de tiempo, donde Tc es la suma de las correspondientes Tk mostradas en los arcos del grafo para este ciclo. El tiempo total para ejecutar el total de las sentencias del ciclo será entonces Tt1 = N * Tc = N * 7 unidades de tiempo. Similarmente, el segundo ciclo en el grafo es S3(i) - S4(i) - S5(i) - S1(i+1) - S2(i+1) - S3(i+2), como se ve en la tabla 4.

Tiempo Sentencia 1 S3(1) 2 S4(1) 3 S5(1) 4 5 6 S1(2) 7 S2(2) 8 9 10 S3(3) 11 S4(3) 12 S5(3) 13 14 15 S1(4) 16 S2(4) 17 18 19 S3(5)

Tabla 4. Segundo ciclo.

Una ejecución de todas las sentencias de este ciclo requiere Tc = ΣTk = 9 unidades de tiempo. Puesto que el patrón se repite cada dos iteraciones, la versión desenrollada del ciclo se ejecutará N/2 veces. Notar que dos copias pueden ser ejecutadas simultáneamente. Una copia puede empezar en i = 1 y la otra en i = 2. Ver tabla 5.

Procesador 1 procesador 2 S1(1) S1(2) S2(1) S2(2) S3(1) S3(2) S4(1) S4(2) S5(1) S5(2) S1(3) S1(4) S2(3) S2(4) S3(3) S3(4) S4(3) S4(4) S5(3) S5(4)

Tabla 5. Tercer Ciclo.

42

De este modo, el tiempo total de ejecución para este ciclo es

Tt2 = Tc * (N/2) = 9N/2 unidades de tiempo.

La cadena de dependencia más larga producida al desenrollar los ciclos es llamada

trayectoria crítica (critical path), y su tiempo de ejecución se denota como Tcrit. Puesto que puede haber varios ciclos en un recorrido, el mínimo tiempo para ejecutarlo es el tiempo requerido para ejecutar la cadena de dependencia más larga. Entonces, para el ejemplo desarrollado

Tcrit = max(Tti) = max(7N,9N/2) = 7N unidades de tiempo.

La máxima aceleración de este recorrido será el cociente entre el tiempo de la versión

secuencial original y el tiempo de ejecución de la trayectoria crítica. Para el ejemplo dado es fácil comprobar que el tiempo de ejecución secuencial, TL, es 9

unidades de tiempo. Entonces, el tiempo total de ejecución para la versión secuencial es

NTl = 9N unidades de tiempo

Dando una aceleración máxima de :

Smax = (NTl)/Tcrit = 9N/7N = 9/7

Aproximadamente 1,28; lo que representa un 28% de aceleración respecto de la versión

secuencial.Se puede demostrar la validez de esta ecuación para un caso general de un recorrido con uno o más ciclos en su grafo de dependencia.

2.5.2 Arquitecturas paralelas de granularidad fina

Las arquitecturas paralelas de granularidad fina explotan el paralelismo a nivel del juego

de instrucciones realizando varias instrucciones u operaciones en un sólo ciclo. Las dependencias deben ser verificadas en tiempo de compilación o dinámicamente por el hardware para asegurar que sólo operaciones independientes son ejecutadas simultáneamente. Para asegurar un máximo de paralelismo la técnica de verificación de dependencia debe mirar más allá de los límites de un bloque para encontrar operaciones independientes dentro del cuerpo de una iteración simple e incluso entre varias iteraciones diferentes.

Los esquemas para verificar las dependencias dinámicas usan hardware complejo para buscar operaciones independientes en tiempo de ejecución pero un número de factores tales como el tamaño del buffer, desarrollo incompleto de ciclos y predicción de bifurcaciones incompletas que restringen el número de bloques que pueden ser buscados dinámicamente. En consecuencia, las técnicas de compilación, anteriormente referenciadas, han sido desarrolladas para completar y perfeccionar la verificación dinámica de dependencias.

43

Mientras que las arquitecturas de granularidad fina explotan el paralelismo a nivel de instrucciones, las arquitecturas de granularidad gruesa lo explotan distribuyendo iteraciones enteras en diferentes procesadores. En el multiprocesador de memoria compartida de la figura siguiente, por ejemplo, la tarea del scheduler es distribuir distintas iteraciones en los diferentes procesadores del sistema, cada una con un índice distinto. Las estrategias de organización, entonces, tienen la tarea de determinar que iteraciones serán ejecutadas por cual procesador y en que momento. Ver figura 20.

Figura 20.- Arquitectura de Multiprocesador de memoria compartida.

2.5.3 Estrategia Doacross scheduling

En ciclos con dependencias de datos entre iteraciones, esta estrategia puede ser usada para

distribuir iteraciones consecutivas del ciclo en procesadores separados. Para prevenir violaciones de dependencia, esquemas de sincronización explícita fuerzan a cada iteración a comenzar al menos d ciclos después que la iteración previa. La ejecución de un ciclo con esta estrategia puede ser modelada como sigue:

Do I = 1, N delay d * (I - 1) ejecutar iteración con índice I. Enddo

Con recursos infinitos, cada iteración se ejecuta en un procesador separado dando un

tiempo de ejecución Tp = (N - 1) * d + TL.

Para esta estrategia con valores grandes de N, la dependencia de datos limita la aceleración

máxima a:

Smax(doacross) = (N * TL) / [(N - 1) * d + TL] aprox. = TL/d

Las limitaciones de recursos limitan fuertemente la aceleración máxima a menos o igual

que el número de procesadores, p. El valor d es análogo al intervalo de iniciación del pipelining-schedule con la diferencia de que el parámetro d fuerza sincronización explícita entre todos los procesadores. Es fácil ver que, todos los casos, d >= TL. con lo cual, ignorando dependencias de recursos, la máxima aceleración ideal que se obtenga será similar a la obtenida por un procesador usando software pipelining.

44

Una diferencia entre doacross scheduling y software pipelining es que el primero no saca ventajas del paralelismo a nivel de instrucciones dentro de cada iteración. Sin embargo, el hecho de poseer contadores de programa individuales en cada procesador permite a doacross scheduling tolerar operaciones condicionales muy complejas que son bastante problemáticas con software pipelining.

2.5.4 Estrategia Doall loop scheduling

Esta estrategia, aplicable a ciclos que no tengan dependencia cruzada entre iteraciones,

sugiere la ejecución de todas las iteraciones simultáneamente. La tarea del scheduling para determinar que iteraciones deben ser ejecutadas por cuales procesadores y en que momento, pueden clasificarse en estáticas y dinámicas dependiendo del momento en que se realiza la decisión de la asignación de tareas. La asignación estática o pre scheduling, asigna iteraciones a procesadores específicos en tiempo de compilación o de carga del programa. Cada procesador determina que tareas va a ejecutar basado en su número de procesador. Por ejemplo, el ciclo en el código siguiente ejecutará las iteraciones 1, p+1, 2p+1... en el procesador 0; las iteraciones 2, p+2, 2p+2... en el procesador 1; y así sucesivamente, donde p es el número de procesador.

Fork(p) do i = (minum + 1), N, step p A(i) = B(i) * C(i) enddo join(p)

2.5.5 Estrategia de balance de carga

Esta estrategia distribuye las iteraciones entre los procesadores en un intento de balancear

la carga computacional. Puesto que cada procesador conoce su número (minum), y que los identificadores de tarea (índice y del ciclo) son locales, cada procesador puede determinar rápidamente que tarea debe ejecutar, con lo que virtualmente no hay sobrecarga de ejecución (runtime overhead). Si un compilador pudiese predecir acertadamente todos los tiempos de ejecución, la carga computacional podría ser perfectamente balanceada para minimizar el tiempo total de ejecución. Desafortunadamente, una variedad de eventos hacen imposible calcular el tiempo exacto que durará una iteración determinada. Por ejemplo, dos iteraciones pueden producir diferentes resultados en una sentencia condicional. Si el número de sentencias a ejecutar en cada una de las ramas de la condición es diferente, entonces el tiempo de ejecución de las dos iteraciones también será distinto. Otros eventos tales como fallos de cache o de página o demoras en la comunicación entre procesadores pueden aumentar aún más esa diferencia. Todo esto hace que sea bastante difícil para el pre- scheduling mantener un balance de carga aceptable.

El siguiente fragmento del programa muestra este problema para una máquina de dos

procesadores: doall i = 1,N if odd(i) a(i) = b(i) else a(i) = b(i) * c(i) enddo

45

Asumiendo el mismo esquema de distribución de ejemplo anterior, el procesador 1 ejecutará todas las iteraciones donde el índice i sea impar y el procesador 2, todas aquellas con índice i par. Por lo tanto uno de los procesadores siempre ejecutará la sentencia a(i) = b(i) y el otro procesador la sentencia a(i) = b(i) * c(i).

La asignación dinámica, también llamada self scheduling, es usada para llevar las decisiones desde el tiempo de compilación a de ejecución haciendo a cada procesador responsable de asignarse su propia tarea. El código siguiente muestra que cada procesador se asigna iteraciones el mismo en tiempo de ejecución accediendo a una variable compartida (next_iter) que representa el índice a la siguiente iteración a ser ejecutada por el próximo procesador libre. Para prevenir que más de un procesador acceda a esta variable, se insertan en el código sentencias de sincronización apropiadas.

Next_iter = 1 fork(p) /* obtener primera iteración */ lock(next_iter) mi_iter = next_iter next_iter ++ unlock(next_iter) /* repetir mientras haya trabajo para realizar */ while (mi_iter <= N) a(mi_iter) = b(mi_iter) * c(mi_iter) /* obtener la siguiente iteración */ lock(next_iter) mi_iter = next_iter next_iter ++ unlock(next_iter) end while join(p)

El tiempo necesario para acceder la variable compartida y para sacar las tareas del spool de

tareas agrega un overhead a la ejecución, pero este se compensa satisfactoriamente con la mejora en el balance de cargas, ya que en este caso, el tiempo ocioso de un procesador será igual a TL.

2.5.6 MPI (Messaging passing interface) Intercambio de paso deMensajes

El envío de un mensaje de un proceso a otro involucra el movimiento de información de

un espacio de direccionamiento a otro. proceso 1 movimiento de datos proceso 2 send(&x,2); ------------------------------------> recv(&y,1);

El envío de un mensaje involucra además:

• a)El uso de los buffers.

• b)Identificación de los mensajes, lo cual se hace por medio de una selección por medio de etiquetas, además necesita del uso de comodines (wildcards)para seleccionar cualquier tipo de mensaje.

46

• c)Nombramiento de procesos.

• d)Sincronización .

Existen dos términos básicos utilizados en el MPI, estos términos son:

• Síncrono que se utiliza en aquellas rutinas que regresan cuando la transferencia del mensaje ha terminado.

• Bloqueo (blocking) ,que se usa para describir funciones que no regresan hasta que termina la

transferencia. Las funciones de no bloqueo (non blocking)inician la solicitud de transferencia y regresa el control

sin esperar que la Transferencia concluya

El paso de mensajes es una tarea ampliamente usada en ciertas clases de máquinas paralelas, especialmente aquellas que cuentan con memoria distribuida. Aunque existen muchas variaciones, el concepto básico en el proceso de comunicación mediante mensajes es bien entendido. En los últimos 10 años, se ha logrado un progreso substancial en convertir aplicaciones significativas hacia este tipo de tareas. Más recientemente diferentes sistemas han demostrado que un sistema de paso de mensajes puede ser implementado eficientemente y con un alto grado de portabilidad.

Al diseñar el lenguaje estándar por facto llamado MPI, se tomaron en cuenta las características más atractivas de los sistemas existentes para el paso de mensajes, en vez de seleccionar uno sólo de ellos y adoptarlo como el estándar. Resultando así, en una fuerte influencia para en la construcción de MPI los trabajos hechos por IBM, INTEL NX/2, Express, nCUBE's Vernex, p4 y PARMACS. Otras contribuciones importantes provienen de Zipcode, Chimp, PVM, Chameleon y PICL.

La meta de MPI fue la de desarrollar un estándar para escribir programas que implementen el paso de mensajes. Por lo cual el Interfase intenta establecer para esto un estándar práctico, portable, eficiente y flexible. El esfuerzo para estandarizar MPI involucra cerca de 60 personas de 40 organizaciones diferentes principalmente de U.S.A. y Europa. La mayoría de los vendedores de computadoras concurrentes estaban involucrados con MPI, así como con investigadores de diferentes universidades, laboratorios del gobierno e industrias. Se llegó a una propuesta preliminar conocida como MPI1, enfocada principalmente en comunicaciones punto a punto sin incluir rutinas para Comunicación colectiva y no presentaba tareas seguras. El estándar final par el MPI fue presentado en la conferencia de supercomputación en Noviembre de 1993, constituyéndose así el foro para el MPI.

En un ambiente de comunicación con memoria distribuida en la cual las rutinas de nivel más alto y/o las abstracciones son construidas sobre rutinas de paso de mensajes de nivel bajo, los beneficios de la estandarización son muy notorios. La principal ventaja al establecer un estándar para el paso de mensajes es la portabilidad y el ser fácil de utilizar. MPI es un sistema complejo, el cual comprende 129 funciones, de las cuales la mayoría tienen muchos parámetros y variantes.

47

Con esto alcanzarón las siguientes características en el diseño de estándar:

• Diseñar una Interfase de programación aplicable. • Permite una Comunicación eficiente: Evitando el copiar de memoria a memoria y permitiendo

la sobreposición de computación y comunicación, además de aligerar la comunicación con el procesador.

• Permite implementaciones que puedan ser utilizadas en un ambiente heterogéneo. • Permite enlaces convenientes en C y Fortran 77 para la interfase.

• Asume una interfase de comunicación segura.

• Define una interfase que no sea muy diferente a los sistemas actuales, tales como PVM, NX,

Express, p4, etc., y provee de diversas extensiones que permitan mayor flexibilidad.

• Define una interfase que pueda ser implementada en diferentes plataformas, sin cambios significativos en el software y las funciones internas de comunicación.

• La semántica de la interfase debe ser independiente del lenguaje.

• La Interfase debe ser diseñada para producir tareas seguras.

En el modelo de programación MPI, un cómputo comprende de uno o más procesos comunicados a

través de llamadas a rutinas de librería para mandar (send) y recibir (receive) mensajes a otros procesos. En la mayoría de las implementaciones de MPI, se crea un conjunto fijo de procesos al inicializar el programa, y un proceso es creado por cada tarea. Sin embargo, estos procesos pueden ejecutar diferentes programas.

De ahí que, el modelo de programación MPI es algunas veces referido como MIMD (múltiple

program múltiple data) para distinguirlo del modelo SIMD, en el cual cada procesador ejecuta el mismo programa.

Debido a que el número de procesos en un sistema de cómputo de MPI es normalmente fijo, se

puede enfatizar en el uso de los mecanismos para comunicar datos entre procesos. Los procesos pueden utilizar operaciones de Comunicación punto a punto para mandar mensajes de un proceso a otro, estas operaciones pueden ser usadas para implementar comunicaciones locales y no estructuradas. Un grupo de procesos puede llamar colectivamente operaciones de Comunicación para realizar tareas globales tales como broadcast, etc. La habilidad de MPI para probar mensajes da como resultado el soportar comunicaciones asíncronas. Probablemente una de las características más importantes del MPI es el soporte para la programación modular. Un mecanismo llamado comunicador permite al programador del MPI definir módulos que encapsulan estructuras internas de comunicación (estos módulos pueden ser combinados secuencialmente y paralelamente).

48

Aunque MPI es un sistema complejo, es posible resolver un amplio rango de problemas usando

seis de sus funciones, estas funciones inician y terminan un cómputo, identifican procesos, además de mandar y recibir mensajes.

• MPI_INIT: Este proceso Inicia el entorno de MPI. • MPI_FINALIZE: Termina el MPI. • MPI_COMM_SIZE: Determina el número de procesos en un cómputo. • MPI_COMM_RANK: Determina el identificador del proceso actual "mi proceso". • MPI_SEND: Manda un mensaje. • MPI_RECV: Recibe un mensaje.

Todas las funciones con excepción de las dos primeras, toman un manejador "comunicador" como

argumento. El comunicador identifica el grupo de procesos y el contexto en el cual la operación se debe realizar. Los comunicadores proveen un mecanismo para identificar sub conjuntos de procesos durante el desarrollo de programas modulares y para garantizar que los mensajes provistos con diferentes propósitos no sean confundidos. El valor por default es llamado MPI_COMM_WORLD, el cual identifica todos los procesos.

Las funciones MPI_INIT y MPI_FINALIZE son usadas para iniciar y terminar MPI, respectivamente MPI_INIT debe ser llamada antes que cualquier otra función MPI y debe ser llamada solamente una vez por proceso. Ninguna función MPI puede ser llamada después de MPI_FINALIZE.

Las funciones MPI_COMM_SIZE y MPI_COMM_RANK determinan el número de procesos en él cómputo actual y el identificador (entero) asignado al proceso actual, respectivamente. (Los procesos en un grupo de procesos son identificados con un único y continuo número (entero) empezado en 0).

La necesidad por tener una comunicación asíncrona puede presentarse cuando un cómputo necesita acceder a los elementos de un dato estructurado compartido en una manera no estructurada. Una implementación aproximada es el encapsular los datos estructurados en un conjunto de tareas de datos especializados, en la cual las peticiones de lectura y escritura pueden ser ejecutadas. Este método no es eficiente en MPI debido a su modelo de programación MPMD.

Una implementación alternativa con MPI, es el distribuir las estructuras de datos compartidas entre los procesos existentes, los cuales deben solicitar periódicamente las solicitudes pendientes de lectura y escritura. Para esto MPI presenta tres funciones MPI_IPROBE, MPI_PROBE, MPI_GET_COUNT.

MPI_IPROBE checa la existencia de mensajes pendientes sin recibirlos, permitiéndonos escribir programas que generan cómputos locales con el procesamiento de mensajes sin previo aviso. El mensaje puede ser recibido usando MPI_RECV.

MPI_PROBE es utilizado para recibir mensajes de los cuales se tiene información incompleta.

49

MPI soporta la programación modular a través de su mecanismo de comunicador (comm, el cual provee la información oculta necesaria al construir un programa modular), al permitir la especificación de componentes de un programa, los cuales encapsulan las operaciones internas de Comunicación y proveen un espacio para el nombre local de los procesos.

Una operación de Comunicación MPI siempre especifica un comunicador. Este identifica

el grupo de procesos que están comprometidos en el proceso de comunicación y el contexto en el cual la comunicación ocurre. El grupo de procesos permite a un sub conjunto de procesos el comunicarse entre ellos mismos usando identificadores locales de procesos y el ejecutar operaciones de comunicación colectivas sin meter a otros procesos. El contexto forma parte del paquete asociado con el mensaje. Una operación receive puede recibir un mensaje sólo si éste fue enviado en el mismo contexto. Si dos rutinas usan diferentes contextos para su Comunicación interna, no puede existir peligro alguno en confundir sus comunicaciones.

Con MPI_COMM_DUP: Un programa puede crear un nuevo comunicador, conteniendo el mismo grupo de procesos pero con un nuevo contexto para asegurar que las comunicaciones generadas para diferentes propósitos no sean confundidas, Este mecanismo soporta la composición secuencial.

Usando MPI_COMM_SPLIT: Un programa puede crear un nuevo comunicador, conteniendo sólo un subconjunto del grupo de procesos. Estos procesos pueden comunicarse entre ellos sin riesgo de tener conflictos con otros cómputos concurrentes. Este mecanismo soporta la composición paralela.

Aplicando MPI_INTERCOMM_CREATE: Un programa puede construir un intercomunicador, el cual enlaza procesos en dos grupos. Soporta la composición paralela.

La función MPI_COMM_FREE: Puede ser utilizada para liberar el comunicador creado al usar las funciones anteriores.

2.5.7 PVM(Paralell Virtual Machine) Maquina Virtual Paralela

Por otro lado existe otro estándar que permite construir y aplicar una máquina virtual o

máquina paralela, este estándar es llamado PVM (Parallel Virtual Machine). PVM es un conjunto de herramientas y librerías que emulan un entorno de propósito general compuesto de nodos interconectados de distintas arquitecturas. El objetivo es conseguir que ese conjunto de nodos pueda ser usado de forma colaborativa para el procesamiento paralelo.

El modelo en el que se basa PVM es dividir las aplicaciones en distintas tareas. Son los procesos los que se dividen por las máquinas para aprovechar todos los recursos. Cada tarea es responsable de una parte de la carga que conlleva esa aplicación. PVM soporta tanto paralelismo en datos, como funcional o una mezcla de ambos. PVM permite que las tareas se comuniquen y sincronicen con las demás tareas de la máquina virtual, enviando y recibiendo mensajes, muchas tareas de una aplicación pueden cooperar para resolver un problema en paralelo. Cada tarea puede enviar un mensaje a cualquiera de las otras tareas, sin límite de tamaño ni de número de mensajes.

50

El sistema PVM se compone de dos partes. La primera es un demonio, llamado pvmd que

residen en todas los nodos que forman parte de la máquina virtual. Cuando un usuario quiere ejecutar una aplicación PVM, primero crea una máquina virtual para arrancar PVM. Entonces se puede ejecutar la aplicación PVM en cualquiera de los nodos. Muchos usuarios pueden configurar varias máquinas virtuales aunque se mezclen unas con las otras y se pueden ejecutar varias aplicaciones PVM simultáneamente. Cada demonio es responsable de todas las aplicaciones que se ejecutan en su nodo. Así el control está totalmente distribuido excepto por un demonio maestro, que es el primero que se ejecutó a mano por el usuario, los demás nodos fueron iniciados por el maestro y son esclavos. En todo momento siempre hay un pvmd maestro. Por tanto la máquina virtual mínima es de un miembro, el maestro.

La segunda parte del sistema es la librería de PVM. Contiene un repertorio de primitivas que son necesarias para la cooperación entre los procesos o threads de una aplicación. Esta librería contiene rutinas para iniciación y terminación de tareas, envío y recepción de mensajes, coordinar y sincronizar tareas, broadcast, modificar la máquina virtual. Cuando un usuario define un conjunto de nodos, PVM abstrae toda la complejidad que tenga el sistema y toda esa complejidad se ve como una gran computadora de memoria distribuida llamada máquina virtual. Esta máquina virtual es creada por el usuario cuando se comienza la operación. Es un conjunto de nodos elegidos por el usuario. En cualquier momento durante la operación puede elegir nuevos nodos para la máquina virtual. Esto puede ser de gran ayuda para mejorar la tolerancia a fallos pues se tiene unos cuantos nodos de reserva (PVM no tiene migración) por sí alguno de los nodos fallara. O si se ve que un conjunto de nodos de una determinada red están fallando se pueden habilitar nodos de otra red para solucionarlo.

Para conseguir abstraer toda la complejidad de las diferentes configuraciones, soporta la heterogeneidad de un sistema a tres niveles:

• -Aplicaciones: las subtareas pueden estar hechas para aprovechar la arquitectura sobre la que funcionan. Por tanto como se puede elegir en que conjunto de nodos se ejecutarán unas tareas específicas, podemos hacer nuestras aplicaciones con la arquitectura al máximo por lo que se puede optimizar y hacer que funcionen aplicaciones hechas para arquitecturas específicas con PVM.

• -Máquinas: nodos con distintos formatos de datos están soportados, incluyendo arquitecturas secuenciales, vectoriales, SMP.

• -Redes: la máquina virtual puede ser interconectada gracias a distintas tecnologías de red. Para PVM existe una red punto a punto, no fiable y no secuencial. Utiliza UDP e implementa toda la confiabilidad y todas las operaciones básicas de difusión como el broadcast.

Las librerias de PVM, consisten en un conjunto de interfaces que está basado en la

observación de las necesidades de la mayoría de las aplicaciones, que están escritas en C y Fortran. Los enlaces para C y C++ para la librería PVM están implementados como funciones, siguiendo las reglas usadas por la mayoría de los sistemas que usan C, incluyendo los sistemas operativos tipo UNIX. Los enlaces para Fortran están implementados como subrutinas más que funciones.

51

Todas las tareas están identificadas con un único identificador de tarea TID (Task

IDentifier). Los mensajes son enviados y recibidos por TIDs. Son únicos en toda la máquina virtual y están determinados por el pvmd local y no se pueden elegir por el usuario. Varias funciones devuelven estos TIDs (pvm_mytid(), pvm_parent(), etc.)para permitir que las aplicaciones de los usuarios conozcan datos de las otras tareas. Existen grupos nombrados por los usuarios, que son agrupaciones lógicas de tareas. Cuando una tarea se une al grupo, a ésta se le asigna un único número dentro de ese grupo. Estos números empiezan en 0 y hasta el número de tareas que disponga el grupo. Cualquier tarea puede unirse o dejar cualquier grupo en cualquier momento sin tener que informar a ninguna otra tarea del grupo. Los grupos se pueden superponer y las tareas pueden enviar mensajes multicast a grupos de los que no son miembro. Cuando una tarea se quiere comunicar con otra ocurren una serie de cosas, los datos que la tarea ha enviado con una operación send, son transferidos a su demonio local quien decodifica el nodo de destino y transfiere los datos al demonio destino. Este demonio decodifica la tarea destino y le entrega los datos. Este protocolo necesita 3 transferencias de datos de las cuales solamente una es sobre la red. También se puede elegir una política de encaminado directo (dependiente de los recursos disponibles). En esta política tras la primera comunicación entre dos tareas los datos sobre el camino a seguir por los datos son guardados en una caché local. Las siguientes llamadas son hechas directamente gracias a esta información. De esta manera las transferencias se reducen a una transferencia sobre la red. Para comunicarse entre sí, el demonio pvmd, usa UDP ya que es un protocolo más sencillo, sólo consume un descriptor de archivo, y con un simple socket UDP se puede comunicar a todos los demás demonios. Además es muy sencillo colocar temporizadores sobre UDP para detectar fallos de nodo, pvmd o red. La comunicación entre las tareas y los pvmd es mediante TCP puesto que se necesita tener la seguridad de que los datos llegarán. En el caso de que sólo se haga una transferencia ésta es TCP por lo que hay que establecer la conexión primero por lo que realmente tampoco es tan beneficioso. En la figura 21 se puede observar como los distintos métodos de comunicación de PVM.

Figura 21.- Comunicaciones en PVM.

52

Cada nodo tiene una estructura llamada host table. Esta tabla tiene una entrada (host descriptor) por cada nodo de la máquina virtual. El descriptor del nodo mantiene la información de la configuración del host, las colas de paquetes y los buffer de mensajes. Inicialmente la tabla sólo tiene la entrada del nodo maestro. Cuando un nuevo esclavo es incluido a la máquina virtual, la tabla del nodo maestro es actualizado para añadir al nuevo esclavo. Entonces esta nueva información es enviada por broadcast a todos los nodos que pertenezcan a la máquina virtual. De esta manera se actualizan todas las tablas y se mantienen consistentes.

Las aplicaciones pueden ver el hardware como una colección de elementos de proceso virtuales sin atributos que pueden explotar las capacidades de máquinas específicas, buscando posicionar ciertas tareas en los nodos más apropiados para ejecutarlas.

En PVM una vez que un proceso empieza en una determinada máquina seguirá en ella

hasta que se muera. Esto tiene graves inconvenientes y de debe tener en cuenta que las cargas suelen variar , y que, a no ser que todos los procesos que se estén ejecutando sean muy homogéneos entre sí, se está descompensando el cluster. Por lo tanto tenemos unos nodos más cargados que otros y seguramente unos nodos terminen su ejecución antes que otros, con lo que se podrían tener nodos muy cargados mientras otros nodos están libres. Esto lleva a una pérdida de rendimiento general.

Otro problema que presenta PVM, es su implementación a nivel de usuario, donde el tipo

de operaciones de bajo nivel es alto sobre la capa UDP. Esto añade complejidad y aumenta la latencia a las comunicaciones producidas sobre el núcleo del sistema (kernel).

Se necesita un conocimiento amplio del sistema, tanto los programadores como los

administradores tienen que conocer el sistema para sacar el máximo rendimiento de él. No existe un programa que se ejecute de forma ideal en cualquier arquitectura ni configuración de cluster. Por lo tanto para paralelizar correcta y eficazmente se necesita que los programadores y administradores conozcan a fondo el sistema en la etapa de implementación, aunque será necesario conocer detalladamente el problema a resolver para buscar la técnica adecuada para su solución.

El paralelismo es explícito, esto quiere decir que se programa de forma especial para poder

usar las características especiales de PVM. Los programas deben ser reescrito y si a esto agregamos que, es necesario que los desarrolladores conozcan perfectamente PVM, se puede decir que migrar una aplicación a un sistema PVM es un proceso complejo y que consume gran tiempo.

53

2.6 El estudio del rendimiento.

2.6.1 Factores que influyen en el rendimiento

Existen Factores que influyen en el rendimiento de un trabajo o de un proceso, estos factores son importantes vistos desde el punto de vista del tiempo de procesamiento y el número de procesos que deben ejecutarse. El rendimiento de un trabajo depende de los siguientes factores:

1) Hardware 2) Software 3) Contenido del Trabajo 4) Diseño de la aplicación

El hardware condiciona de manera muy importante en rendimiento escalar y vectorial. Este rendimiento, en general, va a depender del número de procesadores escalares o vectoriales y de la potencia del conjunto de instrucciones de la máquina.

Un procesador escalar cuenta con suficientes recursos de hardware para que este pueda realizar más de una instrucción simultáneamente. Un procesador vectorial es diseñado específicamente para realizar de forma eficiente operaciones en las que se ven involucrados elementos de matrices, denominados vectores. Estos procesadores resultan especialmente útiles para ser utilizados en el cálculo científico de alto rendimiento (high performance computing), donde las operaciones con vectores y con matrices son ampliamente utilizadas

El software es también un factor muy importante del rendimiento de un trabajo. Este rendimiento dependerá básicamente de la capacidad de los compiladores vectorizantes y de la biblioteca de subrutinas de que se disponga. El compilador es el encargado de definir la diferencia entre el paralelismo con software y con hardware. Algunas tareas de paralelización las realizarán las librerias y se apoyarán con el compilador y otras las realizará el propio usuario utilizando sus conocimientos de programación.

El contenido del trabajo también es un factor importante que influye en su rendimiento. La

cantidad de operaciones en punto flotante que se realicen es importante, ya que éstas son muy costosas debido a que emplean mucho más tiempo de la ALU que las operaciones en punto fijo y se determinan por :

• El tanto por ciento de código vectorizable • El tanto por ciento de código paralelo

54

Para hacer un modelo de rendimiento aceptable se tienen que revisar muchos parámetros, pero esto no es rentable. Por consiguiente nos conformamos con modelos simplificados para la medida del rendimiento de un sistema. Para obtener un alto rendimiento del sistema es necesario que haya una sintonía entre la capacidad de la máquina y el comportamiento del programa. La capacidad de procesamiento de la máquina es susceptible de mejora con las nuevas tecnologías en hardware y software, además de el auxilio de una administración eficiente de los recursos.

El comportamiento del programa depende básicamente de los siguiente factores:

• a)Diseño del algoritmo • b)Estructuras de datos • c)Eficiencia de los lenguajes • d)Conocimientos del programador • e)Tecnología de los compiladores

Las estructuras de datos proporcionan un alto grado de paralelismo y le condicionan. Así

mismo, los lenguajes y los compiladores son muy importantes ya que la eficiencia de los primeros y la inteligencia de los segundos son de gran importancia para detectar dentro del código aquellas partes que pueden ser paralelizables. Los conocimientos del programador también son muy importantes ya que junto con el diseño del algoritmo, los desarrollos pueden adaptarse mucho mejor al hardware del sistema. El rendimiento de un sistema varía según el programa.

El rendimiento de un sistema, es posible medirlo, utilizando características intrínsecas de la relación entre el sistema y el programa, conociendo:

• La imposibilidad de alcanzar un rendimiento máximo. • Programas y técnicas de BENCHMARKING (Pruebas de desempeño y laboratorio) ligados a la

composición del programa.

Los indicadores del rendimiento de una computadora son una serie de parámetros que conforma un modelo simplificado de la medida del rendimiento de un sistema y son utilizados por los arquitectos de sistemas, los programadores y los constructores de compiladores, para la optimización del código y obtención de una ejecución más eficiente. Dentro de este modelo, estos son los indicadores de rendimiento más utilizados:

2.6.2 Tiempo de respuesta (Turnaround Time)

El tiempo de respuesta desde la entrada hasta la salida, lo que incluye accesos a disco,

memoria y tiempos de CPU. Es la medida más simple del rendimiento. En sistemas multiprogramados no aplica la medida del rendimiento anterior, ya que la máquina comparte el tiempo, se produce solapamiento de entrada y salida del programa con tiempo de procesador en otros programas.

55

Es por eso que se emplea la siguiente medida que es el TIEMPO CPU USUARIO. Los parámetros mas empleados son los siguientes:

• Tiempo de cada ciclo (τ). El tiempo empleado por cada ciclo. Es la constante de reloj del procesador. (segundos).

• Frecuencia de reloj (f) .Es el inverso del tiempo de ciclo. f = 1/τ. (hertz). • Total de Instrucciones (Ic).Es el número de instrucciones a ejecutardentro de un programa.

• Ciclos por instrucción (CPI) .Es el número de ciclos computacionales que requiere cada

instrucción.

• Total de ciclos de reloj en la ejecución de un programa C = Ic * CPI • Tiempo de ejecución de programa (Tp). Es el tiempo que tarda un programa en ejecutarse.

Tp = Ic * CPI * τ = Ic * CPI/f = C/f

• Ciclo de memoria (mc).Tiempo que se tarda en completar una referencia a memoria.

mc = k * τ k�latencia >1

Donde k=número de instrucciones.

• Apartir de las definiciones anteriores, las fórmulas del Ciclo por instrucción (CPI) y del tiempo de ejecución (Tp) se pueden utilizar de la siguiente forma:

CPI = p + mr * k (ciclos/instrucción)

Donde el total de ciclos del procesador (p), referencias a memoria por ciclo (mr).

Tp = Ic * CPI * τ = Ic * (p + mr * k) * τ (nanosegundos)

En la tabla 7 se muestra la relación entre factores de rendimiento y atributos del sistema

Ic p mr K τ Arquitectura X

Tecnología compilador

X X X

Implantación y control CPU

X X

Jerarquía memoria

X X

56

Tabla 7 .Relación entre factores de rendimiento y atributos del sistema

En la tabla anterior se muestra la relación entre los factores del rendimiento (Ic, p, mr, k y τ) y algunas características del sistema (arquitectura, tecnología del compilador, implantación y control CPU y jerarquía de la memoria caché). a) Relación MIPS (millones de instrucciones por segundo). Podemos utilizar un nuevo modelo del rendimiento deducido a partir del parámetro MIPS. Es una medida de la velocidad de la computadora, que depende de la frecuencia del reloj (f), del total de instrucciones (Ic), y de los ciclos por instrucción (CPI).

MIPS = Ic (Tp * 106) = (Ic * f) / (Ic * CPI * 106) = f / (CPI * 106) MIPS = f / (C/Ic * 106) = (f * Ic) / (C * 106) [ instrucciones / segundo]

A partir de la definición de MIPS se puede utilizar la siguiente fórmula para el tiempo de CPU:

Tiempo CPU = Tp = (Ic * 10-6)/MIPS (segundos)

b) THROUGHPUT del sistema (Ws).Es la cantidad de trabajo por unidad de tiempo que realiza el sistema. Total de programas (resultados) ejecutados por el sistema en unidad de tiempo.

Ws (programas / segundo)

c) THROUGHPUT de CPU (Wp).Es la cantidad de trabajo de la CPU. Wp = f / (Ic * CPI) = (MIPS * CPI * 106)/(Ic * CPI) = (MIPS * 106)/Ic (programas/segundo)

2.7 Algoritmos paralelos.

2.7.1 Método De Diferencias Finitas

El método de diferencias finitas es una clásica aproximación para encontrar la solución

numérica de las ecuaciones que gobiernan el modelo matemático de un sistema continuo. Es valioso familiarizarse con esta aproximación porque tal conocimiento reforzará la comprensión de los procedimientos de elementos finitos. Básicamente, en una solución por diferencias finitas, las derivadas son reemplazadas por aproximaciones en diferencias finitas, convirtiendo entonces un problema de ecuaciones diferenciales en un problema algebraico fácilmente resoluble por medios comunes (especialmente matriciales).

57

2.7.2 Método de expansión de Taylor

El método de expansión de Taylor es una forma alternativa de obtener aproximaciones de

diferencia. Este método no sólo deduce las fórmulas de diferencia sistemáticamente, sino que también deduce los términos de error. Para una derivada de p-ésimo orden, el número mínimo de puntos de datos requeridos para deducir una aproximación de diferencia es p+1, así por ejemplo una aproximación de diferencia para la primera derivada de una función necesita por lo menos de dos puntos de datos. Para la deducción de la aproximación de diferencia para fi´=f´(xi) en términos fi= f(xi) ^ fi+1 = f(xi+1). La expansión de Taylor de fi+1 alrededor de xi es:

[1] Resolviendo la ecuación anterior para la primera derivada, tenemos:

Κ−′′′⋅−′′⋅−

−=′ +

iiii

i fh

fh

h

fff

62

21

[2]. Si ignoramos todos los términos con excepción del primero del miembro derecho de la ecuación 2, obtendremos la aproximación por diferencia hacia adelante. Los términos que se ignoran constituyen el error de truncado, representado por el término inicial, -(h/2).fi´´. Los demás términos desaparecen más rápidamente que el inicial cuando h disminuye. La aproximación de diferencia hacia adelante, con el error de truncado incluido, se expresa como:

E

h

fff ii

i +−

=′ +1

[3], dónde if

hE ′′⋅−≈

2 El término E indica que el error es aproximadamente proporcional al intervalo de la retícula h. El error también es proporcional a la segunda derivada .fi´´.

De la misma manera podemos expandir fi-1 alrededor de xi en la forma:

[4] Resolviendo nuevamente para la primera derivada, tenemos:

Κ−′′′⋅−′′⋅+

−=′ −

iiii

i fh

fh

h

fff

62

21

y E

h

fff ii

i +−

=′ −1

[5] dónde if

hE ′′⋅≈

2

58

La aproximación anterior se denomina de diferencia hacia atrás.

Tomemos ahora ambas aproximaciones y restemos 4 de 1:

Κ+′′′⋅⋅+′⋅⋅=− −+ iiii fhfhff 311 3

12

[6] De la anterior expresión se ha eliminado el término fi´´. Resolviendo para fi´, obtenemos

Κ+′′′⋅⋅−⋅

−=′ −+

iii

i fhh

fff 211

6

1

2 [7]. Con el término de error incluido, la aproximación de diferencia central se expresa como

Eh

fff ii

i +⋅

−=′ −+

211

[8], dóndeifhE ′′′⋅⋅−≈ 2

6

1

.

Resulta interesante observar que gracias a la cancelación del término fi´´, el error de la aproximación es proporcional al cuadrado de h y no a h. Entonces, reduciendo h reducimos el error con mayor rapidez que con las otras aproximaciones.

De forma similar podemos obtener aproximaciones de diferencia para derivadas superiores, pero la deducción se hace cada vez más laboriosa al aumentar tanto el número de términos como el orden de la derivada.

Sería útil por lo tanto el desarrollo de algoritmos de cómputo que permitan hallar automáticamente la aproximación de diferencia para un conjunto dado de datos.

No obstante, a continuación muestro las expresiones de diferencias, cuyo uso es frecuente.

a) Primera derivada.

Aproximaciones de diferencia hacia adelante

IV

iiiii

i

iiii

i

iii

i

fhEEh

fffff

fhEEh

ffff

fhEEh

fff

⋅⋅−≈+⋅

⋅−⋅−⋅−⋅=′

′′′⋅⋅≈+⋅

⋅−⋅+−=′

′′⋅⋅−≈+−

=′

+++

++

+

3123

212

1

4

1;

6

1118923

1;

2

342

1;

Aproximaciones de diferencia hacia atrás

IV

iiiii

i

iiii

i

iii

i

fhEEh

fffff

fhEEh

ffff

fhEEh

fff

⋅⋅≈+⋅

⋅+⋅−⋅+⋅−=′

′′′⋅⋅≈+⋅

⋅+⋅−+=′

′′⋅⋅≈+−

=′

−−−

−−

−

3123

212

1

4

1;

6

1118923

1;

2

342

1;

Aproximaciones de diferencia centrales

59

V

iiiii

i

iii

i

fhEEh

fffff

fhEEh

fff

⋅⋅≈+⋅

+⋅−⋅+−=′

′′′⋅⋅−≈+⋅

−=′

−−++

−+

42112

211

30

1;

12

886

1;

2

b) Segunda derivada.

Aproximaciones de diferencias hacia adelante

IV

iiiii

i

iiii

i

fhEEh

fffff

fhEEh

ffff

⋅⋅≈+⋅+⋅−⋅+−

=′′

′′′⋅≈++⋅−

=′′

+++

++

22

123

212

12

11;

254

;2

Aproximaciones de diferencia hacia atrás

IV

iiiii

i

iiii

i

fhEEh

fffff

fhEEh

ffff

⋅⋅≈+⋅+⋅−⋅+−

=′′

′′′⋅≈++⋅−

=′′

−−−

−+

22

213

212

12

11;

254

;2

Aproximaciones de diferencia centrales

VI

iiiiii

i

IV

iiii

i

fhEEh

ffffff

fhEEh

ffff

⋅⋅≈+⋅

−⋅+⋅−⋅+−=′′

⋅≈++⋅−

=′′

−−++

−+

42

2112

22

11

90

1;

12

16301612

1;

2

c) Tercera derivada.

Aproximaciones de diferencia hacia adelante

IV

iiiii

i fhEEh

fffff ⋅−≈+

−⋅+⋅−=′′′ +++ 2

3123

2

3;

33

Aproximaciones de diferencia hacia atrás

IV

iiiii

i fhEEh

fffff ⋅≈+

−⋅+⋅−=′′′ −−− 2

3321

2

3;

33

Aproximaciones de diferencia centrales

V

iiiii

i fhEEh

fffff ⋅−≈+

⋅

⋅−⋅+⋅−=′′′ −−++ 2

32112

4

1;

2

222

60

2.7.3 Aproximación De Diferencia Para Derivadas Parciales.

Las fórmulas de aproximación de diferencia para derivadas parciales de funciones

multidimensionales son esencialmente iguales a las de diferenciación de funciones unidimensionales. Consideremos una función bidimensional f(x,y). La aproximación de diferencia para la derivada parcial con respecto a x, por ejemplo, puede deducirse fijando y en un valor constante y0 y considerando f(x,y0) como una función unidimensional. Por tanto, las aproximaciones de diferencia hacia adelante, central y hacia atrás para éstas derivadas parciales se pueden escribir, respectivamente:

( ) ( )

( ) ( )( )

( ) ( )xE

x

yxxfyxf

x

ff

xEx

yxxfyxxf

x

ff

xEx

yxfyxxf

x

ff

x

x

x

∆∝→∆

∆−−≈

∂

∂=

∆∝→∆⋅

∆−−∆+≈

∂

∂=

∆∝→∆

−∆+≈

∂

∂=

0000

20000

0000

,,2

,,

,,

[9].

Las aproximaciones de diferencia central para las segundas derivadas de ( )yxf , en ( )00 , yx están dadas por:

( ) ( ) ( )

( )( )

( ) ( ) ( )

( )

( ) ( )

( ) ( )yx

yyxxfyyxxf

yx

yyxxfyyxxf

yx

ff

y

yyxfyxfyyxf

y

ff

xEx

yxxfyxfyxxf

x

ff

xy

yy

xx

∆⋅∆

∆−∆−−∆−∆+−+

∆⋅∆

∆+∆−−∆+∆+≈

∂⋅∂

∂=

∆

∆−+⋅−∆+≈

∂

∂=

∆∝→∆

∆−+⋅−∆+≈

∂

∂=

0000

00002

2000000

2

2

2

2000000

2

2

,,

,,

,,2,

,,2,

[10].

61

CAPÍTULO 3. DISEÑO Y CONSTRUCCIÓN DE LA MÁQUINA PARALELA.

3.1 Pensamiento y la filosofía de construcción

El pensamiento inicial en la construcción de una máquina paralela se basa en la

mentalidad de hacer mucho a través de trabajos pequeños.Existe un cuento que puede indicarnos el comportamiento de una máquina paralela, el famoso cuento de la sopa de piedras de Marcia Brown donde es posible realizar una sopa de piedras con la cooperación de un pueblo, la moraleja de este cuento es inmediata: Con la cooperación se alcanzan resultados notables, aun cuando se parta de contribuciones pequeñas, que a simple vista parecen o son insignificantes.

La frase “Divide y vencerás”[11] nos indica que para llegar a un objetivo complicado deberemos de partir de diferentes objetivos más pequeños los cuales harán que podremos alcanzar ese objetivo o fin. La construcción de la máquina paralela deberá de seguir esta filosofía para poder realizar miles de millones de cálculos por segundo. Para lograr esto deberemos de explotar el procesamiento en paralelo con numerosos microprocesadores que trabajan en conjunto para resolver problemas de la complejidad de un objetivo en común.

Es posible construir una máquina paralela de una manera muy económica, en la cual se

sea posible hacer una interconexión de computadoras personales utilizando algún programa que permita resolver problemas científicos de procesamiento paralelo.

La idea de la interconexión de computadoras no constituía, en sí misma, ninguna novedad. En los años cincuenta y sesenta, la fuerza área norteamericana tendió la red SAGE, una red de computadoras de válvulas de vacío (bulbos) para protegerse de un inesperado ataque nuclear soviético. A mediados de los ochenta, Digital Equipment Corporation acuñó el término "cluster" (agrupación) al integrar sus minicomputadoras de gama media VAX para formar un sistema mayor.

A principios de los noventa, los científicos empezaron a plantearse la creación de agrupaciones de computadoras inducidas en parte por el bajo costo asociado a la producción en masa de sus microprocesadores. Pero, lo que reforzó el atractivo de esa idea fue la caída del precio de Ethernet, la técnica dominante en la interconexión de computadoras en redes de área local.

Los avances en la programación facilitaron también el apoyo para formar diversas

agrupaciones de varias computadoras. En los años ochenta, UNIX se consolidó como el sistema operativo dominante para la computación científica y técnica. Por desgracia, los sistemas operativos instalados en las computadoras comerciales carecían de la potencia y de la flexibilidad, pero en 1991 un universitario finlandés, Linus Torvalds, creó Linux, un sistema operativo similar a UNIX y que funcionaba en las computadoras personales; Torvalds permitió que su sistema operativo fuera accesible de manera gratuita en Internet. 11 La vieja frase atribuida a Julio Cesar, “Divide et impera” , usada por Napoleón Bonaparte

62

La primera agrupación de computadoras en arreglo (cluster) nació en 1994 en el Centro

Goddard de Vuelos Espaciales. La NASA, a la que pertenece dicha entidad, andaba buscando una solución para los complicados problemas computacionales asociados a las ciencias de la Tierra y del espacio. Necesitaba una máquina capaz de alcanzar un Gigaflop, es decir, realizar mil millones de operaciones de punto flotante por segundo. En aquel entonces, una supercomputadora comercial capaz de alcanzar esta velocidad venía a costar un millón de dólares, y dedicarlo a un sólo grupo de investigadores resultaba un gasto imposible.

Sterling, investigador del centro Goddard de la NASA decidió adentrarse en el sistema de

agrupaciones de computadoras y Con Donald J. Becker, compañero suyo, conectó 16 computadoras, cada una de las cuales contenía un microprocesador Intel 486. Emplearon el sistema Linux y una red Ethernet estándar. Para aplicaciones científicas, esta agrupación de computadoras alcanzaba los 70 Megaflops, o sea, 70 millones de operaciones de punto flotante por segundo. Aunque nos parezca poco de acuerdo con los estándares actuales, esa velocidad no era mucho menor que la de algunas supercomputadoras comerciales de aquel momento. La agrupación se construyó, además, con 40.000 dólares, la décima parte del precio de una máquina comercial con características similares en 1994.

Los investigadores de la NASA lo llamaron "Beowulf", en referencia al joven héroe de la leyenda medieval que derrotó al gigante Grendel arrancándole uno de sus brazos. Con ese nombre se designa ahora toda agrupación económica e integrada por computadoras comerciales.

El algoritmo principal con el que se rige la computación en paralelo es el principio del “divide y vencerás”. Un sistema de procesadores en paralelo secciona un problema complejo en múltiples tareas de componentes menores. Estas tareas se asignan a los diferentes nodos del sistema que realizan sus tareas de manera simultánea. De acuerdo a la naturaleza del problema la programación y el desempeño dependerán del rendimiento del procesamiento en paralelo ya que depende su alto rendimiento de factores como los tiempos de retardo entre la información que viaja de una computadora a otra, la velocidad de la red y estilo de programación utilizado. Uno de los factores de gran importancia es la frecuencia que tendrán los nodos para comunicarse entre sí y de esta manera coordinar su trabajo y compartir resultados parciales.

Hay problemas que requieren dividirse en un número pequeño de tareas minúsculas las

cuales necesitan un intercambio frecuente de información, este tipo de tareas no son adecuados para procesado paralelo. Pero los problemas menos sutiles sí pueden repartirse en porciones mayores. Y al no pedir tanta interconexión entre nodos, permiten un procesamiento correcto y con el mínimo de errores.

A la hora de crear una máquina paralela se deberá de decidir entre varios aspectos esenciales que afectan el diseño del sistema. Un factor importante es el que podamos usar cualquier tipo de red para conectar las computadoras.

63

3.2 Aspectos generales de la programación en paralelo

La programación en paralelo requiere habilidad e ingenio para determinar un tiempo único

de disparo (tiempo temporal cero) de donde parten todos los procesos iniciales. Puede constituir un reto mayor que la propia conexión de las computadoras para crear el sistema Beowulf. Por modelo de programación es acostumbrado recurrir a aplicaciones del tipo cliente servidor. En él, un nodo, que actúa como cliente, dirige el procesado desarrollado por otro o varios más nodos servidores. Es posible que se ejecute el mismo software en todos los nodos que integran la máquina paralela y se asignarán secciones diferentes del código a los nodos cliente, el servidor y cada microprocesador de la agrupación. Por lo que sólo se ejecuta la sección apropiada para su tarea. Los errores de programación pueden tener consecuencias importantes y provocar un descontrol general en la cadena general y en cada nodo, cuando la falla se presenta en un nodo, ésta se transmite a los demás. La búsqueda del error en el código puede resultar una tarea muy complicada y muy frustrante.

Antes de poder realizar cualquier tipo de consideración inicial para la construcción de la

máquina paralela considerada en este documento, es preciso determinar cuales son los aspectos escenciales para su correcta construcción. Sobre estos aspectos hablaremois a continuación.

3.2.1 Tipo de Hardware

Una agrupación homogénea de computadoras en la que todas las computadoras tienen los mismos componentes y microprocesadores permite simplificar la programación y la administración de los nodos mas no deberá de ser requisito imprescindible.

La máquina paralela para cumplir con los objetivos del presente trabajo, deberá soportar una mezcla de microprocesadores de tipos y velocidades diferentes Ya que se utilizará el equipo que no se encuentre activo y sea posible conseguir por estar en desuso o que nos proporcionen.

El tipo de hardware utilizado, representa un aspecto complicado en el diseño, ya que el fin es el de buscar la distribución del trabajo para su procesamiento en paralelo en las computadoras que conforman el sistema. Dado que la máquina paralela puede tener procesadores de diferentes arquitecturas y de velocidades muy distintas, no podemos repartir de una forma homogénea la carga de trabajo entre los nodos: si actuáramos así, las máquinas más rápidas estarían ociosas durante largos períodos de tiempo a la espera de que las computadoras más lentas, acaben su procesamiento. Por esto el uso de programas de código abierto es muy importante, ya que nos permite modificar el origen del código para adaptarlo a lo que sea más apropiado en cada caso en particular.

En este tipo de organización es importante hacer la distribución de la carga, las

computadoras más rápidas realizan la mayor parte del trabajo, aunque las máquinas lentas contribuyen al funcionamiento del sistema.

El microprocesador es uno de los componentes más importantes, ya que en su velocidad y

capacidad es posible determinar la calidad del resto de los elementos. El Microprocesador, para entendernos, y de una manera simple, es el cerebro de la computadora. Es definido como un chip en cuyo interior se encuentran millones de transistores que, combinándose entre ellos, permiten al chip realizar la tarea que tenga encomendada.

64

La unidad de medida que se emplea para expresar la velocidad del microprocesador es el hertz (Hz), aunque la velocidad real de un procesador depende de otros factores, también nos indica más o menos la cantidad de instrucciones que el microprocesador puede realizar en un segundo.

Cada computadora, cuenta con una unidad aritmética, una unidad lógica y una unidad de control. Todas estas unidades en conjunto trabajan sincronizadamente controladas por los pulsos de un reloj maestro que coordina la ejecución de todas las operaciones que se realizan por parte del microprocesador. Cuenta además con una antememoria (memoria cache), la cual es una memoria de gran velocidad que sirve al microprocesador para tener los datos recientes que previsiblemente se utilizarán en próximas operaciones sin tener que acudir a la memoria RAM, reduciendo así el tiempo de espera.

La computadora en algunos casos podría contar con un coprocesador matemático, este componente es la parte del microprocesador especializado en los cálculos matemáticos, aunque también formar parte de otro circuito.

Acontinuación menciono algunos años clave importantes en la historia de los microprocesadores. El 17 de octubre Intel anunciaba la aparición del procesador 80386 DX, el primero en poseer una arquitectura de 32 bits, lo que suponía una velocidad a la hora de procesar las instrucciones realmente importantes con respecto a su predecesor. Dicho procesador contenía en su interior alrededor de los 275000 transistores, más de cien veces los que tenía el primer 4004 después de tan solo 14 años. El reloj llegaba a un máximo de 33 MHz, y era capaz de direccionar 4 GB de memoria.

En 1988, Intel desarrollaba un poco tarde un sistema sencillo de actualizar los antiguos 80286, gracias a la aparición del 80386 SX, que sacrificaba el bus de datos para dejarlo en uno de 16 bits, pero a menor coste. Estos procesadores irrumpieron, con la explosión del entorno gráfico Windows desarrollado por Microsoft unos años antes pero que no había tenido la suficiente aceptación por parte de los usuarios.

El 10 de Abril de 1989, aparecía el Intel 80486 DX, de nuevo con tecnología de 32 bits, y como novedades principales la incorporación del caché de primer nivel (L1), en el propio chip, lo que aceleraba enormemente la transferencia de datos de este caché al procesador, así como la aparición de coprocesador matemático también integrado en el procesador, dejando por tanto de ser una opción como lo era en los anteriores 80386. Dos cambios que unidos al hecho de que por primera vez se sobrepasaban el millón de transistores usando la tecnología de una micra (aunque en la versión de este procesador que iba a 25 MHz, se usó ya la tecnología de 0,8 micras), hacían posible la aparición de programas de calidad sorprendente, entre los cuales destacaron los juegos.

Con una arquitectura real de 32 bits, se usaba de nuevo la tecnología de 0.8 micras, con lo que se lograba construir más unidades en el menor espacio. Los resultados no se hicieron esperar y las compañías empezaron aunque de forma tímida a lanzar programas y juegos exclusivamente para el Pentium.

65

La aparición, el 27 de marzo de 1995, del procesador Pentium Pro, supuso para los servidores de la red y las estaciones de trabajos un aire nuevo, tal y como ocurriera con el Pentium en el ámbito doméstico. La potencia de este nuevo procesador no tenía comparación hasta entonces, gracias a la arquitectura de 64 bits y el empleo de una tecnología revolucionaria como es la de 0.32 micras, lo que permitía la inclusión de 5,500.000 transistores en su interior. El procesador contaba con un segundo chip en el mismo encapsulado que se encargaba de mejorar la velocidad de la memoria caché, lo que resultaba en un incremento del rendimiento sustancioso. Las frecuencias de reloj se mantenían como límite por arriba de 200 MHz, partiendo de un mínimo de 150 MHz. Un procesador que en principio no tenía muchos avisos de saltar al mercado doméstico, puesto que los procesadores Pentium MMX, parecían cubrir de momento todas las necesidades de este campo. El Pentium II, fue simplemente un nuevo ingenio que se sumó a las tecnologías del Pentium Pro con el MMX. Como resultado, el Pentium II fue el procesador más rápido de cuantos a comerciado Intel, hasta principios de 1999. El Pentium II cuenta con 256 KB de caché secundaria integrados en el núcleo del micro su rendimiento mejora en todo tipo de aplicaciones.

La última apuesta de Intel, que representa todo un cambio de arquitectura; pese a su

nombre, internamente poco o nada tiene que ver con otros miembros de la familia Pentium.Se trata de un microprocesador peculiar: su diseño permite alcanzar mayores velocidades, con menos potencia por cada MHz que los micros anteriores; es decir, que un Pentium 4 a 1,3 GHz puede ser mucho más lento que un Pentium III a "sólo" 1 GHz. Para ser competitivo, el Pentium 4 debe funcionar a 1,7 GHz o más.

Ha habido muchos cambios en el campo de los discos duros. De más antiguos del tamaño de una caja de zapatos y de capacidades ridículas (vistas desde hoy) hasta discos duros compactos y reducidos con capacidades 400 veces mayores. El tiempo de acceso es el parámetro más usado para medir la velocidad de un disco duro, y lo forman la suma de dos factores: el tiempo medio de búsqueda y la latencia; el primero es lo que tarde el cabezal en desplazarse a una pista determinada, y el segundo es el tiempo que emplean los datos en pasar por el cabezal.

Si se aumenta la velocidad de rotación, el tiempo de latencia se reduce; en antiguas

unidades era de 3.600 rpm (revoluciones por minuto), lo que daba un tiempo de latencia de 8,3 milisegundos. La mayoría de los discos duros actuales giran ya a 7.200 rpm, con lo que se obtienen 4,17 micro segundos de tiempo de latencia. Y actualmente, existen discos de alta gama aún más rápidos, hasta 10.000 rpm.

El controlador del Disco duro, es un componente electrónico que maneja el flujo de datos entre el sistema y el disco, es directamente responsable de factores como el formato en que se almacenan los datos, su tasa de transferencia y su velocidad. Los primeros discos duros eran administrados por controladores ST506, un estándar creado por la empresa Seagate. Dentro de esta norma se implementaron los modos MFM (Modified Frequency Modulation) y RLL (Run Length Limited), dos sistemas para el almacenamiento de datos que, si bien diferentes en su funcionamiento, a nivel físico y externo del disco presentaban la misma apariencia.

66

La Interfase ESDI (Enhanced Small Devices Interfase) (interfaz mejorada para dispositivos pequeños), permitió elevar el radio de transferencia a 10 Mbits por segundo. Asimismo, se incluyó un pequeño buffer de sectores que permitía transferir pistas completas en un único giro o revolución del disco, se trató de una tecnología de transición, ya que comercialmente no fue muy bien aceptada.

El estándar IDE (Integrated Drive Electronics), fue creado por la firma Western Digital, curiosamente por encargo de Compaq para una nueva gama de computadoras personales. Su característica más representativa era la implementación de la controladora en el propio disco duro, de ahí su denominación. Desde ese momento, únicamente se necesita una conexión entre el cable IDE y el Bus del sistema, siendo posible implementarla en la placa. Se eliminó la necesidad de disponer de dos cables separados para control y datos, bastando con un cable de 40 hilos desde el bus al disco duro. Se estableció también el término ATA (AT Attachment) que define una serie de normas a las que deben acogerse los fabricantes de unidades de este tipo.

IDE permite transferencias de 4 Mb por segundo. La interfaz IDE supuso la simplificación

en el proceso de instalación y configuración de discos duros, y estuvo durante un tiempo a la altura de las exigencias del mercado. La interfaz EIDE o IDE mejorado, propuesto también por Western Digital, aumenta su capacidad, hasta 8,4 Gb, y la tasa de transferencia empieza a subir a partir de los 10 Mb. por segundo, según el modo de transferencia usado. Además, se implementaron dos sistemas de traducción de los parámetros físicos de la unidad, de forma que se pudiera acceder a superiores capacidades. Estos sistemas, denominados CHS y LBA aportaron ventajas, ya que con mínimas modificaciones se podían acceder a las máximas capacidades permitidas.

El número de unidades que podían ser instaladas al mismo tiempo aumentó a cuatro, para

esto se obligó a los fabricantes de sistemas y de BIOS (Basic input output system.- Sistema basico de entrada y salida) a soportar los controladores secundarios, se habilitó la posibilidad de instalar unidades CD-ROM y de cinta.

Prácticamente todos los discos duros incluyen una memoria de paso (buffer), en la que almacenan los últimos sectores leídos ésta que puede ser desde 2 Kb hasta 512 Kb, es un factor muy importante que afecta al rendimiento. Se le llama caché cuando incluyen ciertas características de velocidad; concretamente, los procesos se optimizan cuando el sistema vuelve de una operación de copiado de datos a la unidad sin esperar a que ésta haya finalizado. También utilizan otra técnica diferente donde la unidad informa de la finalización de una operación de escritura en el momento de recibir los datos, antes de comenzar a grabarlos en el disco.

La interfaz SCSI (Small Computer System Interfase) ha sido tradicionalmente relegada a tareas y entornos de ámbito profesional, en los que priva más el rendimiento, la flexibilidad y la fiabilidad. Para empezar, SCSI es una estructura de bus separada del bus del sistema. De esta forma, evita las limitaciones propias del bus del PC. Además, en su versión más sencilla permite conectar hasta 7 dispositivos SCSI (serían 8 pero uno de ellos ha de ser la propia controladora) en el equipo. Las ventajas no están limitadas al número de periféricos sino también a su tipo: se puede conectar prácticamente cualquier dispositivo (escáner, impresoras, CD-ROM, unidades removibles, etc.) siempre que cumplan con esta norma.

Otra enorme ventaja de SCSI es su portabilidad; esto quiere decir que podemos conectar nuestro disco duro o CD-ROM a computadoras Macintosh, Amiga, etc., que empleen también la norma SCSI. Un detalle a resaltar que todos los periféricos SCSI son inteligentes, es decir, cada uno posee su

67

propia ROM donde almacena sus parámetros de funcionamiento. En especial, es la controladora el dispositivo más importante de la cadena SCSI, que al poseer su propia BIOS puede sobrepasar limitaciones de la ROM BIOS del sistema.

Posiblemente lo que hace destacar a SCSI en su rendimiento, bastante superior a IDE , es no depender del bus del sistema. No obstante, no todo iba a ser ventajas: SCSI es más caro que IDE, y en la mayoría de las ocasiones, más complejo de configurar. Considerando construir una maquina paralela formada con 8 computadoras proporcionadas por el CIDETEC-IPN, me es posible establecer el siguiente hardware:

• 8 tarjetas madre 486 con un procesador • 8 procesadores de velocidad variable • 8 módulos de memoria tamaño variable • 8 Discos duros de mínimo 1 GB. • 8 gabinetes. • 8 fuente de poder tipo XT • 8 Cables IDE. • 8 tarjetas de video. • 1 teclado • Monitor Samsung 14 pulgadas.

3.2.2 Tipo de red de Comunicación

El tipo de red que deberá de selecionarsetiene mucho que ver con las características en

precios , eficiencia y operación y velocidad. Ethernet tiene un rendimiento de 10 Mbps y usa un método de acceso por detección de portadora (CSMA/CD). El IEEE 802.3 también define un estándar similar con una ligera diferencia en el formato de las tramas. Todas las adaptaciones del estándar 802.3 tienen una velocidad de transmisión de 10 Mbps con la excepción de 1Base-5, el cual transmite a 1 Mbps pero permite usar grandes tramos de par trenzado. Las topologías más usuales son: 10Base-5; 10Base-2 y 10Base-T, donde el primer número del nombre señala la velocidad en Mbps y el número final a los metros por segmento (multiplicandose por 100). Base viene de banda base (baseband) y Broad de banda ancha (broadband).

Ethernet e IEEE 802.3 especifican tecnologías muy similares, ambas utilizan el método de acceso al medio CSMA/CD, el cual requiere que antes de que cualquier estación pueda transmitir, debe escuchar la red para determinar si actualmente está en uso. Si es así, la estación que desea transmitir espera y si la red no está en uso, la estación transmite.

En CSMA/CD todos los nodos tienen acceso a la red en cualquier momento, una colisión ocurrirá cuando dos estaciones detectaron silencio dentro de la red y enviaron datos al mismo tiempo, en este caso ambas transmisiones se dañan y las estaciones deben transmitir algún tiempo después (acceso aleatorio).

68

Como ya lo hemos dicho Ethernet utiliza el método de acceso al medio CSMA/CD (Carrier

Sense Multiple Access with Collision Detection). Es CSMA ya que múltiples computadoras pueden acceder simultáneamente al cable Ethernet y determinar si se encuentra activo o no, simplemente escuchando si la señal está presente, por otro lado CD “detección de colisión” se refiere a que cada transceptor monitorea el cable mientras está transfiriendo para verificar que una señal externa no interfiera con la suya.

El estándar 10Base-T ofrece muchas de las ventajas del Ethernet sin la necesidad de usar

el caro cable coaxial. Además permite una topología en estrella o distribuida para grupos de estaciones en departamentos u otras áreas. Parte de la especificación 10Base-T busca la compatibilidad con otros estándares 802.3 del IEEE. Esto facilita la transición de un medio a otro; las placas Ethernet ya instaladas se pueden aprovechar si pasamos de coaxial a par trenzado. La siguiente figura muestra una red simple 10Base-T. La especificación 10Base-T incluye una característica de comprobación del cable llamada comprobación de integridad del enlace. Con esta prestación, el sistema comprueba constantemente la conducción del par trenzado para detectar circuitos abiertos y cortocircuitos. El control se mantiene desde un punto central. Cuenta con las siguientes ventajas:

1. Tolerante a fallas. 2. Fácil ubicación de fallas. 3. Fácil de trasladar o cambiar. 4. Uso de cable de par trenzado blindado.

Desventajas:

1. Limitación de distancias. 2. Sensible al ruido.

3.2.3 El sistema operativo.

El programa base fundamental de todos los programas de sistema, es el Sistema Operativo,

que controla todos los recursos de la computadora y proporciona la base sobre la cual pueden escribirse los programas de aplicación.

Con las primeras computadoras, era algo muy complicado ser programador, no sólo

porque los lenguajes de programación no habían evolucionado sino porque se debía manejar la computadora desde la consola y la consola en aquellos tiempos significaba un gran sistema de interruptores. Afortunadamente, esto ha ido cambiando y se lo debemos, en parte, a que han nacido y evolucionado los Sistemas Operativos. Como también lo han hecho las máquinas, los lenguajes de programación e incluso las ideas.

69

Un Sistema Operativo es un programa que actúa como intermediario entre el usuario y el hardware de una computadora, es el instrumento indispensable para hacer de la computadora un objeto útil. Su propósito es proporcionar un entorno en el cual el usuario pueda ejecutar programas. El objetivo principal de un Sistema Operativo es, lograr que el sistema de computación se emplee de manera eficiente y se administren los recursos eficientemente.

Entre las principales funciones del sistema operativo están:

1. Administración de recursos de la computadora. Su función es la de administrar los dispositivos de hardware en la computadora.

2. Control de lo que hace la computadora y de cómo lo hace. Las actividades principales que se

realizan van enfocadas a controlar los datos y los programas, administrar y mantener los sistemas de archivo de disco.

3. Permitir la comunicación usuario máquina. Permite proporcionar ya sea una interfaz de línea de

comando o una interfaz gráfica al usuario, para que este último se pueda comunicar con la computadora.

Con el paso del tiempo, los Sistemas Operativos fueron clasificándose de diferentes maneras,

dependiendo del uso o de la aplicación que se les daba. A continuación se mostrarán diversos tipos de Sistemas Operativos que existen en la actualidad, con algunas de sus características.

• Sistemas operativos por lotes. Se reúnen todos los trabajos comunes para realizarlos al mismo tiempo, evitando la espera de dos o más trabajos como sucede en el procesamiento en serie. Estos sistemas son de los más tradicionales y antiguos, y fueron introducidos alrededor de 1956 para aumentar la capacidad de procesamiento de los programas.

• Sistemas operativos de tiempo real. Son aquellos en los cuales no tiene importancia el usuario

sino los procesos. Por lo general, están sub utilizados sus recursos con la finalidad de prestar atención a los procesos en el momento que lo requieran. Se utilizan en entornos donde el tiempo de respuesta es critico.

• Sistemas operativos de multiprogramación o multitarea. Se distinguen por sus habilidades para

poder soportar la ejecución de dos o más trabajos activos (que se están ejecutado) al mismo tiempo. Esto trae como resultado que la Unidad Central de Procesamiento (CPU) siempre tenga alguna tarea que ejecutar, aprovechando al máximo su utilización.

• Sistemas operativos de tiempo compartido. Permiten la simulación de que el sistema y sus

recursos son todos para cada usuario. El usuario hace una petición a la computadora y ésta la procesa tan pronto como le es posible. La respuesta aparecerá en la terminal del usuario.

• Sistemas operativos paralelos. En estos tipos de Sistemas Operativos se pretende que cuando

existan dos o más procesos que compitan por algún recurso se puedan realizar o ejecutar al mismo tiempo.

70

• Sistemas operativos distribuidos. Permiten distribuir trabajos, tareas o procesos entre un

conjunto de procesadores. Puede ser que este conjunto de procesadores esté en un equipo o en diferentes, (en este caso es transparente para el usuario). Los sistemas distribuidos deben de ser muy confiables, ya que si un componente del sistema se descompone otro componente debe de ser capaz de reemplazarlo.

• Sistemas operativos de red. Son aquellos sistemas que mantienen a dos o más computadoras

unidas a través de algún medio de comunicación (físico o no) con el objetivo primordial de poder compartir los diferentes recursos y la información del sistema.

3.3 Elección de componentes para la construcción de la maquina paralela

El sistema operativo considerado para la construcción de la máquina paralela es LINUX

Mandrake versión 9.2 ya que es de costo limitado o bien casi ningún costo, de no pagar licencias y ser de libre distribución, además de tener múltiples ventajas relacionadas a un excelente desempeño y fortaleza en servicios e interfaz gráfica simple. Estas ventajas son las siguientes: El sistema operativo Linux Mandrake versión 9.2 (codename: Bamboo) es un sistema más avanzados y potente con relación a los sistemas Linux disponibles hoy en día, con características de vanguardia como Apache 2, redimensionado de particiones NTFS de disco duro, control de energía ACPI, soporte de red zeroconf, soporte WI-FI. Linux Mandrake 9.2 da a los usuarios un nivel de comodidad sin igual con un instalador gráfico simplificado, un tema de escritorio Mandrake Galaxy completamente nuevo, impresionantes fuentes anti-alias por supuesto, los nuevos escritorios gráficos KDE 3.1 y GNOME 2.2. Mandrake Linux 9.2 incluye el siguiente software necesario para el proyecto:

1. Kernel 2.4.21: Núcleo de Linux configurable 2. XFree 4.3: Servidor X para acceso remoto 3. Glibc 2.3.1: Librerias de Lenguaje c 4. GCC 3.2.2 : Compilador GNU C estándar 5. Apache 2: Servidor WEB. 6. OpenSSH 3.5: Servidor de conexión remota. 7. KDE 3.1: Escritorio tipo Windows. 8. GNOME 2.2:Escritorio tipo Windows 9. Mozilla 1.3

Linux Mandrake 9.2 está optimizado para procesadores 486 y superiores (y compatibles), por lo que

no funcionará en procesadores x86 antiguos. Cuenta con una configuración mejorada y mayor cantidad de hardware soportado. Mantenimiento del sistema simplificado y Amplia selección de aplicaciones de oficina.

71

Cuenta con multimedia y juegos, servicios de servidores, Internet e Intranet, seguridad de alto nivel, todo el software necesario para el desarrollo de aplicaciones, esta disponible en 60 idiomas y Esta regido por los estándares de Linux y Software Libre.

El sistema básico de Linux Mandrake está disponible como descarga gratuita en muchos lugares de Internet. Linux Mandrake 9.2 está diseñado especialmente para el uso personal. Incluye 2 CDS con miles de las mejores aplicaciones multimedia, gráficas y de productividad.

Linux Mandrake nos permitirá configurar servicios adicionales e incluye todo lo necesario para

instalar y desplegar fácilmente servicios de red profesionales, como Apache 2 y Advanced Extranet Server. El kerner de Linux 2.4.21 proporciona soporte nativo para gran cantidad de memoria mayor a 1024 MB y MultiProceso Simétrico.

3.3.1 Tipo de carga del sistema operativo para la máquina paralela.

Existen dos métodos para poder realizar la carga del sistema operativo utilizando Linux, estas formas de acceso se refieren a la manera de como cada nodo realiza la petición de carga. Las dos formas de carga son las siguientes:

a) Carga Local. En este tipo de carga el sistema operativo es instalado en forma local en el disco duro. Por lo que la instalación deberá de ser considerada de acuerdo a las características del cliente que vaya a utilizarse.

b) Carga Remota. Éste se divide a su vez en tres formas:

1. Arranque vía protocolo. Desde el momento en que la computadora es encendida, ésta deberá ser capaz de reconocer los dispositivos locales e intentar dar de alta los servicios de arranque a través de su tarjeta de red.

2. Identificación DHCP. Los clientes no pueden almacenar el kernel con el que deben arrancar. Este se encontrará en el servidor y ser deberá de ser trasferido cada vez que el cliente lo solicite. Es necesario un disco de carga que le de una dirección IP a la máquina y un nombre.

3. Descarga de la imagen del kernel vía protocolo TFTP. Igualmente los clientes no pueden almacenar el kernel con el que deben arrancar. Este protocolo primitivo de ftp crea una pequeña cache donde se va cargando un kernel especial que da de alta el nodo.

4. Por último, vía protocolo NFS, se le asigna su directorio de trabajo.

Para realizar lo anterior es necesario crear un disco de arranque con una imagen de craga. La imagen de carga no es mas que los archivos basicos de carga del sistema operativo , el el proceso completo puede observarse en la figura 22.

72

Figura 22.- Ejemplo del Proceso de Carga Remota

3.3.2. Aplicaciones y Programas.

3.3.2.1 Servicios requeridos Existen servicios básicos los cuales deberán de configurarse en el nodo principal y van relacionados

a tipo de carga del sistema operativo que se seleccione. Sin embargo para dar una generalidad de servicios las cuales puedan servir a cualquier esquema

antes mencionado bastarán con configurar los siguientes:

a) Servidor RPL.

b) Servidor DHCP.

c) Servidor TFTP.

d) Servidor de NFS.

e) Servidor RSH.

3.3.2.1.1 El servidor RPL.

El protocolo RPL (remote protocol load, Carga por protocolo remoto), ha sido diseñado para

el arranque desde tarjetas de red y le da al servidor la posibilidad de hacer peticiones por DHCP (Dynamic Host Configuration Protocol-Protocolo de configuración de localidades dinamicas), servicio que no posee debido a su falta de disco duro.

Al instalar una tarjeta de red con este soporte permitirá interrumpir a la BIOS del

servidor, en este caso un nodo cliente, con la interrupción del BIOS-ROM, INT 19H para administrar el arranque desde este dispositivo. Es necesario que la tarjeta madre de este nodo cliente cuente con esta característica, algo común en las tarjetas actuales. La estructura de datos en que se basa RPL es una pequeña imagen llamada ROM, que deberá ser transferida al Nic. Esta ROM puede ubicarse en 2 localidades:

73

a. Integrarse directamente en el hardware del Nic. Esta posibilidad sólo viene contemplada en las tarjetas más caras puesto ya que requiere un chip llamado boot ROM específico para cada modelo, tiene una capacidad de unos 32KB.

b. La segunda que es más económica, consiste en montar un servidor de Roms, para que

los clientes obtengan la suya desde él. Esta posibilidad ofrece ventajas tanto a nivel de flexibilidad y ya no será necesario el chip. Las imágenes en ROM ocupan 16KB.

3.3.2.1.2 El servidor DHCP (dynamic host configuration protocol).

DHCP es un superconjunto de las operaciones que puede realizar una llamada especial de carga llamada bootstrap o BOOTP, la cual es una mejora sobre el antiguo protocolo de arranque RARP (ARP remoto). Se utiliza DHCP para conseguir la dirección IP. El funcionamiento de BOOTP y DHCP, es simple cuenta de los siguientes procesos:

1. Realizar intercambios de un sólo paquete con el mismo formato tanto para peticiones como respuestas. Este paquete o datagrama es de tipo IP/UDP y utiliza el tiempo muerto del sistema (timeout) para retransmitir, mientras no se reciba respuesta a una petición.

2. Solicita un BOOTREQUEST. Existe un código de control llamado BOOTREQUEST, el

cual usa el puerto 68, las peticiones BOOTREQUEST contienen el nombre de la máquina que las solicitó y si ésta es conocida.

3. Solicita un BOOTREPLY. Existe un código de control llamado BOOTREPLY el cual

usa el puerto 67 para solicitar peticiones del archivo que debe de descargarse. Los servidores se comportan como compuertas, permitiendo peticiones BOOTP entre varias redes.

En breve el funcionamiento se resume a lo siguiente:

• El cliente rellena un paquete con todos los campos que conoce y con el código de petición, y lo

difunde a la dirección 255.255.255.255 de broadcast. • A continuación contesta el servidor, moldeando el paquete de manera especifica para que el

cliente reciba el paquete y lo procese para establecer los parámetros de su dirección IP.

• El servidor de DHCP se inicia como proceso residente (llamado demonio), utilizando un

servicio de red llamado inetd o xinetd.

74

3.3.2.1.3 El servidor TFTP (trivial ftp).

Este protocolo es un FTP especial mucho más simple. Para empezar, la capa de transporte utiliza UDP en lugar de TCP y transferencia por bloques para el envío de los archivos, lo que hace más sencilla la transferencia. El otro motivo por el que se utiliza UDP y un mecanismo tan simple de control de paquetes es porque se necesita que el programa y lo mínimo de pila IP ocupen poco en memoria para que este pueda grabarse en ROM, que inherentemente disponen de poca capacidad, máximo 32 KBytes.

El servidor también es controlado por un servicio de red llamado inetd (demonio de

configuración de servicios de red). Su configuración se centrará en el servidor, puesto que el cliente lo adopta de forma explícito. Existen dos tipos técnicas de configuración para este protocolo y éstas son:

a. Simple. No se establecer normas de seguridad. b. Seguro. Basa su seguridad en una llamada a un proceso llamado chroot, (una función del sistema

operativo). De este modo, en la ejecución de la rutina de aceptación de peticiones, el directorio exportado se convierte en directorio raíz. Consecuentemente el acceso a otros archivos es más difícil.

El protocolo TFTP es un servicio inseguro, ya que el propio protocolo es simple e inseguro, por lo que es recomendable que el servidor que posea este servicio esté aislado de cualquier red que no garantice medidas serias de seguridad. En casi contrario, cualquiera podría sustituir los archivos que descargan los clientes e incluir en ellos alguna rutina no deseada. 3.3.2.1.4 El servidor NFS NFS es el sistema de almacenamiento ingeniado por Sun Microsystems y que utiliza RPC (Remote Procedure Call-Procedimiento de llamadas remotas). Es un modelo de servidores sin estado, es decir, los servidores NFS no guardan en ningún momento los archivos a los que se están accediendo.

El funcionamiento se basa en dos secciones: cliente y servidor. El cliente monta el sistema

de archivos exportado por el servidor y a partir de este momento accede a los archivos remotos como si fuesen propios. Este sistema es utilizado desde hace tiempo en casi todos los sistemas UNIX como método de compartir archivos en red. La función NFSroot designa el método que sigue el kernel cuando en lugar de tomar el clásico sistema de archivos ext2 o reiserfs.

El sistema de archivos que debemos exportar en el servidor debe contener todos los

archivos necesarios para que la distribución pueda funcionar. Este factor es muy variable, dentro de cada distribución. En principio debe de establecerse una política que nos indique que directorios deben ser necesariamente de lectura y escritura o solamente de lectura. Una buena forma de ahorrar espacio en el servidor sería exportando para todos los clientes los mismos directorios para sólo lectura y particularizando para cada uno los de escritura y lectura.

75

3.3.2.1.5 El servidor RSH El servidor RSH forma parte de un programa de comunicación llamado SSH (Secure

Shell). SSH es un programa que permite realizar conexiones entre máquinas a través de una red abierta de forma segura y ejecutar comandos.

El programa SSH provee fuerte autenticación y comunicación segura sobre un canal inseguro y nace como un reemplazo a los comandos telnet, ftp y rlogin, los cuales proporcionan gran flexibilidad en la administración de una red, pero sin embargo, presenta grandes riesgos en la seguridad de un sistema.

Rsh es configurado con los servicios de red llamados inetd. 3.4 Proceso de construcción

Una vez que ya tenemos todas las características que debe llevar nuestra máquina paralela procederemos a la construcción en dos fases esenciales:

1. Construcción Física. Aquí se realizará la planeación en cuanto como deben de conectarse los dispositivos para el funcionamiento correcto, también le podríamos llamar acoplamiento de hardware.

2. Construcción lógica. Aquí se realizará el análisis de los procesos queme permitan explotar el hardware ya previamente construido y se refiere al funcionamiento del sistema operativo y sus aplicaciones.

3.4.1 Construcción física

Nuestro proyecto deberá de ser una máquina paralela que permita lograr gran desempeño, a bajo

costo, por lo que tomaremos la base de construcción básica de un cluster lo que en Linux es llamado Beowulf para adaptarla a un modelo que permita ser.

El Beowulf consiste en varios nodos o computadoras completas conectadas mediante un bus de

comunicación común bajo un sistema operativo abierto. El esquema de hardware muestra en la figura 23.

76

Figura 23.- Esquema de Hardware de un beowulf.

Como es posible ver en la figura cada computadora que dentro del esquema es llamado

nodo va conectado a un canal de comunicación, existe una máquina la cual actúa como servidor y se le llama como nodo principal. La eficiencia de este beowulf dependerá de la velocidad entre las conexiones de cana nodo sobre el bus de comunicación, así como de cada nodo con su dispositivo de almacenamiento.

En este esquema se aprecia que es requerido un disco duro para cada nodo, una tarjeta de

red o una interfaz de comunicación y un bus común para todos los nodos. En la figura 24 se muestra el diagrama a bloques de un cluster tipo beowulf.

Figura 24.- Diagrama a bloques de un cluster tipo beowulf.

77

Como se puede observar en la figura anterior la estructura del cluster considera su construcción con base en el bus de comunicaciones, la interfaz y la infraestructura intermedia del cluster para crear un ambiente de programación paralela montada sobre un dispositivo de almacenamiento local.

La infraestructura intermedia del cluster se refiere al entorno de lectura de procesos que permiten hacer la redirección a la memoria y al dispositivo de almacenamiento de cada nodo. Cada proceso deberá de correr en forma local de los propios recursos de la máquina. Como es de esperarse la homogeneidad de los recursos de cada nodo es importante para balancear la carga de cálculo en cada uno de los procesadores ya que estos consumirán sus recursos locales, como su memoria y su espacio en almacenamiento de disco y como se espera también un nodo mas actualizado y de mejor velocidad responderá con mejor desempeño que uno antiguo.

El esquema de un beowulf considera nodos locales con su memoria y su disco de almacenamiento, también considera contar con el sistema operativo completo y funcional corriendo, lo cual incrementa el costo de construcción, que sin embargo comparado con el costo de una supercomputadora comercial está muy por debajo, pero el objetivo que se persigue en el presente trabajo es no solo alcanzar niveles óptimos de cálculo en la máquina paralela sino además generar un esquema económico.

Para poder realizar lo anterior al sistema Beowulf se le harán algunas modificaciones en

las que los discos duros son inexistentes o de capacidad de almacenamiento aproximado a 500 MB o más para los nodos de que realizan llamadas a sistema operativo en forma remota y sólo existirá un dispositivo de almacenamiento para el nodo maestro.

Por otro llamaremos nodo cliente a aquel nodo que realiza llamadas a sistema operativo en forma remota y que estará formado tan sólo por sus unidades mínimas de funcionamiento. Estas unidades mínimas que permiten crear un nodo integral son las siguientes:

a. Tarjeta Madre. b. Memoria c. Fuente de poder d. Microprocesador e. Tarjeta de red f. Unidad de carga.

La unidad de carga podrá establecerse de manera que pueda ser un lector de CDROM para leer un disco de arranque, una unidad de cinta, un floppy disk o bien un dispositivo de almacenamiento USB. Todo en conjunto crea el concepto de nodo integral.(Ver figura 25).

Una consideración que se debe tomar en cuenta antes de comprar o utilizar una tarjeta madre para un nodo integral es que esta deberá de tener la capacidad de utilizar un teclado tipo USB o bien que el BIOS no necesite del teclado para encender. Las tarjetas madre en la actualidad son muy económicas y ya tienen las dos características anteriores, podría comprarse tarjetas madre que permitan el autoinicio vía red y eso permitirá eliminar del nodo la sección de unidad de carga. Desgraciadamente estas tarjetas son más caras y poco comunes.

78

Como se puede apreciar en el listado, es posible preguntar donde está el teclado, el ratón (mouse) o el monitor, cabe mencionar que cada nodo integral no necesita de esto para su funcionamiento correcto pero sí se utilizará para la su configuración, la cual depende del dispositivo de carga que se utilice lo cual no es lo mismo para un floppy disk que para un CDROM o bien algún dispositivo USB.

Figura 25.- El nodo Integral. Se consideró además de cada nodo integral, un nodo maestro al cual llamaremos nodo principal que es el que contendrá en su totalidad el sistema operativo y él o los dispósitivos de almacenamiento que serán utilizados por los nodos integrales, por lo que este nodo contara con los mismos elementos de un nodo integral más un teclado, un ratón o mouse y un monitor. La máquina paralela tendrá entonces dadas las modificaciones indicadas en la figura 26. En este nuevo esquema cada nodo integral depende del dispositivo de carga para poder configurarse dentro del sistema operativo del nodo principal y configurar el entorno, así como los procesos que estarán involucrados en el funcionamiento. El dispositivo de almacenamiento principal se encuentra en el nodo principal y de aquí en un mismo directorio, se tomará el mismo archivo a procesar por cada uno de los nodos integrales de manera que existirá un sólo entorno para cada nodo integral. Este sistema permite garantizar la escalabilidad y el integrar n-nodos integrales al proyecto con el mínimo de problemas.

79

Figura 26.- Esquema principal de la máquina paralela propuesta. Indudablemente el bus de comunicaciones es primordial para que la máquina logre un desempeño correcto y óptimo por lo que analizando los diferentes tipos de topologías de red, fue más factible el tener una red de tipo ethernet 10/100 mb/s por su bajo precio12. Además de que las tarjetas de red conseguidas también soportan esta tecnología (aunque la interfaz para el bus de comunicaciones puede ser diversa), lo único que se requiere es un canal de comunicación simple, así que para la construcción de cualquier otra máquina paralela es posible utilizar cualquier esquema de comunicación vía un análisis de tiempos para ver la factibilidad de éste. El modelo propuesto final en hardware de la máquina paralela dadas las consideraciones anteriores es el mostrado por la figura 27. La correcta configuración del software, en este caso el sistema operativo es muy importante ya que aquí es donde el proyecto cobrará forma

12 Precio de 12 Dlls. Americanos cotizados el dia 12 de febrero de 2006.

80

Figura 27.- El modelo en hardware propuesto final de la máquina paralela.

3.4.2 Construcción Lógica.

El procedimiento general que debe de hacer un nodo integral , es más compleja ya que

este no cuenta con todos los elementos para darse de alta en la red y no tiene tampoco la capacidad de disco para guardar información.

La idea fundamental para configurar los dispositivos de carga es la siguiente: el nodo

integral buscará su dirección IP en el servidor de arranque vía protocolo BOOTP, usando la dirección IP inicial como “0.0.0.0” y recibiendo su núcleo vía el protocolo TFTP. El arrancar un sistema a través de pequeños segmentos no es simple, es necesario instalar el paquete nfsboot.

81

Este paquete contiene la imagen de una EPROM de arranque para diferentes tarjetas de red que puede ser grabada directamente pero existen varias vías alternativas para preparar el nodo integral. Si la máquina cuenta con un disco duro, entonces es posible utilizar un pequeño programa tipo DOS, o la imagen binaria del un disquete creado con el comando dd de la siguiente forma:

#dd if=imagen of=/dev/fd0H1440

Esta imagen contiene un cliente BOOTP y TFTP. Es necesario configurar un núcleo de

Linux, para que tenga la opción nfsroot habilitada. Es necesario poner al día el núcleo con un parche incluido en el paquete nfsboot. Es necesario configurar el soporte para dispositivos de sistemas de archivo ya sea por disquetes o discos duros, pero es obligatorio habilitar soporte TCP/IP, el soporte para tarjeta ethernet y el soporte de sistema de archivos nfs. Y, una vez realizado esto, recompilar el núcleo y reconstruir los módulos de configuración.

BOOTPD puede encontrarse en el paquete comprimido bootpd-2.4.tar.gz o bien en su versión compilada binaria. Después de obtener el paquete, es necesario compilarlo e instalarlo, con el fin de que los archivos generados puedan encontrase como servicios en la carpeta /sbin. Al tratarse de un servicio, éste deberá de iniciarse para que esté corriendo como demonio en el sistema, esto es permanentemente y para esto se utiliza el comando;

# bootpd –s

En el caso de Linux mandrake existe un servicio llamo Xinetd el cual se encarga de la configuración y carga de este servicio por lo que sólo será necesario darlo de alta con la instrucción:

#/sbin/chkconfig bootpd on

Por ultimo se iniciará el servicio con el siguiente comando: #/etc/rc.d/init.d/xinetd restart

El protocolo BOOTP tiene un archivo de configuración llamado bootptab el cual se encuentra

en /etc. Este deberá modificarse insertando la dirección IP, su dirección de compuerta (gateway), el servidor de nombres y las direcciones ethernet de las máquinas remotas. En el caso de cada nodo integral se tiene una configuración semejante a la siguiente:

global.prof:\ :sm=255.255.255.0:\ :ds=192.168.1.5:\ :gw=192.168.1.19:\ :ht=ethernet:\ :bf=linux: nodo1:hd=/export/root/nodo1:tc=global.prof:ha=0000c0863d7a:ip=193.1.0.1. nodo2:hd=/export/root/nodo2:tc=global.prof:ha=0800110244e1:ip=192.1.0.2 nodo3:hd=/export/root/nodo3:tc=global.prof:ha=0800110244e1:ip=192.1.0.3 nodo4:hd=/export/root/nodo4:tc=global.prof:ha=0800110244e1:ip=192.1.0.4 nodo5:hd=/export/root/nodo5:tc=global.prof:ha=0800110244e1:ip=192.1.0.5 nodo6:hd=/export/root/nodo6:tc=global.prof:ha=0800110244e1:ip=192.1,0.6 nodo7:hd=/export/root/nodo7:tc=global.prof:ha=0800110244e1:ip=192.1.0.7 nodo8:hd=/export/root/nodo8:tc=global.prof:ha=0800110244e1:ip=192.1.0.8

82

Aquí encontraremos las siguientes claves de configuración:

1. sm: Corresponde a la máscara de subred 2. ds: Dirección del servidor de nombres (DNS) 3. gw: Dirección de la pasarela por defecto 4. ht: Tipo de hardware de red 5. bf: Nombre del archivo de arranque Después de esto, cada máquina debe tener una línea donde se tiene el siguiente esquema:

1. El primer campo contiene el nombre de la máquina

2. hd contiene el directorio del archivo de arranque

3. El archivo de esquema general debe ser incluido en el campo tc

4. ha contiene la dirección de hardware de la tarjeta de red

5. ip contiene la dirección ip que se asigna

3.4.3 Instalación del nodo principal

Para la instalación del nodo principal bastará con tener instalados los servicios básicos

antes mencionados. Es necesario un sistema Linux completo, además de espacio en disco para exportarlo para lectura y escritura en el nodo integral. Es necesario montar el directorio exportado en algún lugar común sobre el sistema de archivos de la máquina Linux.

Es posible crear los subdirectorios para los nodos integrales utilizando el siguiente script , se establece que los nodos integrales son llamados nodo1,nodo2:

cd /export/linux for x in [nodo2 nodo3 nodo4 nodo5 nodo6 nodo7] ; do mkdir $x; cd $x (cd ../nodo1; tar cf - *) | tar xvf – done

Una vez hecho esto, es necesario realizar las siguientes exportaciones:

/export/linux/usr: Sólo lectura para todo el mundo /export/linux/nodo1: Solamente para nodo1 con permisos rw,root /export/linux/nodo2: Solamente para nodo1 con permisos rw,root /export/linux/nodo3: Solamente para nodo1 con permisos rw,root /export/linux/nodo4: Solamente para nodo1 con permisos rw,root

83

/export/linux/nodo5: Solamente para nodo1 con permisos rw,root /export/linux/nodo6: Solamente para nodo1 con permisos rw,root /export/linux/nodo7: Solamente para nodo1 con permisos rw,root

Como se indica a continuación el archivo /etc/export quedaria así:

# Este archivo es /etc/export # La siguiente línea es una única: /etc/root/usr -access=linuxnet # Las siguientes líneas corresponden a una por cada máquina /export/root/nodo1 rw=machine1,root=nodo1 /export/root/nodo2 rw=machine1,root=nodo2 /export/root/nodo3 rw=machine1,root=nodo3 /export/root/nodo4 rw=machine1,root=nodo4 /export/root/nodo5 rw=machine1,root=nodo5 /export/root/nodo6 rw=machine1,root=nodo6 /export/root/nodo7 rw=machine1,root=nodo7

Por último es necesario ejecutar el siguiente comando para actualizar las exportaciones:

#exportfs -a

Con lo anterior quedara configurado el servidor TFTP, ya que los nodos integrales

arrancarán desde el directorio /export. Por ultimo se realiza un enlace que permita montar los directorios al momento en el que el servidor es encendido:

#/sbin/mount server://export/linux/usr /usr

Como la primera línea de: /export/linux/nodo1X/etc/rc.d/rc.S

Hasta este momento los nodos integrales son dados de alta en el sistema operativo como

máquinas individuales. La figuras 28 y 29 muestran el diagrama de flujo de la carga de los nodos integrales.

84

Figura 28.- Diagrama de flujo de la carga de los nodos integrales en el sistema operativo (parte 1)

85

Figura 29.- Diagrama de flujo de la carga de los nodos integrales en el sistema operativo (parte 2). Es posible que cada terminal pueda tener acceso a un entorno grafico, así como a diferentes aplicaciones, sin embargo para este proyecto no es necesario, ya que el entorno grafico se encuentra en el nodo principal. Hasta este momento existe conexión entre cada nodo integral y el nodo principal, pero aun no funciona como una máquina paralela.

86

3.4.4 Diseño e implementación de la máquina paralela

Para poder crear ahora la máquina paralela es necesario saber como funciona en sus

procesos el procesamiento distribuido, que consiste en la administración de varios procesos, ejecutándose en sistemas de computadoras múltiples y distribuidas. La concurrencia es fundamental en todas las áreas que necesitan cómputo paralelo y fundamental para el diseño del sistema operativo. La concurrencia comprende un gran número de características de diseño, donde son incluidos aspectos como la comunicación entre procesos, administración de los recursos, la sincronización en la ejecución de varios procesos y la asignación del tiempo de procesador para cada proceso. Estas características son comunes para sistemas con multiprocesadores y proceso distribuido, e inclusive con sistemas programados con un sólo procesador.

La concurrencia puede presentarse en tres contextos diferentes:

a) Múltiples aplicaciones: la multiprogramación se creó para permitir que el tiempo de procesador de la máquina fuese compartido dinámicamente entre varias aplicaciones activas.

b) Aplicaciones estructuradas: como ampliación de los principios del diseño modular y la

programación estructurada, algunas aplicaciones pueden implementarse eficazmente como un conjunto de procesos concurrentes.

c) Estructura del sistema operativo: las ventajas de estructuración son aplicables en

algunos sistemas operativos y el uso de conjunto de procesos o hilos son aprovechados por los programadores para aprovechar la concurrencia.

En un sistema multiprogramado con un único procesador, los procesos se intercalan en el tiempo aparentando una ejecución simultánea. Aunque no se logra un procesamiento paralelo y produce una sobrecarga en los intercambios de procesos, la ejecución intercalada produce beneficios en la eficiencia del procesamiento y en la estructuración de los programas.

La intercalación y la superposición pueden contemplarse como ejemplos de procesamiento concurrente en un sistema monoprocesador, los problemas son consecuencia de la velocidad de ejecución de los procesos que no pueden predecirse y depende de las actividades de otros procesos. De la forma en que el sistema operativo trata las interrupciones surgen las siguientes dificultades:

1. Compartir recursos globales implica riesgos de seguridad 2. Para el sistema operativo es difícil administrar en forma óptima los recursos.

Dentro de las labores que realiza el sistema operativo se encuentran las siguientes actividades:

1) El sistema operativo debe seguir a los distintos procesos activos 2) El sistema operativo debe asignar y retirar los distintos recursos a cada proceso activo,

entre estos se incluyen:

87

i. Tiempo de procesador ii. Memoria

iii. Archivos iv. Dispositivos de entrada y salida

3) El sistema operativo debe proteger los datos y los recursos físicos de cada proceso contra

los accesos o influencias no intencionadas de otros procesos. 4) Los resultados de un proceso son independientes de la velocidad a la que se realiza la

ejecución de otros procesos concurrentes.

Para abordar la independencia de la velocidad debemos ver las formas en las que los procesos interactúan. Se puede clasificar la manera como interactúan los procesos en función al nivel de conocimiento que cada proceso tiene de la existencia de los demás. Existen tres niveles de conocimiento:

1) Los procesos no tienen conocimiento de los demás: son procesos independientes que no

operan juntos. 2) Los procesos tienen un conocimiento indirecto de los otros: los procesos no conocen a

los otros por sus identificadores de proceso pero muestran cooperación el objeto común. 3) Los procesos tienen conocimiento directo de los otros: los procesos se comunican por el

identificador de proceso y pueden trabajar conjuntamente.

Los procesos concurrentes entran en conflicto cuando compiten por el uso del mismo recurso. Dos o más procesos necesitan acceder a un recurso durante su ejecución y es de alta prioridad que cada proceso deje tal y como esté el estado del recurso que utilice. La ejecución de un proceso puede influir en el comportamiento de los procesos que por él compiten.

Cuando existen procesos en competencia, se deben solucionar tres problemas de control:

a) La necesidad de exclusión mutua. Hacer que se cumpla la

exclusión mutua provoca un interbloqueo. b) La inanición. Si tres procesos necesitan acceder a un recurso,

donde P1 posee al recurso, luego lo abandona y le concede el acceso al siguiente proceso P2, P1 solicita acceso de nuevo y el sistema operativo concede el acceso a P1 Y P2 alternativamente, se puede negar indefinidamente a P3 el acceso al recurso.

c) Cooperación entre procesos compartidos. Comprende los procesos que interactúan con otros sin tener conocimiento siquiera de ellos

88

Para solucionar problemas de procesos concurrentes, se diseñaron los sistemas operativos actuales, como un conjunto de procesos secuenciales, eficientes y fiables para dar soporte a la cooperación de recursos y de procesos. Los procesos de usuario podrían utilizar estos mecanismos si el procesador y el sistema operativo los hacían disponible. El principio fundamental es el siguiente, los procesos pueden interactuar entre si por medio de simples señales, con esto son obligados a detenerse en una posición determinada hasta que reciba una señal específica.

Para controlar esta situación se usan variables especiales llamadas semáforos, los

procesos ejecutan funciones primitivas llamadas wait, y si la señal aun no se ha transmitido, el proceso se suspende hasta que tiene lugar la transmisión. Los semáforos son variables que tienen un número entero sobre el que se definen las siguientes operaciones:

a. Valor negativo: la operación wait disminuye el valor del semáforo y si el valor no es positivo el

proceso que ejecuta se bloquea. b. Operaciones signal: incrementan el número del semáforo. Si el valor es positivo se desbloquea

el proceso bloqueado por una operación wait.

No hay forma de examinar o manipular los semáforos aparte de estas operaciones. Las funciones primitivas wait y signal se suponen atómicas, es decir no pueden ser interrumpidas y cada rutina puede considerarse como un peso indivisible. Un semáforo solo puede tomar los valores 0 y 1.

Los semáforos son más sencillos de implantar y puede demostrarse que tienen la misma potencia de expresión que los semáforos del sistema. Ambos semáforos emplean una cola para mantener los procesos en espera, la cuestión reside en el orden en que se retiran los procesos de la cola. Los semáforos robustos garantizan la inexistencia de inanición en el algoritmo de exclusión mutua, pero no es así en los semáforos débiles, se supone que los semáforos del sistema son siempre robustos ya que son los más adecuados y porque son los tipos de semáforos que más incluyen los sistemas operativos.

Adicional a los semáforos existen los monitores. Estos son estructuras de un lenguaje de programación que ofrecen una funcionalidad equivalente a las de los semáforos pero son más fáciles de controlar. La estructura de monitor se ha implementado en varios lenguajes de programación como: Pascal concurrente, Modula-2, Java, etcetera. Para una lista enlazada se puede necesitar un proceso de cierre que bloquee todas las listas enlazadas o bien un cierre por cada elemento de una lista.

Un monitor es un módulo de software que consta de uno o más procedimientos, una secuencia de

inicio y uno datos locales. Sus características son las siguientes:

a. Sólo los procedimientos del monitor acceden a variables de datos locales. b. Un proceso entra en el monitor invocando a uno de sus procedimientos. c. En el monitor sólo un proceso puede ser ejecutado en un momento dado; cualquier otro proceso

quedará suspendido esperando la disponibilidad del monitor. d. Al ser un proceso por vez, el monitor puede ofrecer un servicio de exclusión mutua fácilmente.

El monitor proporciona variables de condición que son accesibles sólo desde dentro del monitor.

Hay dos funciones para operar variables de condición:

89

a. cwait : suspende la ejecución del proceso que llama bajo la condición "c". El monitor está ahora disponible para otro proceso.

b. csignal : retorna la ejecución de un proceso suspendido después de un cwait, bajo la misma condición. Si hay varios procesos elige uno de ellos.

Si un proceso de monitor ejecuta un csignal y no hay tareas esperando entonces el csignal de pierde.

Aunque un proceso puede entrar al monitor llamando a cualquiera de sus procedimientos, se puede decir que el monitor tiene un sólo punto de acceso, custodiado para que sólo un proceso esté en el monitor en un instante dado. Si existen otros procesos tratando de entrar al monitor, estos se colocan en una cola de procesos suspendidos esperando la disponibilidad del monitor.

Un proceso dentro de un monitor puede suspenderse a sí mismo, temporalmente, bajo la condición

X ejecutando cwait(x), entonces se coloca en una cola de procesos que esperan que cambie la condición X entonces ejecuta un csignal(x) que avisa a la cola de condición correspondiente de que la condición a cambiado.}

3.4.4.1 Intercambio de mensajes

Existen dos requisitos básicos que deben satisfacerse cuando los procesos interactúan entre

sí y que conforman el intercambio de mensajes. Estos son: 1. La sincronización 2. La comunicación Los procesos tienen que sincronizarse para cumplir la exclusión mutua, los procesos

cooperantes pueden necesitar intercambiar información. El intercambio de mensajes es un método que permite que se realice ambas funciones. Este método tiene la ventaja de que es de fácil implementación en sistemas distribuidos y también en sistemas de multiprocesador y monoprocesador de memoria compartida. La funcionalidad real del intercambio de mensajes, generalmente, se da por medio de un par de funciones primitivas:

a. Send: Enviar información. b. Receive:Recibir información

3.4.4.2 Sincronización La comunicación de un mensaje implica cierto nivel de sincronización. El receptor no puede recibir

un mensaje hasta que sea enviado por otro proceso. Cuando se ejecuta una primitiva send en un proceso, existen dos posibilidades:

a. El proceso emisor se bloquea hasta que recibe el mensaje b. El proceso emisor no se bloquea

90

Igualmente cuando un proceso ejecuta una primitiva receive, existen dos alternativas: a. Si previamente se ha enviado algún mensaje, éste es recibido y continua la ejecución. b. Si no hay ningún mensaje esperando entonces:

i. El proceso se bloquea hasta que llega un mensaje ii. El proceso continúa ejecutando, abandonando el intento de recepción.

El emisor y el receptor pueden ser bloqueantes o no bloqueantes. Existen 3 tipos de

combinaciones pero un sistema sólo implementa uno o dos.

I. Envío bloqueante, recepción bloqueante: tanto el emisor como el receptor se bloquean hasta que llega el mensaje; esta técnica se conoce como rendezvous.

II. Envío no bloqueante, recepción bloqueante: aunque el emisor puede continuar, el receptor se bloquea hasta que llega el mensaje solicitado. Es la combinación más útil.

III. Envío no bloqueante, recepción no bloqueante: nadie debe esperar.

El send no bloqueante es la forma más natural para muchas tareas de programación concurrente. Un posible riesgo del send no bloqueante es que por error puede llevar a una situación en la que el proceso genere mensajes repetidamente. Para el receive, la versión bloqueante es la más natural para muchas tareas de programación concurrente. En general, un proceso que solicita un mensaje necesitará la información esperada antes de continuar.

Es importante disponer de alguna forma de especificar en la primitiva send que proceso va a recibir el mensaje. La mayoría de las implementaciones permiten a los procesos receptores indicar el origen del mensaje que se va a recibir. Los distintos esquemas para hacer referencia a los procesos en las primitivas send y receive se encuadran dentro de 2 categorías: Direccionamiento directo: la primitiva send incluye una identificación específica del proceso de destino.

i. La primitiva receive se puede manejar de dos formas: 1. Requiere que el proceso designe explícitamente un proceso emisor. 2. El proceso debe conocer de antemano de que proceso espera un mensaje.

En otros casos es imposible especificar el proceso de origen por anticipado.

2. Direccionamiento indirecto: los mensajes no se envían directamente del emisor al

receptor, sino a una estructura de datos compartidos formada por colas, que pueden guardar los mensajes temporalmente, que se denominan buzones. Para que los dos procesos se comuniquen, uno envía mensajes al buzón apropiado y el otro los retira. La ventaja principal de este tipo de direccionamiento está en que se desacopla a emisor y receptor, asegurando mayor flexibilidad en el uso de mensajes.

91

Por último existe una clasificación basada en la relación entre emisores y receptores y se encuentra dada de la siguiente forma:

1. Uno a uno: Llamada también punto a punto, permite que se establezca un enlace privado entre dos procesos.

2. Muchos a uno: resulta útil para interacciones cliente-servidor. En este

caso el buzón se llama puerto. 3. Uno a muchos: permite un emisor y varios receptores.

La asociación de procesos a buzones puede ser estática o dinámica. Los puertos suelen estar asociados estáticamente con algún proceso en particular. El puerto se crea y se asigna al proceso permanentemente. Una relación de uno a uno se define de forma estática y permanentemente. Cuando hay varios emisores, la asociación a un buzón puede realizarse dinámicamente. Se pueden utilizar primitivas como conectar o desconectar.

Con base en lo anterior la máquina paralela requerirá que cada buzón se encuentre en forma local, escuchando las llamadas de los buzones de otros nodos integrales e inclusive del nodo principal. El control de los procesos deberá de realizarse de manera remota y cada buzón deberá de tener interacción con los demás buzones.

Para poder tener el control de cada nodo con cada uno de los demás es requerido un

servicio que permita lograr esta interacción de procesos sin que se vea lastimada la seguridad del proyecto. Este servicio será el RSH que permitirá acceder como determinado usuario a los demás nodos, cabe mencionar que el estándar MPICH es un entorno de programación que permite explotar la configuración de la máquina paralela realizando algunas configuraciones adicionales.

Los detalles de como preparar e instalar MPICH incluyen en las secciones siguientes: a. El primer paso es descargar MPICH e instalarlo: La vía más fácil para

conseguir el programa es ingresando a la página Web: www.mcs.anl.gov/mpi/mpich/download.html.

b. Se adquiere por la vía anterior el archivo mpich.tar.gz , por lo que se deberá

de des comprimir usando el siguiente comando:

#tar –zxvf mpich.tar.gz

Es necesario pre-compilar el código que se obtuvo al hacer la descompresión de MPICH, esto se realiza con el la instrucción siguiente:

#./configure -- with-device=ch_p4mpd -- prefix=/usr/local/mpich-1.2.6

92

El proceso de configuración analiza el sistema operativo y determina las opciones y las

direcciones de los archivos; esto también crea el archivo makefile el cual permite crear los archivos ejecutables. Es necesario decidir donde se instalará MPICH. Este paso no es estrictamente necesario.

A continuación deberemos de compilar el código usando las librerías de GNU gcc las

cuales deberán de estar incluidas en el sistema operativo del nodo principal. Estos ejecutables o binarios se crean con la siguiente instrucción:

#make

Esto puede tomar algún tiempo en crear los archivos definitivos, por último después de concluida esta fase será necesario ejecutar la siguiente orden:

#make install

Esto sitúa los archivos en el lugar definitivo para su uso. Es necesario que el directorio completamente compilado sea copiado a los recursos

compartidos de los nodos integrales, para que el nodo integral pueda ejecutar los demonios correspondientes. Los archivos en su totalidad del directorio BIN deberán de ser copiados al directorio /usr/bin de cada nodo integral y del nodo principal.

El método de acceso rsh es más sencillo de utilizar que otros servicios de acceso como el

ssh (secure shell) y consume menos recursos , es necesario incluir rlogin como otro servicio de xinetd, el cual será útil para probar el funcionamiento del nodo integral y se configura igual que el servicio rsh y pertenece al demonio xinetd. Este servidor es instalado en defecto, pero por default estos servicios de son inhabilitados. Para habilitarlos se deberá de correr el siguiente comando:

#/sbin/chkconfig rlogin on #/sbin/chkconfig rsh on

Y deberemos reiniciar el servidor xinetd con el siguiente comando: #/etc/rc.d/init.d/xinetd restart

Hasta este momento no es posible establecer comunicación alguna ya que el servicio esta

denegado Para permitir a los usuarios de rsh ingresar sin contraseña es necesario editar el archivo /etc/hosts.equiv. Este archivo debe tener los nombres de los nodos integrales y del nodo principal.

93

En el directorio raíz de cada nodo deberá de estar un archivo llamado .rhost en el cual se encuentran todos los nodos, aceptados. Un ejemplo de este archivo es el siguiente:

Server # Este es el nodo principal Nodo1 Nodo2 Nodo3 Nodo4 Nodo5 Nodo6 Nodo7

Para permitir el control de las terminales será necesario editar el archivo /etc/securetty

Con el fin de añadir la instrucción: Pts/1

Con el fin de que acepte terminales remotas. Esto será muy útil porque por medio de estas

terminales podremos administrar algunos procesos de los nodos integrales. La seguridad del acceso es controlada por el archivo /etc/pam.d/rsh el cual contiene la siguiente información:

auth required /lib/security/pam_nologin.so auth required /lib/security/pam_securetty.so auth required /lib/security/pam_env.so auth sufficient /lib/security/pam_rhosts_auth.so account required /lib/security/pam_stack.so service=system-auth session required /lib/security/pam_stack.so service=system-auth

Como se puede observar las claves de autentificación para el sistema se encuentran

establecidas con el comando required o sufficien”. Un comando sufficient le dice al sistema que no es requerido un password.

La comunicación entre los procesos de MPICH emplean los mecanismos de los puertos

estándares de UNIX generalmente utilizan los puertos en el rango de 1024 y 65535. La prueba que indica que cada nodo integral está correctamente configurado para aceptar

órdenes remotas se comprueba con la orden:

#Rsh [nombre del nodo] ls.

Con este procedimiento el compilador mpich deberá de encontrarse en funcionamiento y

por lo tanto la máquina paralela deberá de funcionar, pero será necesario hacer las pruebas correspondientes para asegurarnos que realmente existe la paralelizacion de los procesos y lo más importante es que puede ejecutar programas paralelos. La figura 30 muestra hasta el momento en que se establece la comunicación de los procesos en la máquina paralela en una distribución de mensajes a todos los nodos (broadcast).

94

Figura 30.- Se muestra hasta el momento de como se establece la comunicación de los procesos en la máquina paralela simulando un broadcast.

95

Para crear un programa en paralelo es necesario conocer cual es la manera como funciona

el compilador paralelo, en este caso el MPICH. Existen tres fases necesarias para crear un código el cual pueda responder al procesamiento paralelo. Estas fases son:

1. Escribir la aplicación utilizando el lenguaje C y el compilador gcc,

utilizando las librerías de MPICH. Bastará tan solo con incluir la librería mpi.h.

2. Compilar la aplicación utilizando el comando mpicc con la siguiente sintaxis.

#mpicc –o archivo de salida archivo.c

3. Ejecutar la aplicación : Es necesario antes que nada cambiar los permisos

para que puedan ser utilizados por todos los nodos en escritura, lectura y ejecución con los siguientes comandos:

#chmod 777 [ archivo de salida]( generado por mpicc)

#mpirun –np [numero de procesos] archivo (generado por mpicc)

Por ejemplo supongamos un programa simple para identificar un nodo con su nombre. #include <stdio.h> #include "mpi.h" int main(int argc, char* argv[]) { int numProcs; int myRank; // Inicializo MPI MPI_Init(&argc,&argv); // Determino el numero de procesos MPI_Comm_size( MPI_COMM_WORLD, 2); // Determino el numero de proceso con el que estoy ejecutado MPI_Comm_rank( MPI_COMM_WORLD, &myRank); // Muestro el numero de procesos if(myRank==0) printf("Numero de procesos : %d\n",numProcs); fflush(NULL); // Muestro quien soy printf("Hola Mundo, soy el proceso : %d\n",myRank); fflush(NULL); // Finalizo MPI MPI_Finalize(); return 0; }

Como podemos ver el código fuente es similar al estándar de c, en el caso del compilador

96

de C se utiliza GNU GCC, el cual es importante para ingresar las librerias de MPI. La iniciación del entorno en paralelo es establecida por el comando:

#MPI_Init(&argc,&argv);

El cual tiene esa configuración ya que acepta valores de inicialización al momento de correr el programa el parámetro mas importante que es pasado a esta función de mpi es el parámetro np o numero de procesos que es utilizada por mpirun.

El entorno de mpi está configurado por el número de nodos en el archivo machines.linux en el

cual se establece el nodo y el número de procesadores que involucra, para este proyecto tenemos:

Servidor:2 Nodo1:2 Nodo2:2 Nodo3:2 Nodo4:2 Nodo5:2 Nodo6:2 Nodo7:2

Por lo que para hacer referencia a este listado y a estos nodos se utiliza el comando

MPI_COMM_WORLD:

// Determina él numero de procesos MPI_Comm_size( MPI_COMM_WORLD, &np); // Determino el numero de proceso con el que estoy ejecutado MPI_Comm_rank( MPI_COMM_WORLD, &myRank);

Al final del programa el entorno deberá de terminar con el siguiente comando, este comando solo es ocupado una vez en el código y es obligatorio escribirlo.

// Finalizo MPI MPI_Finalize();

La librería de MPICH cuenta además de estas funciones las dos primitivas principales de el intercambio de mensajes como lo es MPI_SEND y MPI_RECEIVE, además de 105 funciones adicionales, esta librería es un estándar por lo que los programas que funcionan en otro tipo de supercomputadoras funcionarán correctamente sobre esta máquina paralela. De esta forma garantizo la compatibilidad y se podrá integrar como nodo integral cualquier computadora o súper computadora que permita el acceso rsh y MPICH bajo cualquier sistema operativo. Logrando con esto que permita la multiplataforma. En el anexo 3 se muestran las principales funciones de la librería MPICH.

3.4.5 Experimentos y optimización.

3.4.5.1 Performance de Red El diseño, la construcción y la utilización de un sistema de alto desempeño requiere de una medición apropiada y una optimización en la configuración de la red.

97

Para llevar a cabo estos experimentos se realizaron las pruebas con la siguiente configuración:

1. Una Tarjeta de 100 Mbps fast ethernet comercial por nodo conectadas mediante un switch fast ethernet marca 3com.

2. Una tarjeta de red 1000 Mbps gigabit Ethernet marca 3com por nodo conectadas con un switch

gigabit Ethernet.

Para materializar los dos escenarios en el cluster construido cuyo hardware es heterogéneo, se tomaron dos nodos de iguales caracteríısticas, en este caso fueron seleccionados por proximidad al nodo principal.

La primera prueba o benchmark que se realizó fue el llamado Throughput de TCP, que consiste en evaluar el desempeño del canal de comunicación del cluster a nivel de protocolo TCP. Para esto se utilizo el modulo TCP del benchmark NetPIPE.(Ver anexo 4.)

Con los resultados obtenidos se realizaron los gráficos de throughput según el tamaño de bloque

transferido, de saturación de la red y de firma ethernet. Estos últimos permiten analizar el tamaño máximo del paquete para el cual se logra un incremento en el throughput y la latencia de la red respectivamente. Obteniendo los siguientes resultados:

a. En fast ethernet (FE) el buffer de envió fue de 16 KB. b. En gigabit ethernet (GE) el buffer de envío fue de 64 KB En ambos casos el buffer de recepción es de 85 KB. El buffer de envío para GE se configuró

cambiando las variables del socket TCP del sistema operativo Linux. Utilizando el comando de linux ifconfig se configuraron los distintos tamaños de MTU, por ejemplo para 3000 bytes se ejecutó:

#ifconfig eth0 mtu 3000

La Figura 31 muestra el throughput en función del tamaño de bloque transferido. A

simple vista, se pueden observar las mejoras resultantes al incrementar la capacidad del medio de comunicación entre los nodos. Sin embargo, pese a utilizar tarjetas y un switch gigabit ethernet, el mejor resultado no alcanza los 350 Mbps, esto como resultado de tener una red de orden 1 (red lan). Es factible incrementar el resultado utilizando una configuración de red indirecta, sin embargo el costo de esta implementación es muy costoso y mas difícil de implementar.

Con respecto a gigabit ethernet y a la variación en el tamaño del MTU, si se aumenta a 3000 bytes se logra una mejora pareja de 20 Mbps comparada con 1500 bytes.

También se logra una mejora similar con 9000 bytes, pero su comportamiento es un poco inestable y por debajo del caso de 3000 bytes. Es posible que el procesador no sea lo suficientemente rápido para realizar los cálculos que requiere TCP/IP para poder utilizar la capacidad de ancho de banda que provee gigabit ethernet.

En todos los casos se utilizan paquetes de tamaño menor o igual a 8 bytes, esto se debe a

que para paquetes tan pequeños el benchmark envía un sólo paquete TCP muchas veces y devuelve el

98

promedio de la latencia obtenida. Estos casos no son útiles para analizar el throughput. También se observa que para cada caso la función crece abruptamente en cierto intervalo de tiempo, es allí es, donde se obtiene un throughput mayor al incrementar el tamaño del bloque.

El gráfico de saturación de la red, figura 32, se obtiene de graficar el tamaño de bloque contra el tiempo ambos en escala logarítmica. Se define como punto de saturación a partir del cual al incrementar el tamaño del bloque el tiempo crece linealmente.

Figura 31.- Throughput para tamaño de sockets por default sobre TCP , donde (F)ast, (E)thernet, (B)onding, M(PICH), (G)igabit.

99

Figura 32.- Gráfico de saturación.

3.4.5.2 Transmisión de información (throughput) de MPICH

Para realizar la medición del troughput de MPICH, se utilizó de nuevo él modulo MPI del benchmark NetPIPE. Los resultados obtenidos se muestran a partir de los gráficos de throughput el cual depende del bloque transferido, de saturación de la red (figura 32) y de firma ethernet . Figura 33. En la figura 31, se muestra el throughput contra el tamaño de bloque transferido. Sé graficaron los resultados para MPICH en fast ethernet y gigabit ethernet con MTU=1500 bytes. Se modificó la variable SOCKBUFSIZE, y se ejecutó el benchmark para buffers de 32 KB y 128 KB.

100

Figura 33.- Gráfico de firma ethernet.

Para las pruebas de las funciones de MPICH a primera vista se observa que el

desempeño se ve afectado en comparación con los resultados obtenidos para TCP. Esto se debe a la sobrecarga (overhead) que se agrega sobre el protocolo TCP al implementar funciones de paso de mensajes más simples para el programador.

En las pruebas de MPICH con su configuración de buffers de envío y se recibieron

mensajes por de 32 KB, lo que ocasiono que el throughput disminuyera en promedio: a. 18 % para gigabit ethernet

b. 11 % para fast Ethernet.

En el gráfico de saturación de la red, Figura 32, se observa que los puntos de saturación de MPICH coinciden con los de TCP. Siendo de 4 KB para gigabit ethernet, y para fast ethernet de 2 KB.

101

Finalmente, en la figura 33, se observa la latencia de MPICH donde es mayor la latencia para el caso de fast ethernet con 70 µs y en gigabit ethernet con MTU igual a 1500 bytes con 47 µs.

3.4.5.3 Benchmark Time Esta prueba de desempeño es utilizada para tomar los tiempos de acceso de los distintos comandos UNIX. Se midieron los tiempos en los siguientes eventos, esto se hace con el comando time que permite mostrar cualquier comando remoto o local:

1. Lectura local (ext3) 2. Lectura remota (NFS) 3. Lectura local escritura local. 4. Lectura local escritura remota

Parámetros de prueba:

Para la transferencia de archivos en su categoría de transferencia remota se utilizo las fuentes del kernel comprimido con un tamaño de 36,7 MB y se selecciono para realizar las pruebas dos nodos al azar.

La sintaxis básica de este comando es simple y se encuentra representada de la siguiente forma:

#Time comando

Ejemplo #time rsh nodo1 ls.

Para analizar los gráficos se debe tomar en cuenta la influencia el tamaño de bloque de cada comando y del archivo de prueba , 8 KB para NFS .En la Figura 34, se muestra el tiempo de ejecución de los comandos de lectura rm -f, du -sk, ls -R, grep -r y find -name.

102

Figura 34.- Se muestra el tiempo de ejecución de los comandos de lectura rm -f, du -sk, ls -R, grep -r y find -name.

103

CONCLUSIONES Y RECOMENDACIONES Se realizaron exitosamente pruebas de desempeño, generadas por los benchmarks y se

ejecuto el programa pi para el calculo de la constante pi, en la maquina paralela alcanzando una capacidad de procesamiento de 1 Gflops, la compatibilidad del sistema se comprobo en este mismo ejercicio, ya que el programa fue escrito para la origin 2000.

Además se han establecido recomendaciones y especificaciones acerca de la instalación,

configuración y construcción de cada nodo, con énfasis en el hardware de los nodos y la tecnología de red utilizada. La máquina descrita constituye el primer paso de un programa de desarrollo tecnológico en materia de supercómputo. Para fines del 2006 se concluirá la construcción de una máquina de memoria distribuida en configuración de hipercubo de hasta 256 nodos, y para fines del 2007 se pretende contar con una máquina de memoria compartida de características similares para satisfacer las aplicaciones más demandantes de la computación técnica y científica.

No se obtuvo mayor rendimiento con gigabit ethernet que utilizando fast ethernet. Como se

desprende de los experimentos de red realizados, por lo que se demuestra que para obtener un mayor rendimiento en gigabit ethernet es necesario tener en cuenta la arquitectura del nodo antes de migrar de la tecnología fase ethernet. El máximo throughput alcanzable depende fuertemente del bus PCI del nodo como así como también la velocidad del procesador y sus técnicas de manejar él cache.

También es factor de la capacidad que posean las tarjetas de red para acceder al resto

de los componentes que le dan la característica de acceder directo a memoria, realizar checksums de paquetes y de poseer su propia cache para el manejo de los sockets TCP, siendo necesario un bus PCI dedicado que le garantice la tasa de transferencia adecuada. No solo depende del hardware el desempeño de sistema sino también del la correcta configuración del los parámetros del protocolo de red TCP/IP.

Se debe tener en cuenta que todas las pruebas realizadas con NetPIPE dan un valor

máximo del throughput de la máquina paralela. Y que con el hardware actual es prácticamente imposible llegar a lograr el 50 % de la capacidad gigabit.

Con respecto a los sistemas de archivos disponibles, se ha podido comprobar que tener

configurados archivos ext3 y NFS, en el cluster brinda mayores posibilidades de uso posibilidades al momento de implementar una solución a un problema dado. En la aplicación de la prueba con el comando time, se demostró que NFS no es adecuado para procesamiento paralelo pues no tiene consistencia en cache. Por último, las particiones ext3 locales en cada uno de los nodos son buenas para ejecuciones seriales en los nodos internos del cluster pues se evita el uso de la red innecesariamente.

Con respecto a la compatibilidad de la máquina para poder aceptar lenguajes de

programación de estándares para procesamiento paralelo. La máquina paralela cumplió aceptando el estándar por de facto MPICH permitiéndole trabajar inclusive con otros sistemas operativos, también aceptó programas elaborados en otras plataformas que contengan el mismo entandar.

104

Esto permitió a la vez que la máquina paralela acepte otro tipo de programas que acepta el protocolo estándar MPI, como mpi-povray, el cual es un programa que permite la renderización y el modelado de gráficos de alto consumo computacional.

105

BIBLIOGRAFÍA Internetworking with TCP/IP. Volume I. Principles, Protocols and Architecture. Douglas E. Comer Editorial Prentice Hall ISBN: 0-13-216987-8 InternetWorking with TCP/IP. Volume II. Design, Implementation and Internals. Douglas E. Comer / David L. Stevens Editorial Prentice Hall ISBN: 0-13-134677-6 InternetWorking with TCP/IP. Volume III. Cliente - Server Programming and Applications. Douglas E. Comer / David L. Stevens Editorial Prentice Hall ISBN: 0-13-474222-2 UNIX. Programación Avanzada. Francisco Manuel Márquez García Editorial RA-MA, 1993 ISBN: 84-7897-112-2 El Lenguaje de Programación C. Brian W. Kerniguan / Dennis M. Ritchie Editorial Prentice Hall ISBN: 968-880-205-0 Aplique Turbo C++ Herbert Schildt Editorial Mc Graw Hill ISBN: 0-07-881610-6 Programación y Aplicaciones X Windows. Eric F. Johnson / Kevin Reichard Editorial Ra-Ma ISBN: 84-7897-065-7 El Libro de las Comunicaciones del PC. Técnica, Programación y Aplicaciones. José A. Caballar Editorial Ra-Ma ISBN: 84-7897-212-9

106

UNIX. Manual de Referencia. Sistema V. Versión 3. Stephen Coffin Editorial Mc Graw Hill ISBN: 0-07-881299-2 Sistemas Operativos: Diseño e Implementación. Andrew S. Tanenbaum Editorial Prentice Hall ISBN: 0-13-630302-1 Conéctate al Mundo de Internet. De Krol / O’Reilly & Associates, Inc. Editorial Mc Graw Hill ISBN: 970-10-0637-2 Tratamiento Digital de Imágenes. Alberto Domingo Ajenjo Editorial Anaya Multimedia ISBN: 84-7614-460-1 Robótica, Control, Visión e Inteligencia. K.S. Fu / R.C. González / C.S.G. Lee Editorial Mc Graw Hill ISBN: 0-07-022625-3

a

ANEXO A. BREVE HISTORIA DE TCP/IP

Internet fue propuesta originalmente por la precursora de DARPA, creadora de proyectos de investigación avanzada de la defensa (advanced research projets agency, ARPA), con una forma de probar la viabilidad de las redes de conmutación de paquetes. (Cuando el enfoque de ARPA se volvió de naturaleza militar, se cambio el nombre. Durante su estadía en el proyecto, ARPA previo una red de líneas rentadas conectadas por nodos de conmutación. La red se denominó ARPAnet y los nodos se conocieron como procesadores de Mensajes de Internet (IMPs).

ARPAnet inicialmente está formada por cuatro IMPs. En 1971 ARPAnet entró en servicio normal. Las máquinas utilizaron ARPAnet mediante la conexión a un IMP y utilizando el protocolo "1822" (número del documento técnico que describía el sistema).

Una necesidad comúnmente reconocida era la capacidad de transferir archivos de una máquina a otra, así como la capacidad de aceptar registro de entrada remoto no podían ser realizados hasta que se implementaron en un protocolo conocido como Programa de Control de Red (Network Control Program, NCP) que cumplía con estos requisitos. Más adelante, a través de FTP (Protocolo de Transferencia de Archivo, File Transfer Protocol) se añadió el correo electrónico y junto con el registro y la transferencia de archivos remotos de NCP, se conformaron los servicios de ARPAnet.

Al llegar 1973 resultaba claro que NCP era incapaz de manejar el volumen de tráfico y la nueva funcionalidad propuesta. Se inició un proyecto con el objetivo de desarrollar un nuevo protocolo. El nacimiento de TCP/IP y las arquitecturas de las compuertas fueron propuestos por primera vez en 1974. El artículo publicado por Cerf y Kahn describía un sistema que incluía un protocolo de aplicación estandarizada, que también utilizaba confirmaciones de extremo a extremo. También, proponían conectividad universal a través de la red. Estas dos ideas eran radicales en un mundo de hardware y software propietarios, porque permitirían que cualquier tipo de plataforma participara en la red. El protocolo fue creado y se conoció como TCP/IP.

Ya que dentro de un sistema TCP/IP los datos transmitidos se dividen en pequeños paquetes, éstos resaltan una serie de características. La tarea de IP es llevar los datos a granel (los paquetes) de un sitio a otro. Las computadoras que encuentran las vías para llevar los datos de una red a otra (denominadas enrutadores) utilizan IP para trasladar los datos. En resumen IP mueve los paquetes de datos a granel, mientras TCP se encarga del flujo y asegura que los datos estén correctos.

Las líneas de comunicación se pueden compartir entre varios usuarios. Cualquier tipo de paquete puede transmitirse al mismo tiempo, y se ordenará y combinará cuando llegue a su destino. Compare esto con la manera en que se transmite una conversación telefónica: una vez que establece una conexión, se reservan algunos circuitos para usted, que no puede emplear en otra llamada, aun si deja esperando a su interlocutor por veinte minutos.

Los datos no tienen que enviarse directamente entre dos computadoras. Cada paquete pasa de computadora en computadora hasta llegar a su destino. Éste, claro está, es el secreto de como se pueden enviar datos y mensajes entre dos computadoras aunque no estén conectadas directamente entre sí. Lo que realmente sorprende es que sólo se necesitan algunos segundos para enviar un archivo de

b

buen tamaño de una máquina a otra, aunque estén separadas por miles de kilómetros y pese a que los datos tienen que pasar por múltiples computadoras. Una de las razones de la rapidez es que, cuando algo anda mal, sólo es necesario volver a transmitir un paquete, no todo el mensaje. Los paquetes no necesitan seguir la misma trayectoria. La red puede llevar cada paquete de un lugar a otro y usar la conexión más idónea que esté disponible en ese instante. No todos los paquetes de los mensajes tienen que viajar, necesariamente, por la misma ruta, ni necesariamente tienen que llegar todos al mismo tiempo.

La flexibilidad del sistema lo hace muy confiable. Si un enlace se pierde, el sistema usa otro. Cuando usted envía un mensaje, el TCP divide los datos en paquetes, ordena éstos en secuencia, agrega cierta información para control de errores y después los lanza hacia fuera, y los distribuye. En el otro extremo, el TCP recibe los paquetes, verifica si hay errores y los vuelve a combinar para convertirlos en los datos originales. De haber error en algún punto, el programa TCP destino envía un mensaje solicitando que se vuelvan a enviar determinados paquetes.

TCP/IP es el protocolo común utilizado por todas las computadoras son conectadas a Internet, de manera que éstos puedan comunicarse entre sí. Hay que tener en cuenta que en Internet se encuentran conectadas computadoras de clases muy diferentes y con hardware y software incompatibles en muchos casos, además de todos los medios y formas posibles de conexión. Aquí se encuentra una de las grandes ventajas del TCP/IP, pues este protocolo se encargará de que la comunicación entre todos sea posible. TCP/IP es compatible con cualquier sistema operativo y con cualquier tipo de hardware. TCP/IP no es un único protocolo, sino que es en realidad lo que se conoce con este nombre es un conjunto de protocolos que cubren los distintos niveles del modelo OSI. Los dos protocolos más importantes son el TCP (Transmisión Control Protocol) y el IP (Internet Protocol), que son los que dan nombre al conjunto. La arquitectura del TCP/IP consta de cinco niveles o capas en las que se agrupan los protocolos y que se relacionan con los niveles OSI de la siguiente manera:

a) Aplicación: Se corresponde con los niveles OSI de aplicación, presentación y sesión. Aquí se incluyen protocolos destinados a proporcionar servicios, tales como correo electrónico (SMTP), transferencia de archivos (FTP), conexión remota (TELNET) y otros más recientes como el protocolo HTTP (Hypertext Transfer Protocol).

b) Transporte: Coincide con el nivel de transporte del modelo OSI. Los protocolos de este nivel,

tales como TCP y UDP, se encargan de manejar los datos y proporcionar la fiabilidad necesaria en el transporte de los mismos.

c) Internet: Es el nivel de red del modelo OSI. Incluye al protocolo IP, que se encarga de enviar los

paquetes de información a sus destinos correspondientes. Es utilizado con esta finalidad por los protocolos del nivel de transporte.

d) Físico: Análogo al nivel físico del OSI.

e) Red: Es la interfaz de la red real. TCP/IP no especifica ningún protocolo concreto, así es que

corre por las interfaces conocidas, como por ejemplo: 802.2, CSMA/CD, X.25, etc.

c

El protocolo TCP/IP necesita funcionar sobre algún tipo de red o de medio físico que proporcione sus propios protocolos para el nivel de enlace de Internet. Por este motivo hay que tener en cuenta que los protocolos utilizados en este nivel pueden ser muy diversos y no forman parte del conjunto TCP/IP. Sin embargo, esto no debe ser problemático puesto que una de las funciones y ventajas principales del TCP/IP es proporcionar una abstracción del medio de forma que sea posible el intercambio de información entre medios diferentes y tecnologías que inicialmente son incompatibles. Para transmitir información a través de TCP/IP, ésta debe ser dividida en unidades de menor tamaño. Esto proporciona grandes ventajas en el manejo de los datos que se transfieren y, por otro lado, esto es algo común en cualquier protocolo de comunicaciones. En TCP/IP cada una de estas unidades de información recibe el nombre de "datagrama" (datagram), y son conjuntos de datos que se envían como mensajes independientes.

Para mucha gente los términos TCP/IP y Ethernet van juntos casi en forma automática, principalmente por razones históricas, así como por el simple hecho de que más redes basadas en Ethernet con TCP/IP que cualquier otro tipo. Ethernet se desarrolló originalmente en el Centro de Investigaciones de Palo Alto de XEROX (PARC), como un paso hacia un sistema electrónico de comunicaciones de oficina y desde entonces ha crecido en capacidad y popularidad.

Ethernet es un sistema de hardware proporcionado para las capas de vínculo de datos y

física del modelo OSI. Como parte de los estándares de Ethernet, se establecen los tipos de cable y las velocidades de difusión. Hay varias versiones distintas de Ethernet, cada una de ellas con una velocidad diferente de transferencia de datos. La más común es Ethernet versión 2, también conocida como 10base5, Thick Ethernet e IEEE 802.3 (Institute of Electrical and Electronic Engineers, IEEE). Este sistema tiene una velocidad de 10 megabits por segundo. Ambos tienen sus propios procesos para el empaquetado de la información: TCP/IP utiliza direcciones de 32 bits, en tanto que Ethernet emplea un esquema de 48 bits.

El protocolo de transporte de clase 4 del modelo OSI (al que con frecuencia se le llama TP4), y TCP tienen numerosas similitudes, pero también algunas diferencias. A continuación se dan a conocer los puntos en que los dos protocolos son iguales. Los dos protocolos están diseñados para proporcionar un servicio de transporte seguro, orientado a conexión y de extremo a extremo, sobre una red insegura, que puede perder, dañar, almacenar y duplicar paquetes. Los dos deben enfrentarse a los peores problemas como sería el caso de una subred que pudiera almacenar una secuencia válida de paquetes y más tarde volviera a entregarlos.

Los dos protocolos también son semejantes por el hecho de que los dos tienen una fase de

establecimiento de conexión, una fase de transferencia de datos y después una fase de liberación de la conexión. Los conceptos generales del establecimiento, uso y liberación de conexiones también son similares, aunque difieren en algunos detalles. En particular, tanto TP4 como TCP utilizan la comunicación ida-vuelta-ida para eliminar las dificultades potenciales ocasionadas por paquetes antiguos que aparecieran súbitamente y pudiesen causar problemas. Sin embargo, los dos protocolos también presentan diferencias muy notables.

Primero, TP4 utiliza nueve tipos diferentes de UTP, en tanto que TCP sólo tiene uno. Esta

d

diferencia trae como resultado que TCP sea más sencillo, pero al mismo tiempo también necesita una cabecera más grande, porque todos los campos deben estar presentes en todas las TPDU. El mínimo tamaño de la cabecera TCP es de 20 octetos; el mínimo tamaño de la cabecera TP4 es de 5 octetos. Los dos protocolos permiten campos opcionales, que pueden incrementar el tamaño de las cabeceras por encima del mínimo permitido.

Una segunda diferencia es con respecto a lo que sucede cuando los dos procesos, en forma simultánea, intentan establecer conexiones entre los mismos dos TSAP (es decir, una colisión de conexiones). Con TP4 se establecen dos conexiones duplex independientes; en tanto que con TCP, una conexión se identifica mediante un par de TSAP, por lo que solamente se establece una conexión.

Una tercera diferencia es con respecto al formato de direcciones que se utiliza. TP4 no especifica el formato exacto de una dirección TSAP; mientras que TCP utiliza números de 32 bits.

El concepto de calidad de servicio también se trata en forma diferente en los dos

protocolos, constituyendo la cuarta diferencia. TP4 tiene un mecanismo de extremo abierto, bastante elaborado, para una negociación a tres bandas sobre la calidad de servicio. Esta negociación incluye al proceso que hace la llamada, al proceso que es llamado y al mismo servicio de transporte. Se pueden especificar muchos parámetros, y pueden proporcionarse los valores: deseado y mínimo aceptable. A diferencia de esto, TCP no tiene ningún campo de calidad de servicio, sino que el servicio subyacente IP tiene un campo de 8 bits, el cual permite que se haga una relación a partir de un número limitado de combinaciones de velocidad y seguridad.

Una quinta diferencia es que TP4 permite que los datos del usuario sean transportados en

la TPDU CR, pero TCP no permite que los datos del usuario aparezcan en la TPDU inicial. El dato inicial (como por ejemplo, una contraseña), podría ser necesario para decidir si se debe, o no, establecer una conexión. Con TCP no es posible hacer que el establecimiento dependa de los datos del usuario.

Las cuatro diferencias anteriores se relacionan con la fase de establecimiento de la conexión. Las cinco siguientes se relacionan con la fase de transferencia de datos. Una diferencia básica es el modelo del transporte de datos. El modelo TP4 es el de una serie de mensajes ordenados (correspondientes a las TSDU en la terminología OSI). El modelo TCP es el de un flujo continuo de octetos, sin que haya ningún límite explícito entre mensajes. En la práctica, sin embargo, el modelo TCP no es realmente un flujo puro de octetos, porque el procedimiento de biblioteca denominado push puede llamarse para sacar todos los datos que estén almacenados, pero que todavía no se hayan transmitido.

Cuando el usuario remoto lleva a cabo una operación de lectura, los datos anteriores y posteriores al push no se combinarán, por lo que, en cierta forma un push podría penarse como si definiesen una frontera entre mensajes.

La séptima diferencia se ocupa de cómo son tratados los datos importantes que necesitan de un procesamiento especial. TP4 tiene dos flujos de mensajes independientes, los datos normales y los acelerados multiplexados de manera conjunta. En cualquier instante únicamente un mensaje acelerado puede estar activo. TCP utiliza el campo acelerado para indicar que cierta cantidad de octetos, dentro de la TPDU actualmente en uso, es especial y debería procesarse fuera de orden.

e

La octava diferencia es la ausencia del concepto de superposición en TP4 y su presencia en TCP. Esta diferencia no es tan significativa como al principio podría parecer, dado que es posible que una entidad de transporte ponga dos TPDU, por ejemplo, DT y AK en un único paquete de red.

La novena diferencia se relaciona con la forma como se trata el control de flujo. TP4 puede utilizar un esquema de crédito pero también se puede basar en el esquema de ventana de la capa de red para regular el flujo. TCP siempre utiliza un mecanismo de control de flujo explícito con el tamaño de la ventana especificado en cada TPDU.

La décima diferencia se relaciona con este esquema de ventana. En ambos protocolos el receptor tiene la capacidad de reducir la ventana en forma voluntaria. Esta posibilidad genera potencialmente problemas, si el otorgamiento de una ventana grande y su contracción subsiguiente llegan en un orden incorrecto. En TCP no hay ninguna solución para este problema; en tanto en TP4 éste se resuelve por medio del número de subsecuencia que está incluido en la contracción, permitiendo de esta manera que el emisor determine si la ventana pequeña siguió, o precedió, a la más grande.

Finalmente, la onceava y última diferencia existente entre los dos protocolos, consisten en la manera como se liberan las conexiones. TP4 utiliza una desconexión abrupta en la que una serie de TPDU de datos puede ser seguido directamente por una TPDU DR. Si las TPDU de datos se llegaran a perder, el protocolo no los podría recuperar y la información, al final se perdería. TCP utiliza una comunicación de ida-vuelta-ida para evitar la pérdida de datos en el momento de la desconexión. El modelo OSI trata este problema en la capa de sesión. Es importante hacer notar que la Oficina Nacional de Normalización de Estados Unidos estaba tan disgustada con esta propiedad de TP4, que introdujo TPDU adicionales en el protocolo de transporte para permitir la desconexión sin que hubiera una pérdida de datos. Como consecuencia de esto, las versiones de Estados Unidos y la internacional de TP4 son diferentes.

Es importante señalar que el protocolo IP explicado anteriormente, o mejor dicho la versión de éste es la más utilizada actualmente, pero hace muy poco tiempo salió una nueva versión llamada la número 6. Las diferencias no son muchas, pero mejoran muchos aspectos de la antigua, ésta no es muy utilizada, pero creemos que es necesario explicar como funciona, para poder hacer una comparación con la antigua.

Una red TCP/IP transfiere datos mediante el ensamblaje de bloques de datos en paquetes, cada paquete comienza con una cabecera que contiene información de control; tal como la dirección del destino, seguido de los datos. Cuando se envía un archivo por la red TCP/IP, su contenido se envía utilizando una serie de paquetes diferentes. El Internet protocol (IP), un protocolo de la capa de red, permite a las aplicaciones ejecutarse transparentemente sobre redes interconectadas. Cuando se utiliza IP, no es necesario conocer que hardware se utiliza, por tantota aplicación corre en una red de área local. El Transmissión Control Protocol (TCP); un protocolo de la capa de transporte, asegura que los datos sean entregados, que lo que se recibe, sea lo que se pretendía enviar y que los paquetes que sean recibidos en el orden en que fueron enviados. TCP terminará una conexión si ocurre un error que haga la transmisión fiable imposible.

f

La primera vez que uno oye hablar de Internet, casi siempre es en relación con el nombre TCP/IP, en muchos casos se habla de TCP/IP como "el protocolo que se usa en Internet" o "que hace funcionar Internet". Como explicación coloquial es válida, pero IP y TCP son dos protocolos con funciones específicas y diferenciadas. Pero cuando se habla de TCP/IP no se está hablando únicamente de estos dos protocolos, sino de toda una familia con fines diversos, que han constituido la arquitectura de la actual red Internet. Entre ellos, por supuesto, se encuentra el fundamental, Internet Protocol o IP, encargado de generar el internet virtual. TCP proporciona el nivel de transporte más empleado, pero es posible encontrar otros protocolos de transporte en Internet como UDP. Otros protocolos vienen a servir de apoyo a éstos, como ICMP y, para realizar una comunicación, será necesario resolver muchos otros problemas como la correspondencia entre direcciones físicas y lógicas para lo que se emplean protocolos como ARP, RARP y BOOTP; el mantenimiento de una información de rutas consistente, a través de protocolos de encaminamiento como GGP, EGP, OSPF o RLP; la administración de red para lo que se define otros protocolos como NSMP la accesibilidad de una serie de servicios finales en forma de aplicación a través de otra serie de protocolos como TELNET, FTP,TFTP o SMTP. A todos ellos y otros muchos, se alude cuando se menciona TCP/IP de forma genérica.

Desde el momento que surgió Ethernet la necesidad de realizar una conexión entre

distintas redes, se fija como primer objetivo ocultar no sólo el hardware sino, también, el tipo de red sobre el que se sustenta la comunicación, para lo que se define una serie de servicios universales de comunicación.

Este objetivo de transparencia puede alcanzarse a través de los programas de aplicación que de encarguen de tratar en cada máquina con la red y el hardware específico con que ésta cuenta proporcionando un sistema uniforme en la red. Sin embargo, este enfoque si bien es más intuitivo y concreto y a veces se emplea en programas reducidos para resolver un problema bien definido, presenta grandes problemas en cuanto el escenario aparece como un conjunto heterogéneo más o menos numeroso y, sobre todo, cuando se persigue cierta generalidad. Así, si en determinado momento se desea incorporar una nueva funcionalidad, es necesario desarrollar código para cada diferente arquitectura.

Una posibilidad consiste en ceder una API (interfaces de programas de aplicaciones) de comunicaciones implementando internamente una arquitectura de protocolos. Desde este punto de vista se generará una inter-red virtual interconectada a través de un protocolo encargado de generar esta imagen de red virtual, al que se denomina protocolo de red. Esta arquitectura puede estar constituida por una serie de protocolos de propósito general, independiente de las aplicaciones, que se encarguen de transmitir fragmentos de información desde un origen a un destino sin importarles la naturaleza de la información que transportan. Por otra parte, al tratar los protocolos con fragmentos de información es posible realizar un tratamiento más eficiente.

Con esta perspectiva, los programadores de aplicaciones emplean la API del sistema para

realizar la comunicación necesaria sin necesidad de preocuparse por los mecanismos reales de esta comunicación separando una problemática de otra.

I

ANEXO B. CRONOLOGÍA DEL PROCESAMIENTO EN PARALELO. Año Suceso

1955 El IBM 704 usa circuitos aritméticos paralelos binarios junto con una unidad de punto flotante que aceleraban significativamente el desarrollo de operaciones numéricas frente a las tradicionales unidades aritmético-lógicas (el arquitecto del sistema es Gnetne Amdahl). A pesar de su velocidad (aprox. 5kFLOPS), las operaciones de E/S resultaban lentas y representaban un cuello de botella. Como solución a este problema la IBM decide incorporar procesadores de E/S independientes (y posteriormente llamados canales) en modelos posteriores de la 704 y su sucesor, la IBM 709.

1956 IBM inicia el proyecto 7030 (también llamado STRETCH) para producir una supercomputadora para el Laboratorio Nacional Los Álamos. Su meta es crear una máquina 100 veces más poderosa que las de su época.

Se inicia el proyecto LARC (Livermore Automatic Research Computer), el diseño de una supercomputadora para el Laboratorio Nacional Livermore. El proyecto Atlas comienza como una aventura conjunta entre la Universidad de Manchester y Ferranti Ltd. El arquitecto principal es Tom Kilburn.

1958 Bull anuncia la Gamma 60 con múltiples unidades funcionales e instrucciones fork y join en su conjunto de instrucciones. Llegaron a construirse 19.

John Cocke y Daniel Slotnick discuten el uso del paralelismo en cálculos numéricos en un memorandum de la IBM. Posteriormente Slotnick propone la SOLOMON, una máquina SIMD con 1024 elementos de procesamiento de 1 bit, cada uno con memoria para 128 valores de 32 bits. La máquina nunca se construye pero es el punto de arranque para trabajos posteriores.

1959 Sperry Rand entrega el primer sistema LARC, el cual dispone de un procesador de E/S independiente que operaba en paralelo con una o dos unidades de procesamiento. Sólo se construyeron dos.

IBM entrega su primera STRETCH, que presentaba la anticipación de instrucciones y corrección de errores. Se construyen 8. La tecnología es reutilizada en la IBM 7090.

La primera IBM 7090 es entregada. Esta es la versión transistorizada de la IBM 709.

II

1960 Control Data inicia el desarrollo de su CDC 6600.

E. V. Yevreinov en el Instituto de Matemáticas en Novosibirsk (IMN) comienza sus trabajos en arquitecturas fuertemente acopladas de paralelismo burdo con interconexiones programables.

1962 CDC entrega su primera CDC 1604, máquina similar a la IBM 7090 caracterizada por palabras de 48 bits y ciclos de memoria de 6µs. La computadora Atlas es operacional. Es la primera máquina en usar memoria virtual y paginación, su ejecución de instrucciones es en oleoducto (pipelined), y contiene unidades aritméticas de punto flotante y punto fijo separadas. Su desempeño es de aproximadamente 200kFLOPS.

C. A. Petri describe las Redes de Petri, un concepto teórico para la descripción y análisis de las propiedades de sistemas concurrentes.

Burroughs introduce su multiprocesador MIMD simétrico D825. Cuenta de 1 a 4 CPUs que acceden a 1 ó 16 módulos de memoria usando un conmutador de barraje cruzado (crossbar switch). Las CPUs son similares al posterior B5000, el sistema operativo es simétrico con una cola compartida (shared ready queue).

1964 Control Data Corporation empieza a producir la CDC 6600, la primer supercomputadora en ser un éxito técnico y comercial. Cada máquina tiene una CPU de 60 bits y 10 unidades periféricas de procesamiento (PPUs). La CPU utiliza un marcador para manejar la dependencia de instrucciones.

IBM inicia el diseño del Advanced Computer System (ACS), capaz de manejar hasta siete instrucciones por ciclo. El proyecto fue cerrado en 1969 pero muchas de las técnicas fueron incorporadas en posteriores computadores.

Daniel Slotnick propone la construcción de una computadora paralela masiva para el Laboratorio Nacional Livermore, pero la Comisión de Energía Atómica da el contrato a CDC, que construye la STAR-100. Slotnick consigue el financiamiento de la U.S. Air Force y su diseño evoluciona a la ILLIAC-IV. La máquina es construida en la Universidad de Illinois, con Burroughs y Texas Instruments como principales subcontratistas. La Advanced Scientific Computer (ASC) de la Texas Instruments crece junto a esta iniciativa.�

III

1965 General Electric, el MIT, y AT&T Bell Laboratories comienzan a trabajar en Multics. El objetivo del proyecto es la construcción de un sistema operativo de propósito General de memoria compartida, multiprocesamiento y tiempo compartido. Edsger Dijkstra describe y nombra el Problema de las Regiones Críticas. Mucho del trabajo posterior en sistemas concurrentes es dedicado a encontrar eficientes y seguras formas de manejar regiones críticas.

James W. Cooley y John W. Tukey describen el Algoritmo de la Transformada Rápida de Fourier, que es posteriormente uno de los más grandes consumidores de ciclos de punto flotante.

1976 Marzo

La Cray-1 es la primera computadora en usar el procesamiento vectorial y tenía

una capacidad de procesamiento pico de 100 MFLOPS. Frecuencia de reloj 110 MHz; 9 ns ciclo del núcleo.

Cortesia de M. en C. Eduardo René Rodríguez Ávila [13].

13 Extracto de Principia, Sección de historia de la computación, URL: http://homepage.mac.com/eravila/history.html

IV

ANEXO C. FUNCIONES BÁSICAS DE MPICH

Aún cuando MPI incluye más de 125 funciones, se puede trabajar en la creación de cualquier programa en paralelo con sólo seis. Estas funciones se describen a continuación tanto en su sintaxis para Fortran como para C. También se describe el tipo de dato de aquellos argumentos de las funciones que no son inherentes a MPI. Los argumentos se describen en la tabla I y ahí se define el tipo de dato de los argumentos MPI.

MPI predefine una serie de variables y de estructuras de datos inherentes a su funcionamiento y estas se encuentran en un archivo de encabezado que debe ser incluido en todo código que use MPI. La siguiente instrucción debe agregarse en la parte inicial del código:

a. En Fortran: include "mpif.h". b. En C: #include <mpi.h>

Las siguientes instrucciones inicializan el ambiente de trabajo en paralelo: a. En fortran: Call MPI_INIT (ierr).

b. En C: MPI_INIT(&argc,argv)

Con las siguientes instrucciones MPICH inicializa varias estructuras de datos inherentes al

ambiente de trabajo MPI. Si el ambiente no se puede inicializar, el programa se detiene por completo: a. En fortran: Call MPI_COMM_SIZE(comm.,size,ierr).

b. En C: MPI_COMM_SIZE(comm.., size)

La siguiente función, regresa el número de procesadores así como un comunicador por

default, comm = MPI_WORLD_COMM, el cual indica el conjunto de todos los procesadores asignados a la ejecución del programa. Posteriormente, el usuario puede definir otros comunicadores para designar subconjuntos de procesadores.

a. En fortran: call MPI_COMM_RANK (comm, rank, ierr). b. En C: MPI_COMM_RANK(comm, rank)

V

La primitiva send, envía un mensaje a otro procesador. El procesador origen espera que el

procesador destinatario haya recibido el mensaje antes de continuar trabajando. a. Fortran: call MPI_SEND(buf, count, datatype, dest, tag, comm, ierr).

b. En C: MPI_Send(&buf, count, datatype, dest, tag, comm).

Se dispone a recibir un mensaje de parte de otro procesador. El procesador destinatario no puede continuar su trabajo hasta haber recibido dicho mensaje.

a. Fortran: call MPI_RECV(buf, count, datatype, source, tag, comm, status, ierr).

b. En C: MPI_Recv(&buf, count, datatype, source, tag, comm, &status)

La siguiente función, cierra el ambiente de trabajo en paralelo una vez finalizado el trabajo:

a. Fortran: call MPI_FINALIZE(ierr). b. En C: MPI_Finalize(.)

Los argumentos de las funciones tienen el siguiente significado:

Al iniciar la ejecución de un programa en paralelo, la instrucción MPI_COMM_SIZE regresa un comunicador por default: MPI_COMM_WORLD, el cual contiene los números que corresponden a cada uno de los procesadores que se asignan para la ejecución del programa. Esta información es utilizada por la mayoría de las funciones MPI para saber cuáles son los procesadores de la computadora que se han de comunicar entre si para efectuar dicha función. Posteriormente, el usuario puede seleccionar subconjuntos de procesadores a partir de los procesadores definidos en MPI_COMM_WORLD para obtener otros comunicadores. El tipo de dato de MPI_COMM_WORLD es definido como MPI_Comm en mpif.h, mpi.h.

Los tipos de datos reconocidos por MPI son definidos en la tabla II siguiente.

VI

Argc Número de argumentos en la línea de comandos (C).

Argv Argumentos en la línea de comandos (C).

Buf Variable que contiene la información a comunicar.

Comm Comunicador que incluye el número de cada procesador miembro de un ambiente de trabajo en paralelo. Al iniciar la ejecución de un programa en paralelo, la instrucción MPI_COMM_SIZE regresa un comunicador por default: MPI_COMM_WORLD, el cual contiene los números que corresponden a cada uno de los procesadores que se asignan para la ejecución del programa.

Count Cantidad de elementos contenidos en buf.

datatype Tipo de la variable buf. Los tipos de datos reconocidos por MPI son definidos en la tabla 2.

Dest Número lógico del procesador al cual se ha transferido información.

errorcode Entero que identifica una situación asociada con error en proceso. Algunas implementaciones de MPI regresan este valor como si fuera producto de una instrucción return errorcode.

Iré Código de error de implementación que es igual a MPI_SUCCESS sí la función termina con éxito; de otra manera, el valor de ierr corresponde a un valor que depende de la implementación de MPI.

Rank Número lógico del procesador.

Op Operación a ejecutar.

Outsize Tamaño de buffer de salida.

position Posición del último elemento alimentado o recuperado de un buffer.

Recvbuf Variable que contiene la información a recibir.

recvcount Cantidad de elementos contenidos en recvbuf.

recvdatatype Tipo de la variable recvbuf. Los tipos de datos reconocidos por MPI son definidos en la tabla II.

Request En combinación con las funciones MPI_TEST y MPI_WAIT proporciona información sobre el estado de una función MPI_ISEND o MPI_IRECV.

sendbuf Variable que contiene la información a comunicar.

sendcount Cantidad de elementos contenidos en senbuf.

senddatatype Tipo de la variable senbuf. Ver tabla II.

Size Número de procesadores asignados al programa.

Source Número lógico del procesador que ha enviado información.

Status Arreglo de tamaño MPI_STATUS_SIZE. Auxiliar en conocer el estado de ejecución de una función MPI.

Tag Identifica el envío. Generalmente es cero y sólo cambia cuando se ha de comunicar más de un envío.

Target Número lógico del procesador a quien se envía información.

Tabla I. Argumentos de funciones MPI.

VII

MPI C MPI Fortran MPI_CHAR signed char MPI_INTEGER INTEGER

MPI_SHORT signed short int MPI_REAL REAL

MPI_INT signed int MPI_DOUBLE_PRECISION DOUBLE PRECISION

MPI_LONG signed long int MPI_COMPLEX COMPLEX

MPI_UNSIGNED_CHAR unsigned char MPI_LOGICAL LOGICAL

MPI_UNSIGNED_SHORT unsigned short int MPI_CHARACTER CHARACTER

MPI_UNSIGNED unsigned int MPI_BYTE

MPI_UNSIGNED_LONG unsigned long int MPI_PACKED

MPI_FLOAT float

MPI_DOUBLE double

MPI_LONG_DOUBLE long double

MPI_BYTE

MPI_PACKED

Tabla II. Correspondencia entre tipos de datos en MPI, Fortran y C.

A

ANEXO D. NETPIPE.

NetPIPE es una herramienta independiente del funcionamiento del protocolo que

representa visualmente la red bajo una gran variedad de condiciones. Realiza las pruebas simples de los mensajes tipo ping-pong que incrementan el tamaño de procesamiento entre dos procesos a través de una red o dentro de un sistema de SMP.

El tamaño del mensaje puede elegirse a intervalos regulares, y con perturbaciones leves, con el fin de proporcionar una prueba completa del sistema de comunicación. Cada punto de referencias implica muchas pruebas del ping-pong para proporcionar una sincronización exacta. Los estados latentes son calculados dividiendo el tiempo redondo del viaje por la mitad para los mensajes pequeños generalmente en octetos menores a 64 Kbytes.

NetPIPE fue desarrollado originalmente en la LCC por Quinn Snell, Armin Mikler y Juan Gustafson. El código ha sido desarrollado y mantenido por Dave Turner desde octubre de 2000 con contribuciones diversas. Los módulos que se han agregado desde su creación involucran librerías de prueba para PVM, TCGMSG, y los estándares para MPI y Mpi-2.

El archivo de instalación es llamado Netpipe_3.6.2.tar.gz y para instalarlo es necesario hacer

lo siguiente:

1. Colocar el archivo Netpipe_3.6.2.tar.gz en un directorio llamado netpipe. 2. Descomprimir el archivo utilizando el comando tar –zxvf Netpipe_3.6.2.tar.gz

3. Utilizar el comando ./configure para crear el archivo make. 4. Utilizar el comando make para crear el ejecutable y a continuación make install

para que el archivo se encuentre completamente instalado.