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

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
1

2

INSTITUTO POLITECNICO NACIONAL
COORDINACION GENERAL DE POSGRADO E INVESTIGACION
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.
3

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.
4

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

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
6

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.
7

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
8

RESUMEN.
“CONSTRUCCIÓN DE UNA MÁQUINA PARALELA
PARA CENTROS DE INVESTIGACIÓN “
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.
9

“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 industrystandard
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.
10

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.
11

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.
12

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
13

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
14

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.
15

Í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
16

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
17

DESCRIPCIÓN
LISTA DE FIGURAS Y TABLAS
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
18

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
19

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
20

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 IBM 1 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.
1

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
2

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.
3

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
4

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
5

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.
6

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).
7

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.
8

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
9

• 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).
10

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.
11

• 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.
12

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
13

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
14

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
15

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
16

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.
17

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
Organización de computadoras Andrew S. Tanenbaum
MISD Fuente:
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.
18

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.
19

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
20

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
21

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
22

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.
23

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
24

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.
25

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.
26

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)
27

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.
28

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

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.
30

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
Nivel de proceso
Nivel de instrucción
Nivel de variable
Nivel de bit
compartida
Paralelo
Redes de computadoras
Multicomputadoras
Paso de mensajes
Memoria
Multiprocesadores
Granularidad del
algoritmo
Grado de acoplamiento
Modo de comunicación
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.
31

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
32

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.
33

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(N 2 ), siendo N el número de
procesadores.
M1 M2 M3
P1
S S S
P2
S S S
P2
S S S
Figura 14.- Red Crossbar
34

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.
1
2
N
……
……
1
2
N
Figura 16.- Red multietapa
Etapa 1 Etapa 2
Etapa k
35

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.
1
n
4 x 2
1
3 x 3
2 x 4
1
1
n
1
12
inputs
1
n
r
m
r x r
r
1
n
12
outputs
n x m
m x n
Figura 17.- Red Multietapa estrictamente no bloqueante.
36

. No bloqueantes re configurables: pueden realizar todas las conexiones posibles reconfigurando
conexiones existentes (si m >= n) .Ver figura 18.
0
1
0
1
2
3
2
3
4
5
4
5
6
7
6
7
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í.
37

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.
38

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

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.
40

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.
Tabla 5. Tercer Ciclo.
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)
41

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
Dando una aceleración máxima de :
NTl = 9N unidades de tiempo
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.
42

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.
máxima a:
Para esta estrategia con valores grandes de N, la dependencia de datos limita la aceleración
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 pipeliningschedule
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.
43

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
44

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 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.
45

