Interfaz de Paso de Mensajes

La interfaz de paso de mensajes o MPI (sigla del inglés message passing interface) es un estándar que define la sintaxis y la semántica de las funciones contenidas en una biblioteca de paso de mensajes diseñada para ser usada en programas que exploten la existencia de múltiples procesadores, escritas generalmente en C, C++, Fortran y Ada. Siendo más específicos, en realidad MPI se trata de un "estándar por consenso", el cual fue diseñado originalmente en un foro abierto que incluía proveedores de hardware, investigadores, académicos, desarrolladores de bibliotecas de software y usuarios, que representaban a más de 40 organizaciones. Es gracias a esta amplia participación que tuvo su desarrollo que surgió rápidamente MPI, en forma de un estándar ampliamente usado para escribir programas de paso de mensajes. Con esto dicho, cabe aclarar que MPI no es un verdadero estándar, debido a que no fue emitido por una organización de estándares como ISO o la IEEE​, sin embargo, este es ampliamente usado debido a que es de código libre.

La ventaja de MPI sobre otras bibliotecas de paso de mensajes, es que los programas que utilizan la biblioteca son portables (dado que MPI ha sido implementado para casi toda arquitectura de memoria distribuida), y rápidos, (porque cada implementación de la biblioteca ha sido optimizada para el hardware en la cual se ejecuta).

Historia

Al diseñarse la interfaz de paso de mensajes se tuvieron en cuenta las características más atractivas de los sistemas existentes para el paso de mensajes, en vez de seleccionar uno solo de ellos y adoptarlo como el estándar, resultando así, en una fuerte influencia para MPI los trabajos hechos por IBM, INTEL, NX/, Express, nCUBE's Vernex, p4 y PARMACS. Otras contribuciones importantes provienen de Zipcode, Chimp, PVM, Chameleon y PICL.

El esfuerzo para estandarizar MPI involucró a cerca de 60 personas de 40 organizaciones diferentes principalmente de EE. UU. 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.

El proceso de estandarización comenzó en el taller de estándares para el paso de mensajes en un ambiente con memoria distribuida, patrocinado por el Centro de Investigación en Computación Paralela en Williamsburg, Virginia, Estados Unidos (abril 29-30 de 1992).

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 por el MPI fue presentado en la conferencia de supercómputo 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 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-1 apareció en 1994, el estándar MPI-2 fue lanzado en 1997

Fundamentos de MPI

Con MPI el número de procesos requeridos se asigna antes de la ejecución del programa, y no se crean procesos adicionales mientras la aplicación se ejecuta. A cada proceso se le asigna una variable que se denomina rango, la cual identifica a cada proceso, en el rango de 0 a p-1, donde p es el número total de procesos. El control de la ejecución del programa se realiza mediante la variable de rango. Esta permite determinar qué proceso ejecuta determinada porción de código. En MPI se define un comunicador como una colección de procesos, los cuales pueden enviar mensajes el uno al otro; el comunicador básico se denomina MPI_COMM_WORLD y se define mediante un macro del lenguaje C. MPI_COMM_WORLD agrupa a todos los procesos activos durante la ejecución de una aplicación. Las llamadas de MPI se dividen en cuatro clases:

1. Llamadas utilizadas para inicializar, administrar y finalizar comunicaciones.
2. Llamadas utilizadas para transferir datos entre un par de procesos.
3. Llamadas para transferir datos entre varios procesos.
4. Llamadas utilizadas para crear tipos de datos definidos por el usuario.

La primera clase de llamadas permiten inicializar la biblioteca de paso de mensajes, identificar el número de procesos y el rango de los procesos. La segunda clase de llamadas incluye operaciones de comunicación punto a punto, para diferentes tipos de actividades de envío y recepción. La tercera clase de llamadas son conocidas como operaciones grupales, que proveen operaciones de comunicaciones entre grupos de procesos. La última clase de llamadas provee flexibilidad en la construcción de estructuras de datos complejos.

En MPI, un mensaje está conformado por el cuerpo del mensaje, el cual contiene los datos a ser enviados, y su envoltura, que indica el proceso fuente y el destino. El cuerpo del mensaje en MPI se conforma por tres piezas de información: búfer, tipo de dato y contador. El búfer, es la localidad de memoria donde se encuentran los datos de salida o donde se almacenan los datos de entrada. El tipo de dato, indica el tipo de los datos que se envían en el mensaje. En casos simples, éste es un tipo básico o primitivo, por ejemplo, un número entero, y que en aplicaciones más avanzadas puede ser un tipo de dato construido a través de datos primitivos. Los tipos de datos derivados son análogos a las estructuras de C. El contador es un número de secuencia que junto al tipo de datos permiten al usuario agrupar ítems de datos de un mismo tipo en un solo mensaje. MPI estandariza los tipos de datos primitivos, evitando que el programador se preocupe de las diferencias que existen entre ellos, cuando se encuentran en distintas plataformas.

