Interfaz de Paso de Mensajes

De Wikipedia, la enciclopedia libre
(Redirigido desde «MPI»)
Saltar a: navegación, búsqueda

MPI ("Message Passing Interface", Interfaz de Paso de Mensajes) 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.

El paso de mensajes es una técnica empleada en programación concurrente para aportar sincronización entre procesos y permitir la exclusión mutua, de manera similar a como se hace con los semáforos, monitores, etc.

Su principal característica es que no precisa de memoria compartida, por lo que es muy importante en la programación de sistemas distribuidos.

Los elementos principales que intervienen en el paso de mensajes son el proceso que envía, el que recibe y el mensaje.

Dependiendo de si el proceso que envía el mensaje espera a que el mensaje sea recibido, se puede hablar de paso de mensajes síncrono o asíncrono. En el paso de mensajes asíncrono, el proceso que envía, no espera a que el mensaje sea recibido, y continúa su ejecución, siendo posible que vuelva a generar un nuevo mensaje y a enviarlo antes de que se haya recibido el anterior. Por este motivo se suelen emplear buzones, en los que se almacenan los mensajes a espera de que un proceso los reciba. Generalmente empleando este sistema, el proceso que envía mensajes sólo se bloquea o para, cuando finaliza su ejecución, o si el buzón está lleno. En el paso de mensajes síncrono, el proceso que envía el mensaje espera a que un proceso lo reciba para continuar su ejecución. Por esto se suele llamar a esta técnica encuentro, o rendezvous. Dentro del paso de mensajes síncrono se engloba a la llamada a procedimiento remoto, muy popular en las arquitecturas cliente/servidor.

La Interfaz de Paso de Mensajes (conocido ampliamente como MPI, siglas en inglés de Message Passing Interface) es un protocolo de comunicación entre computadoras. Es el estándar para la comunicación entre los nodos que ejecutan un programa en un sistema de memoria distribuida. Las implementaciones en MPI consisten en un conjunto de bibliotecas de rutinas que pueden ser utilizadas en programas escritos en los lenguajes de programación C, C++, Fortran y Ada. 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[editar]

Al diseñarse 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 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[editar]

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 rank, 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 rank; la variable rank permite determinar que proceso ejecuta determinada porción de código. En MPI se define un comunicator como una colección de procesos, los cuales pueden enviar mensajes el uno al otro; el comunicator 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 (size) y el rango de los procesos (rank). 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: buffer, tipo de dato y count. El buffer, 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 count 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 comunicator y una etiqueta. La fuente identifica al proceso transmisor. El destino identifica al proceso receptor. El comunicator especifica el grupo de procesos a los cuales pertenecen la fuente y el destino. La etiqueta (tag) 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[editar]

MPI dispone de 4 funciones primordiales que se utilizan en todo programa con MPI. Estas funciones son:

MPI_Init permite inicializar una sesión MPI. Esta función debe ser utilizada antes de llamar a cualquier otra función de MPI.

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

MPI_Comm_rank permite determinar el identificador (rank) del proceso actual.

Llamadas utilizadas para transferir datos entre dos procesos[editar]

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[editar]

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 sólo 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[editar]

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[editar]

  • 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

Implementaciones[editar]

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

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[editar]

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[editar]

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[editar]

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 (en inglés) 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 arrays multi-dimensionales y objetos complejos ineficientes.

Los métodos utilizados por lo general implican la transferencia de una línea a la vez y/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 los arrays 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.

Microsoft Windows[editar]

Windows Compute Cluster Server utiliza el Microsoft Messaging Passing Interface v2 (MPI-MS) para la comunicación entre los nodos de procesamiento sobre el cluster 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 f 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[editar]

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

Funciones básicas[editar]

Cualquier programa paralelo con MPI puede implementarse con tan sólo 6 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. Éstas 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_WORD , 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[editar]

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 procesadores\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, "Procesador %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;
}

Véase también[editar]

Enlaces externos[editar]