• 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.
46

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).
47

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.
48

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.
49

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.
50

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.
51

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.
52

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
53

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.
54

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 (m c ).Tiempo que se tarda en completar una referencia a memoria.
m c = k * τ klatencia >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 + m r * k (ciclos/instrucción)
Donde el total de ciclos del procesador (p), referencias a memoria por ciclo (m r ).
Tp = Ic * CPI * τ = Ic * (p + m r * k) * τ (nanosegundos)
En la tabla 7 se muestra la relación entre factores de rendimiento y atributos del sistema
Arquitectura
Ic p m r K τ
X
Tecnología
compilador
Implantación y
control CPU
Jerarquía
memoria
X X X
X
X
X
X
55

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, m r , 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 * 10 6 ) = (Ic * f) / (Ic * CPI * 10 6 ) = f / (CPI * 10 6 )
MIPS = f / (C/Ic * 10 6 ) = (f * Ic) / (C * 10 6 ) [ 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 * 10 6 )/(Ic * CPI) = (MIPS * 10 6 )/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).
56

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(x i ) ^ 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:
f
f
i+
1
′
i
=
h
−
f
i
2
h h
− ⋅ f
i
′′−
2 6
⋅
f ′−′′
i
Κ
[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:
f
f
− f
h
i+1
i
′
i
= +
E
[3], dónde
h
E ≈ − ⋅ f i
′
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:
f
f
−
i i−1
′
i
=
h
f
h
+ ⋅
2
2
h
fi′′−
6
⋅
f ′′−′
i
Κ
y
f
f
− f
h
i i−1
′
i
= +
E
[5] dónde
h
E ≈ ⋅ f i
′
2
57

′′′
La aproximación anterior se denomina de diferencia hacia atrás.
Tomemos ahora ambas aproximaciones y restemos 4 de 1:
1 3
f i+
− f i−
= ⋅ h ⋅ f i
′+ ⋅ h ⋅ f i
′′+′
1 1
2
Κ
3
[6]
De la anterior expresión se ha eliminado el término fi´´. Resolviendo para fi´, obtenemos
fi+
1
− f
i−1
1 2
f ′ = − ⋅ ⋅ ′′+′
i
h f
i
Κ
2 ⋅ h 6
[7].
Con el término de error incluido, la aproximación de diferencia central se expresa como
f
i+
1
− f
i−1
1 2
f ′
i
= + E E ≈ − ⋅ h ⋅ f i
′′′
2 ⋅ h [8], dónde 6 .
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
fi+
1
− f
i
1
f ′
i
= + E ; E ≈ − ⋅ h ⋅ f ′′
i
h
2
− fi+
2
+ 4 ⋅ fi+
1
− 3⋅
fi
1 2
f ′
i
=
+ E ; E ≈ ⋅ h ⋅ f
i
2 ⋅ h
3
2 ⋅ fi+
3
− 9 ⋅ f
i+
2
−18⋅
fi+
1
−11⋅
fi
1 3
f ′
i
=
+ E ; E ≈ − ⋅ h
6 ⋅ h
4
Aproximaciones de diferencia hacia atrás
fi
− fi−
1
1
f ′
i
= + E ; E ≈ ⋅ h ⋅ f ′′
i
h
2
+ f
i−2
− 4 ⋅ f
i−1
+ 3⋅
f
i
1 2
f ′
i
=
+ E ; E ≈ ⋅ h ⋅ f ′′′
i
2 ⋅ h
3
− 2 ⋅ fi−3
+ 9 ⋅ fi−2
−18
⋅ f
i−1
+ 11⋅
fi
1 3
f ′
i
=
+ E ; E ≈ ⋅ h
6 ⋅ h
4
Aproximaciones de diferencia centrales
⋅ f
⋅ f
IV
i
IV
i
58

59
V
i
i
i
i
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
f
h
E
E
h
f
f
f
⋅
⋅
≈
+
⋅
+
⋅
−
⋅
+
−
=
′
′′′
⋅
⋅
≈ −
+
⋅
−
=
′
−
−
+
+
−
+
4
2
1
1
2
2
1
1
30
1
;
12
8
8
6
1
;
2
b) Segunda derivada.
Aproximaciones de diferencias hacia adelante
IV
i
i
i
i
i
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
f
h
E
E
h
f
f
f
f
⋅
⋅
≈
+
⋅
+
⋅
−
⋅
+
−
=
′′
′′′
⋅
≈
+
+
⋅
−
=
′′
+
+
+
+
+
2
2
1
2
3
2
1
2
12
11
;
2
5
4
;
2
Aproximaciones de diferencia hacia atrás
IV
i
i
i
i
i
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
f
h
E
E
h
f
f
f
f
⋅
⋅
≈
+
⋅
+
⋅
−
⋅
+
−
=
′′
′′′
⋅
≈
+
+
⋅
−
=
′′
−
−
−
−
+
2
2
2
1
3
2
1
2
12
11
;
2
5
4
;
2
Aproximaciones de diferencia centrales
VI
i
i
i
i
i
i
i
IV
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
f
f
h
E
E
h
f
f
f
f
⋅
⋅
≈
+
⋅
−
⋅
+
⋅
−
⋅
+
−
=
′′
⋅
≈
+
+
⋅
−
=
′′
−
−
+
+
−
+
4
2
2
1
1
2
2
2
1
1
90
1
;
12
16
30
16
12
1
;
2
c) Tercera derivada.
Aproximaciones de diferencia hacia adelante
IV
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
⋅
≈ −
+
−
⋅
+
⋅
−
=
′′′ +
+
+ 2
3
1
2
3
2
3
;
3
3
Aproximaciones de diferencia hacia atrás
IV
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
⋅
≈
+
−
⋅
+
⋅
−
=
′′′ −
−
− 2
3
3
2
1
2
3
;
3
3
Aproximaciones de diferencia centrales
V
i
i
i
i
i
i
f
h
E
E
h
f
f
f
f
f
⋅
≈ −
+
⋅
⋅
−
⋅
+
⋅
−
=
′′′ −
−
+
+ 2
3
2
1
1
2
4
1
;
2
2
2
2

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:
f
f
f
x
x
x
∂f
=
∂x
∂f
=
∂x
∂f
=
∂x
≈
≈
≈
f
f
f
( x + ∆x,
y ) − f ( x , y )
0
∆x
( x + ∆x,
y ) − f ( x − ∆x,
y )
0
2 ⋅ ∆x
( x , y ) − f ( x − ∆x,
y )
0
0
0
0
∆x
0
0
0
0
0
→
0
→
E ∝ ∆x
→
E ∝
( ∆x)
E ∝ ∆x
[9].
2
( x , y 0 0
)
f
f
f
xx
yy
xy
−
+
Las aproximaciones de diferencia central para las segundas derivadas de f ( x , y)
están dadas por:
2
∂ f f x0
+ ∆x,
y
= ≈
2
∂x
2
∂ f
=
2
∂y
2
∂ f
= ≈
∂x
⋅ ∂y
f
≈
f
(
0
) − 2 ⋅ f ( x0
, y0
) + f ( x0
− ∆x,
y0
)
2
( ∆x)
( x0
, y0
+ ∆y) − 2 ⋅ f ( x0
, y0
) + f ( x0
, y0
− ∆y)
2
( ∆y)
f ( x + ∆x,
y + ∆y) − f ( x − ∆x,
y + ∆y)
( x + ∆x,
y − ∆y) − f ( x − ∆x,
y − ∆y)
0
0
0
∆x
⋅ ∆y
0
0
∆x
⋅ ∆y
0
0
0
→
E ∝
( ∆x)
2
[10].
en
60

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
61

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.
62

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.
63

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.
64

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.
65

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
66

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).
67

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.
68

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.
69

• 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.
70

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.
71

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:
72

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.
73

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.
74

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.
75

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.
76

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.
77

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.
78

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 precio 12 . 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.
79

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.
80

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
81

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
82

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.
83

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).
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.
85

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:
86

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
87

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:
88

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
89

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.
90

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
91

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.
92

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).
93

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.
94

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
#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
95

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.
96

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
97

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.
98

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.
99

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.
100

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.
forma:
La sintaxis básica de este comando es simple y se encuentra representada de la siguiente
#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.
101

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

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.
103

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.
104

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
105

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
106

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
a

uen 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.
b

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
c

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.
d

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.
e

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.
f

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.
709.
La primera IBM 7090 es entregada. Esta es la versión transistorizada de la IBM
I

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.
II

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
III

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
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)
IV

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)
trabajo:
La siguiente función, cierra el ambiente de trabajo en paralelo una vez finalizado el
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.
V

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.
VI

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.
VII

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.
A