La envoltura de un mensaje en MPI típicamente contiene la dirección destino, la dirección de la fuente, y cualquier otra información que se necesite para transmitir y entregar el mensaje. La envoltura de un mensaje en MPI, consta de cuatro partes: la fuente, el destino, el comunicador y una etiqueta. La fuente identifica al proceso transmisor. El destino identifica al proceso receptor. El comunicador especifica el grupo de procesos a los cuales pertenecen la fuente y el destino. La etiqueta permite clasificar el mensaje.

El campo etiqueta es un entero definido por el usuario que puede ser utilizado para distinguir los mensajes que recibe un proceso. Por ejemplo, se tienen dos procesos A y B. El proceso A envía dos mensajes al proceso B, ambos mensajes contienen un dato. Uno de los datos es utilizado para realizar un cálculo, mientras el otro es utilizado para imprimirlo en pantalla. El proceso A utiliza diferentes etiquetas para los mensajes. El proceso B utiliza los valores de etiquetas definidos en el proceso A e identifica que operación deberá realizar con el dato de cada mensaje.

Llamadas utilizadas para inicializar, administrar y finalizar comunicaciones

MPI dispone de cuatro funciones primordiales que se utilizan en todo programa con MPI: MPI_Init, MPI_Finalize, MPI_Comm_size y MPI_Comm_rank.

MPI_Init

Esta función inicializa todas las estructuras de datos necesarias para permitir la comunicación entre procesos basados en el envío de mensajes MPI y debe ser utilizada antes de llamar a cualquier otra función de MPI. Reserva el canal de comunicación, asigna un valor a la constante MPI_COMM_WORLD Esta rutina, o MPI_Init_thead, debe ser llamado antes que cualquier otra rutina de MPI. Debe ser llamada una única vez, en caso de no hacerlo así sería erróneo. De esta forma, un programa normal MPI debería quedar de la siguiente forma:

int main(int argc, char* argv[]){
    /* Declaracion de variables */
    MPI_Init(&argc, &argv);
    /* Reparto de contenido */
    /* Bucle principal del programa */
    MPI_Finalize();
}

Todos los programas MPI deben tener siempre una llamada a esta función. Los argumentos que recibe no son ni modificados, ni interpretados ni distribuidos.

Sintaxis de MPI_Init

En C

#include "mpi.h"
int MPI_Init (int *argc, char ***argv)

En C++

#include <mpi.h>
void MPI::Init(int& argc, char**& argv)
void MPI::Init()

Parámetros de entrada de MPI_Init

argc: puntero al número de argumentos

argv: puntero al vector de argumentos

MPI_Finalize

Permite terminar una sesión MPI. Esta función debe ser la última llamada a MPI que un programa realice. Permite liberar la memoria usada por MPI.

MPI_Comm_size

Permite determinar el número total de procesos que pertenecen a un comunicador.

MPI_Comm_rank

Permite determinar el identificador o rango del proceso actual.

Llamadas utilizadas para transferir datos entre dos procesos

La transferencia de datos entre dos procesos se consigue mediante las llamadas MPI_Send y MPI_Recv. Estas llamadas devuelven un código que indica su éxito o fracaso.

MPI_Send

Permite enviar información desde un proceso a otro.

MPI_Recv

Permite recibir información desde otro proceso.

Ambas funciones son bloqueantes, es decir que el proceso que realiza la llamada se bloquea hasta que la operación de comunicación se complete.

Las versiones no bloqueantes de MPI_Send y MPI_Recv son MPI_Isend y MPI_Irecv, respectivamente. Estas llamadas inician la operación de transferencia pero su finalización debe ser realizada de forma explícita mediante llamadas como MPI_Test y MPI_Wait.

MPI_Wait

Es una llamada bloqueante y retorna cuando la operación de envío o recepción se completa.

MPI_Test

Permite verificar si la operación de envío o recepción ha finalizado, esta función primero chequea el estado de la operación de envío o recepción y luego retorna.

Llamadas utilizadas para transferir datos entre varios procesos

MPI posee llamadas para comunicaciones grupales que incluyen operaciones tipo difusión (broadcast), recolección (gather), distribución (scatter) y reducción. Algunas de las funciones que permiten realizar transferencia entre varios procesos se presentan a continuación.

MPI_Barrier permite realizar operaciones de sincronización. En estas operaciones no existe ninguna clase de intercambio de información. Suele emplearse para dar por finalizada una etapa del programa, asegurándose de que todos los procesos han terminado antes de dar comienzo a la siguiente.

MPI_Bcast permite a un proceso enviar una copia de sus datos a otros procesos dentro de un grupo definido por un comunicator.

MPI_Scatter establece una operación de distribución, en la cual un dato (arreglo de algún tipo de datos) se distribuye en diferentes procesos.

MPI_Gather establece una operación de recolección, en la cual los datos son recolectados en un solo proceso.

MPI_Reduce permite que el proceso raíz recolecte datos desde otros procesos en un grupo, y los combine en un solo ítem de datos. Por ejemplo, se podría utilizar una operación reducción, para calcular la suma de los elementos de un arreglo que se distribuyó en algunos procesos.

Llamadas utilizadas para crear tipos de datos definidos por el usuario

Para definir nuevos tipos de datos se puede utilizar la llamada MPI_Type_struct para crear un nuevo tipo o se puede utilizar la llamada MPI_Pack para empaquetar los datos.

Características de MPI

• Estandarización.
• Portabilidad: multiprocesadores, multicomputadores, redes, heterogéneos, ...
• Buenas prestaciones.
• Amplia funcionalidad.
• Existencia de implementaciones libres (mpich, LAM-MPI, ...)

La especificación detalla las funciones que se pueden utilizar, no el modo como se compilan y lanzan-ejecutan los programas, lo cual puede variar de una implementación a otra.

Siguiendo el modelo SPMD, el usuario escribirá su aplicación como un proceso secuencial del que se lanzarán varias instancias que cooperan entre sí.

Los procesos invocan diferentes funciones MPI que permiten

• iniciar, gestionar y finalizar procesos MPI
• comunicar datos entre dos procesos
• realizar operaciones de comunicación entre grupos de procesos
• crear tipos arbitrarios de datos

Dos aspectos relevantes que se deben considerar al trabajar con MPI son:

• La semántica de la interfaz debe mantenerse independiente del lenguaje de programación utilizado.

• Se debe diseñar la interfaz para garantizar la seguridad al realizar las tareas.

Grupos y comunicadores

• Grupos: Un grupo MPI es un conjunto fijo y ordenado de procesos MPI únicos. En otras palabras, un grupo MPI es una colección de procesos.
• Comunicadores: Un comunicador representa la "membresía" de un proceso en un grupo de procesos más grande. Contiene un grupo de procesos que pueden comunicarse entre sí. El tamaño de un comunicador no cambia una vez creado; por lo que cada proceso dentro de un comunicador tiene un número único para identificarlo llamado "rank del proceso".

Primero se crea el grupo con los procesos deseados que se incluirán dentro del grupo y luego el grupo se utiliza para crear un comunicador. El comunicador predeterminado se llama MPI_COMM_WORLD que agrupa a todos los procesos cuando se inicia el programa.

Métodos de comunicación MPI

Existen 3 tipos de métodos que usa MPI para que los procesos se puedan comunicar entre sí:

• Comunicación Point-toPoint: Es el tipo más usado de comunicación. Implica la transferencia de un mensaje de un proceso a un proceso particular en el mismo comunicador.

MPI proporciona comunicación punto a punto con bloqueo (síncrono) y sin bloqueo (asíncrono)

• Con bloqueo: un proceso MPI envía un mensaje a otro proceso MPI y espera hasta que el proceso receptor reciba completa y correctamente el mensaje antes de continuar con su trabajo.
• Sin bloqueo: envía un mensaje a otro proceso MPI y continúa su trabajo sin esperar para asegurarse de que el proceso receptor haya recibido correctamente el mensaje.

• Comunicación colectiva: En este tipo de comunicación, un proceso transmite un mensaje a todos los procesos en el mismo comunicador, incluido a él mismo.
• Comunicación One-sided: Con el método de comunicación unilateral MPI, un proceso puede acceder directamente al espacio de memoria de otro proceso sin involucrarlo.

MPI-2

Comunicación unilateral

MPI-2 define tres operaciones de comunicación unilaterales, MPI_Put, MPI_Get y MPI_Accumulate, que son una operación de escritura en la memoria remota, una lectura de la memoria remota y una operación de reducción en la misma memoria en varias tareas, respectivamente. También se definen tres métodos diferentes para sincronizar esta comunicación (bloqueos globales, por pares y remotos) ya que la especificación no garantiza que estas operaciones hayan tenido lugar hasta un punto de sincronización.

Estos tipos de llamada a menudo pueden ser útiles para algoritmos en los que la sincronización sería un inconveniente (por ejemplo, la multiplicación de matrices distribuidas) o donde es deseable que las tareas puedan equilibrar su carga mientras otros procesadores operan con datos.

Gestión dinámica de procesos

El aspecto clave es "la capacidad de un proceso MPI para participar en la creación de nuevos procesos MPI o para establecer comunicación con procesos MPI que se han iniciado por separado". La especificación MPI-2 describe tres interfaces principales mediante las cuales los procesos MPI pueden establecer comunicaciones dinámicamente, MPI_Comm_spawn, MPI_Comm_accept/MPI_Comm_connect y MPI_Comm_join. La interfaz MPI_Comm_spawn permite que un proceso MPI genere una cantidad de instancias del proceso MPI nombrado. El conjunto recién generado de procesos MPI forma un nuevo intracomunicador MPI_COMM_WORLD pero puede comunicarse con el padre y el intercomunicador que devuelve la función. MPI_Comm_spawn_multiple es una interfaz alternativa que permite que las diferentes instancias generadas sean binarios diferentes con argumentos diferentes.

I/O

La función de E/S paralela a veces se denomina MPI-IO y se refiere a un conjunto de funciones diseñadas para abstraer la gestión de E/S en sistemas distribuidos a MPI y permitir que se acceda fácilmente a los archivos de forma pautada utilizando la funcionalidad de tipo de datos derivado existente. .

La poca investigación que se ha realizado sobre esta característica indica que puede no ser trivial obtener ganancias de alto rendimiento mediante el uso de MPI-IO. Por ejemplo, una implementación de multiplicaciones de matriz-vector dispersos utilizando la biblioteca de E/S de MPI muestra un comportamiento general de ganancia de rendimiento menor, pero estos resultados no son concluyentes. No fue hasta que se implementó la idea de E/S colectiva en MPI-IO que MPI-IO comenzó a alcanzar una adopción generalizada. La E/S colectiva aumenta sustancialmente el ancho de banda de E/S de las aplicaciones al hacer que los procesos transformen colectivamente las operaciones de E/S pequeñas y no contiguas en operaciones grandes y contiguas, lo que reduce el bloqueo y la sobrecarga de búsqueda de disco. Debido a sus grandes beneficios de rendimiento, MPI-IO también se convirtió en la capa de E/S subyacente para muchas bibliotecas de E/S de última generación, como HDF5 y Parallel NetCDF. Su popularidad también desencadenó la investigación sobre optimizaciones de E/S colectivas, como E/S con reconocimiento de diseño y agregación de archivos cruzados.

MPI 4.0

Los esfuerzos de estandarización de MPI 4.0 tienen como objetivo agregar nuevas técnicas, enfoques o conceptos al estándar MPI que ayudarán a MPI a abordar la necesidad de las aplicaciones y arquitecturas actuales y de próxima generación. En particular, actualmente se están proponiendo y trabajando en las siguientes adiciones:

• Extensiones para admitir mejor los modelos de programación híbridos
• Soporte para tolerancia a fallas en aplicaciones MPI
• Colectivos persistentes
• Afirmaciones y sugerencias de rendimiento
• RMA/Comunicación unilateral

Además, varios grupos de trabajo están trabajando en nuevas ideas y conceptos, incl.

• Mensajes activos
• Transmisión de mensajes
• Reelaboración de la interfaz de creación de perfiles MPI
• Extensiones a MPI_T
• Solicitudes generalizadas
• Preocupaciones híbridas MPI+X (especialmente MPI+CAF)
• Enviar cancelación
• Devolución de llamada de atributo
• Conteo grande

Además, el grupo de trabajo sobre herramientas analiza interfaces de herramientas de terceros adicionales, que generalmente se publican como documentos complementarios:

• Manejar la introspección de los depuradores
• Depuración de detección e identificación de DLL

Tenga en cuenta, sin embargo, que todos estos esfuerzos o nuevos conceptos actualmente solo se están discutiendo o proponiendo y no hay garantía de que alguno en particular se incluya en cualquier próxima versión de MPI.​

Implementaciones

La implementación del lenguaje para MPI es, en general, los lenguajes que intentan optimizar el tiempo de ejecución.

La mayoría de las implementaciones de MPI se realizan en una combinación de C, C + + y el lenguaje ensamblador, C ++, Fortran. Sin embargo, el idioma y la aplicación de usuario final idioma son, en principio, siempre desasociado.

La etapa inicial de aplicación del estándar MPI 1.x fue MPICH, nacida en Argonne National Laboratory y la Universidad del Estado de Misisipi.

IBM también fue una de las primeras en implementar el estándar MPI, y la mayoría de las empresas de superordenador a principio de los años 90 comercializando MPICH o implementando su propia aplicación del estándar MPI 1.x.

LAM/MPI del Centro de Supercomputación de Ohio es otra de las primeras en implementarlo.

El Argonne National Laboratory continuó desarrollando MPICH durante más de una década, y ahora ofrece MPICH2 que se corresponde con la implementación del estándar MPI-2.1

LAM/MPI, y otra serie de esfuerzos recientes de MPI se han fusionado para formar un nuevo proyecto mundial, el llamado OpenMPI, pero este nombre no implica ninguna relación con el estándar.

Microsoft ha añadido una MPI al esfuerzo a sus Kit Cluster Computing (2005), basada en MPICH2. MPI se ha convertido y sigue siendo un elemento vital para la interfaz de programación concurrente a esta fecha de hoy.

Muchas distribuciones de Linux incluyen MPI (uno o ambos MPICH y LAM, como ejemplos particulares), pero es mejor obtener las últimas versiones de MPI de desarrolladores desde los sitios de desarrollo.

Muchos vendedores de distribuciones personalizadas de las actuales implementaciones de software libre, que se centran en un mejor rendimiento y estabilidad.

Además de la corriente principal de MPI para programación de alto rendimiento, MPI se ha utilizado ampliamente con Python, Perl, Java.

Estas comunidades están creciendo.

Basados en MATLAB MPI aparecen en muchas formas, pero no hay un consenso sobre una única manera de utilizar MPI con MATLAB.

Las siguientes secciones detallan algunos de estos esfuerzos.

Python

Hay por lo menos cinco intentos conocidos de aplicar MPI para Python: mpi4py, PyPar, PyMPI, MYMPI, y en el submódulo ScientificPython MPI.

PyMPI es notable porque se trata de una variante de python intérprete multi-nodo de la aplicación de la propia intérprete, más que el código se ejecuta el intérprete. Implementa la mayor parte de la especificación MPI y trabaja automáticamente con el código compilado que necesita para hacer llamadas MPI.

PyPar, MYMPI, y el módulo ScientificPython están diseñados para trabajar como un típico módulo realizando una declaración de importación.

Hacen el trabajo del codificador para decidir cuándo y dónde pertenece la llamada a MPI_Init.

OCaml

El Módulo OCamlMPI implementa un gran subconjunto de las funciones MPIy está en uso activo en la computación científica.

Para tener una idea de su madurez: se informó sobre la lista de Ocaml que una línea de once mil OCaml programa fue "MPI-ficados", utilizando el módulo, con un adicional de 500 líneas de código y ligera reestructuración y ha corrido con excelentes resultados hasta 170 nodos en un superordenador.

Java

Aunque Java no dispone de un funcionario MPI vinculantes, ha habido varios intentos de puente de Java y MPI, con diferentes grados de éxito y compatibilidad.

Uno de los primeros intentos fue Bryan Carpenter's mpiJava, básicamente una colección de envoltorios JNI de la biblioteca local MPI de C, cuyo resultado es un híbrido con limitada portabilidad en la práctica, y que tiene que ser recompilado con la biblioteca específica de la biblioteca MPI que se utiliza.

Sin embargo, este proyecto original definió el mpiJava API (de hecho una API MPI para Java equivalente a la de C ++ o muy similar), que posteriormente otros proyectos Java MPI han utilizado.

Una alternativa, aunque menos utilizada, es la API MPJ, diseñada para ser más orientada a objetos y más cerca a los convenios de codificación de Sun Microsystems.

Otros que utilizan la API de las bibliotecas Java MPI pueden ser dependientes de la biblioteca local, o llevar a cabo las funciones de paso de mensajes en Java, mientras que algunos como P2P-MPI también permiten la funcionalidad y operación de plataforma mixtos.

Algunas de las partes más difíciles de cualquier aplicación para Java MPI surgen de las limitaciones del propio lenguaje de programación y sus peculiaridades, como la falta de los punteros explícitos y espacio de las direcciones de memoria lineales para sus objetos, que hacen la transferencia de matrices o arrays multidimensionales y objetos complejos ineficientes.

Los métodos utilizados por lo general implican la transferencia de una línea a la vez o la realización explícita de serialización y emiten tanto en el envío y la recepción final, simulando C o FORTRAN como las matrices por el uso de un array unidimensional, y punteros a los tipos primitivos por el uso de un solo elemento de los vectores, lo que da lugar a estilos de programación bastante extraños de las convenciones Java.

Una de las principales mejoras es MPJ Express por Aamir Shafi y supervisado por Bryan Carpenter y Mark Baker. Como plataforma básica se usa Fast Ethernet, avances de la tecnología JVM ahora disponible programas Java escritos en Java a sus rivales C homólogos.

Por otra parte, las mejoras en el hardware especializados de red prosiguieron, disminuyendo los costes de comunicación a un par de microsegundos.

La cuestión clave en la actualidad no es para debatir entre sí es mejor la JNI con respecto al Java puro, sino el proporcionar un mecanismo flexible de los programas de intercambiar los protocolos de comunicación.

El objetivo de este proyecto es proporcionar un sistema de mensajería de referencia de Java basada en el estándar MPI. La aplicación sigue una arquitectura basada en una idea de los controladores de dispositivo.

.NET

Windows Compute Cluster Server utiliza el Microsoft Messaging Passing Interface v2 (MPI-MS) para la comunicación entre los nodos de procesamiento sobre el clúster de red.

La interfaz de programación de aplicaciones consta de más de 160 funciones. MS-MPI fue diseñado, con algunas excepciones, debido a consideraciones de seguridad, para abarcar el conjunto completo de funciones que MPI2 aplicado en MPICH2.

Hay también una completa gestionada aplicación .NET de MPI - Pure Mpi.NET. La API orientada a objetos es potente, fácil de utilizar para la programación paralela.

Ha sido desarrollado sobre la última tecnología .NET, incluido en la Windows Communication Foundation (WCF).

Esto le permite declarativamente especificar la configuración de llamada y configuración de entorno final y las necesidades de rendimiento.

Las interfaces MPI, a la vez que aprovecha al máximo las características de .NET -incluyendo los genéricos, los delegados, los resultados asíncronos, excepciones y extensibilidad.

Implementaciones hardware

No hubo investigación para implementar MPI directamente en el hardware del sistema, por ejemplo, por medio de procesador en la memoria, donde las operaciones MPI estén integrados en los chips de RAM de cada nodo.

Implícitamente, este tipo de aplicación sería independiente al lenguaje, Sistema Operativo o CPU en el sistema, pero no sería fácilmente actualizado.

Otra aproximación ha sido la de añadir aceleración hardware a una o más partes de la operación.

Esto puede incluir el hardware de procesamiento de las colas de MPI o el uso de RDMA directamente a la transferencia de datos entre la memoria y la interfaz de red sin necesidad de CPU o intervención del núcleo.

Empresas

MPI es un estándar para la comunicación entre procesos en sistemas distribuidos, y es comúnmente utilizado en supercomputadoras y clústeres de alto rendimiento. Estas son algunas de las empresas que hacen uso de MPI:

• IBM: IBM implementa MPI en sistemas HPC (High-Performance Computing) como parte de sus soluciones para clientes empresariales.
• Intel: La empresa ha desarrollado una implementación de MPI llamada "Intel MPI", que es parte de su conjunto de herramientas de desarrollo paralelo. Intel MPI proporciona una implementación eficiente y escalable de MPI, optimizada para los procesadores Intel.
• Microsoft: En el ámbito de la nube, Microsoft Azure ofrece instancias de máquinas virtuales optimizada para HPC, donde se puede utilizar MPI para aplicaciones paralelas.
• Cray: Cray ha sido conocido por construir supercomputadoras de alto rendimiento, y MPI es una parte integral de muchas de estas implementaciones.
• National Instuments: Empresas que trabajan en áreas como la instrumentación y el control a menudo utilizan MPI para realizar cálculos intensivos y procesamiento de datos en paralelo.
• Siemens: En el sector de la simulación y el diseño asistido por computadora, podrían emplear MPI en sus aplicaciones para mejorar el rendimiento en sistemas distribuidos.

Funciones básicas

Cualquier programa paralelo con MPI puede implementarse con tan solo seis funciones, aunque hay muchas más funciones para aspectos avanzados. Todas ellas empiezan por MPI_ y obligan a que todos los programas escritos en MPI contengan la directiva:

 #include "mpi.h",

Este fichero contiene las definiciones, macros y prototipos de función necesarios para compilar los programas MPI.

Antes de llamar a cualquier otra función MPI debe hacer una llamada a MPI_Init(); esta función sólo debe ser llamada una vez. Sus argumentos son punteros a los parámetros de la función main(), argc y argv. Esta función permite al sistema hacer todas la configuraciones necesarias para que la biblioteca MPI pueda ser usada. Después de que el programa haya acabado de utilizar la biblioteca MPI se debe hacer una llamada a MPI_Finalize(). La función MPI_Finalize() limpia todos los trabajos no finalizados dejados por MPI. Los programas MPI deben ser obligatoriamente inicializados y finalizados en MPI (MPI_Init, MPI_Finalize).

MPI ofrece la función MPI_Comm_rank(), la cual retorna el identificador de un proceso en su segundo argumento. Su sintaxis es:

int MPI_Comm_rank(MPI_Comm comunicador, int* identificador)

El primer argumento es el comunicador. Esencialmente un comunicador es una colección de procesos que pueden enviarse mensajes entre sí. Normalmente para diseñar programas básicos el único comunicador que se necesitará es MPI_COMM_WORLD. Está predefinido en MPI y consiste en todos los procesos que se ejecutan cuando el programa comienza.

Muchas de las construcciones que se emplean en los programas, dependen también del número de procesos que se ejecutan. MPI ofrece la función MPI_Comm_size() para determinar dicho número de procesos. Su primer argumento es el comunicador. En el segundo argumento retorna el número de procesos pertenecientes a dicho comunicador. Su sintaxis es:

int MPI_Comm_size(MPI_Comm comunicador, int* numprocs)

La función MPI_Get_processor_name() permite conocer el nombre del procesador donde está ubicado cada proceso. Esto puede ser útil para monitorizar los programas en redes heterogéneas. Conocer en qué máquina concreta se está ejecutando un proceso específico puede ser determinante para explicar su comportamiento, para lo cual puede apoyarse con las herramientas de monitorización . La sintaxis de dicha función es la siguiente:

int MPI_Get_processor_name(char* nombre, int* longnombre)

El parámetro nombre es una cadena (vector de caracteres) cuyo tamaño debe ser al menos igual a la constante MPI_MAX_PROCESSOR_NAME. En dicho vector quedará almacenado el nombre del procesador. El parámetro longnombre es otro parámetro de salida que informa de la longitud de la cadena obtenida.

El paso de mensajes bloqueantes se lleva a cabo en los programas por las funciones MPI_Send() y MPI_Recv() principalmente. La primera función envía un mensaje a un proceso determinado. La segunda recibe un mensaje de un proceso. Estas son las funciones más básicas de paso de mensajes en MPI.

En MPI el entorno contiene la siguiente información:

1. El identificador del proceso receptor del mensaje.
2. El identificador del proceso emisor del mensaje.
3. Una etiqueta.
4. Un comunicador.

Fichero cabecera:

1. include <mpi.h>

Formato de las funciones: codigo_error = MPI_nombre( parámetros ... )

Inicialización: int MPI_Init ( int *argc , char ***argv )

Comunicador: Conjunto de procesos que se intercomunican. Por defecto podemos utilizar MPI_COMM_WORLD , en cuyo caso el grupo de procesos es el conjunto de procesos lanzados conjuntamente para resolver un problema

Identificación de procesos: MPI_Comm_rank ( MPI_Comm comm , int *rank)

Procesos en el comunicador: MPI_Comm_size ( MPI_Comm comm , int *size)

Finalización: int MPI_Finalize ( )

Mensajes: Un mensaje estará formado por un cierto número de elementos de un mismo tipo MPI.

Tipos MPI básicos:

MPI_CHAR	signed char
MPI_SHORT	signed short int
MPI_INT	signed int
MPI_LONG	signed long int
MPI_UNSIGNED_CHAR	unsigned char
MPI_UNSIGNED_SHOT	unsigned short int
MPI_UNSIGNED	unsigned int
MPI_UNSIGNED_LONG	unsigned long int
MPI_FLOAT	float
MPI_DOUBLE	double
MPI_LONG_DOUBLE	long double
MPI_BYTE
MPI_PACKED

Tipos MPI derivados: los construye el programador.

Envío de un mensaje a otro proceso: int MPI_Send ( void *posicion_de_memoria , int contador , MPI_Datatype tipo , int destino , int etiqueta , MPI_Comm comunicador )

Recepción de un mensaje de otro proceso:

int MPI_Recv ( void *posicion_de_memoria , int contador , MPI_Datatype tipo , int origen , int etiqueta, MPI_Comm comunicador , MPI_Status *estado)

El receptor puede emplear MPI_ANY_TAG y/o MPI_ANY_SOURCE

Ejemplo

A continuación se presenta un “Hola Mundo” implementado en C utilizando MPI. El programa envía un mensaje a cada nodo y lo imprime en pantalla. Además, cada nodo procesa el mensaje y retorna los resultados al nodo principal.

#include <mpi.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char idstr[32];
  char buff[128];
  int numprocs;
  int myid;
  int i;
  MPI_Status stat; 

  MPI_Init(&argc,&argv); 
  MPI_Comm_size(MPI_COMM_WORLD,&numprocs); 
  MPI_Comm_rank(MPI_COMM_WORLD,&myid); 

  if(myid == 0)
  {
    printf("Tenemos %d procesos\n", numprocs);
    for(i=1;i<numprocs;i++)
    {
      sprintf(buff, "¡Holaaa %d! ", i);
      MPI_Send(buff, 128, MPI_CHAR, i, 0, MPI_COMM_WORLD);
    }
    for(i=1;i<numprocs;i++)
    {
      MPI_Recv(buff, 128, MPI_CHAR, i, 0, MPI_COMM_WORLD, &stat);
      printf("%s\n", buff);
    }
  }
  else
  {
    MPI_Recv(buff, 128, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &stat);
    sprintf(idstr, "Proceso %d ", myid);
    strcat(buff, idstr);
    strcat(buff, "reportandose\n");
    MPI_Send(buff, 128, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
  }

  MPI_Finalize();
  return 0;
}

Ejemplo 2

/*
 * Open Systems Laboratory
 * http://www.lam-mpi.org/tutorials/
 * Indiana University
 *
 * MPI Tutorial
 * Lab 2: The cannonical ring program
 *
 * Mail questions regarding tutorial material to lam at lam dash mpi dot org
 */

#include <stdio.h>
#include <mpi.h>

int 
main(int argc, char *argv[]){
  MPI_Status status;
  int num, rank, size, tag, next, from;

  /* Start up MPI */

  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &size);
 
  /* Arbitrarily choose 201 to be our tag.  Calculate the rank of the
     next process in the ring.  Use the modulus operator so that the
     last process "wraps around" to rank zero. */

  tag = 201;
  next = (rank + 1) % size;
  from = (rank + size - 1) % size;

  /* If we are the "console" process, get a integer from the user to
     specify how many times we want to go around the ring */

  if (rank == 0) {
    printf("Enter the number of times around the ring: ");
    scanf("%d", &num);

    printf("Process %d sending %d to %d\n", rank, num, next);
    MPI_Send(&num, 1, MPI_INT, next, tag, MPI_COMM_WORLD); 
  }

  /* Pass the message around the ring.  The exit mechanism works as
     follows: the message (a positive integer) is passed around the
     ring.  Each time is passes rank 0, it is decremented.  When each
     processes receives the 0 message, it passes it on to the next
     process and then quits.  By passing the 0 first, every process
     gets the 0 message and can quit normally. */

  do {

    MPI_Recv(&num, 1, MPI_INT, from, tag, MPI_COMM_WORLD, &status);
    printf("Process %d received %d\n", rank, num);

    if (rank == 0) {
      --num;
      printf("Process 0 decremented num\n");
    }

    printf("Process %d sending %d to %d\n", rank, num, next);
    MPI_Send(&num, 1, MPI_INT, next, tag, MPI_COMM_WORLD);
  } while (num > 0);
  printf("Process %d exiting\n", rank);

  /* The last process does one extra send to process 0, which needs to
     be received before the program can exit */

  if (rank == 0)
    MPI_Recv(&num, 1, MPI_INT, from, tag, MPI_COMM_WORLD, &status);

  /* Quit */

  MPI_Finalize();
  return 0;
}

Campos de utilización

Los métodos de programación paralela en computadoras paralelas brindan acceso a una mayor memoria y recursos de CPU que no están disponibles en las computadoras en serie. Esto permite resolver grandes problemas con mayor velocidad o incluso inviable en comparación con el tiempo de ejecución típico en un solo procesador. Por lo que MPI es particularmente útil para áreas y aplicaciones en las que se requieren numerosos cálculos, los cuales pueden dividirse en tareas separadas y ejecutarse simultáneamente en varios procesadores, como lo son:

• Manufactura avanzada
• Aeroespacial
• Agricultura
• Astrofísica
• Meteorología
• Dinámica molecular
• Simulación de fluidos
• Dinámica de estructuras
• Modelos de crecimiento económico
• Energías alternativas
• Partes automotrices
• Biotecnología
• Química
• Procesamiento de alimentos
• Tecnología de la información
• Maquinaria
• Dispositivos médicos

• Simulación numérica y modelado: Aplicaciones que implican simulaciones numéricas intensivas, como simulaciones de fluidos, simulaciones de estructuras, y modelado de fenómenos físicos, pueden beneficiarse de la paralelización con MPI para acelerar los cálculos.
• Investigación científica: En campos como la física, la química, la biología computacional y la astrofísica, donde se realizan cálculos intensivos, MPI se utiliza para distribuir la carga de trabajo y aprovechar la capacidad de cómputo de clústeres y supercomputadoras
• Ingeniería de software y desarrollo de código paralelo: En el desarrollo de software para aplicaciones paralelas, los desarrolladores utilizan MPI para diseñar algoritmos que pueden ejecutarse de manera eficiente en sistemas distribuidos.
• Finanzas computacionales: En la modelización financiera, especialmente en simulaciones de riesgo, valoración de derivados y análisis de carteras, MPI se emplea para acelerar los cálculos y mejorar la eficiencia.
• Machine learning y redes neuronales: En el entrenamiento de modelos de aprendizaje profundo, donde se manejan grandes conjuntos de datos y se requieren muchos cálculos, MPI se puede usar para distribuir la carga de trabajo en múltiples nodos de procesamiento.

Véase también

• PVM

Enlaces externos

• Programación de aplicaciones paralelas  con MPI (Message Passing Interface)
• MPI specification
• MPI DMOZ category
• Open MPI web site
• LAM/MPI web site
• MPICH
• SCore MPI
• Scali MPI
• HP-MPI (enlace roto disponible en Internet Archive; véase el historial, la primera versión y la última).
• MVAPICH: MPI over InfiniBand
• Parawiki page for MPI
• Global Arrays
• PVM/MPI Users' Group Meeting (2006 edition)
• MPI Samples
• Manage MPI jobs with Moab
• MPICH over Myrinet (GM, classic driver)
• MPICH over Myrinet (MX, next-gen driver)
• Parallel Programming with MatlabMPI
• SGI Message Passing Toolkit
• Message Passing Interface Forum
• Ayuda MPI - Cátedra Programación Paralela - Universidad de Granada

• Datos: Q127879