Programación Paralela MPI en Linux

Saludos, en esta ocasión hablaremos de la programación paralela. Esta es una forma de cómputo en la que muchas instrucciones se ejecutan simultáneamente, operando sobre el principio de problemas más grande, que se pueden dividir en unos más pequeños, que luego son resueltos simultáneamente (en paralelo).

Se han desarrollado múltiples librerías para esta funcionalidad, hoy toca a MPI (Message Passing Interface) que traducido es “Interfaz de paso de mensajes”. MPI es una especificación para la programación de comunicación entre procesos, esta proporciona librerías cargadas de funciones para C, C++ o Fortran que son empleadas en los programas para comunicar datos entre distintos procesos.

Características:

• Estandarización.
• Portabilidad: multicomputadores, multiprocesadores, redes, heterogéneos (procesadores con diferentes características).
• Buenas prestaciones (Código muy bien hecho).

Una ventaja de usar MPI es que cuenta con mucha aceptación, debido a que es portable (permitiendo ser migrados a diferentes computadores paralelos) y cuenta con el aval del MPI Forum, que posee unas 40 organizaciones, encargadas de establecer modelos que permitan desarrollar programas paralelos. La versión actual de MPI es la 2 (La que se usara en este curso).

Instalando MPI

Su instalación es realmente simple, basta con colocar en nuestra terminal:

sudo apt-get install libcr-dev mpich2 mpich2-doc

Nos mostrará el siguiente contenido:

Nuestro Primer Programa:

#include <mpi.h>

#include <stdio.h>


int main(int argc,char* argv[]){

    int id, total_proc;

    MPI_Init(&argc,&argv);

    MPI_Comm_rank(MPI_COMM_WORLD,&id);

    MPI_Comm_size(MPI_COMM_WORLD,&total_proc);

    printf("Hola Solvetic desde el proceso %d de un total de %d \n", id, total_proc);
    MPI_Finalize();

   return 0;
   

}

Compilamos:

mpicc hola.c -o hola

Ejecutamos:

Como se puede observar la sintaxis es muy similar como si se trabajase con gcc normalmente por terminal, se usa -np “numero de procesadores” para identificar con cuantos procesadores vamos a trabajar, es recomendable que el numero de procesadores que coloquemos allí sea igual a los que se tienen físicamente en el computador.

Funciones definidas en MPI

Lo excelente de usar MPI es que con solo implementarse 6 funciones, ya se tiene un programa en paralelo, aunque hay muchas más funciones para aspectos avanzados. Todas ellas empiezan por MPI_ y obligan a que los programas tengan la directiva #include “mpi.h.

Todo programa en MPI, debe ser inicializados y finalizados, puesto que dentro de este sector(ambiente) existirá la comunicación y el manejo de pases de mensaje (MPI_Init , MPI_Finalize).

Los procesos en ejecución pueden saber en cualquier momento cuantos procesos MPI forman parte de un grupo de procesos, con la terminología MPI_Comm_size y que número de orden ocupan (se inicia por 0, como casi todo en informática).

Mecanismos de Comunicación

Los mensajes punto a punto deben ser enviados explícitamente por el emisor y recibidos explícitamente por el receptor (en otro tutorial explicaremos otras operaciones de comunicación colectivas), para lo cual emplearemos dos funciones básicas (MPI_Send y MPI_Recv).

Ya que he estado nombrando mucho los mensajes expliquemos de forma formal que son, los mensajes es la información que se envía de un emisor a un receptor. En este caso de un procesador A a un procesador B (aunque puede ser a muchos más, de forma simultáneamente). Un mensaje en MPI está conformado por un cierto número de elementos de un mismo tipo MPI.

Los tipos básicos en MPI son:

• MPI_CHAR
• MPI_SHORT
• MPI_INT
• MPI_LONG
• MPI_UNSIGNED_CHAR
• MPI_UNSIGNED
• MPI_FLOAT
• MPI_DOUBLE
• MPI_LONG
• MPI_BYTE
• MPI_PACKED

Si ninguno es lo que necesitas, no te preocupes, puedes construir tus propios tipos, por ejemplo las famosas estructuras.

¿Cómo enviar un mensaje de un proceso a otro? Fácil MPI lo hace:

#include <mpi.h>

#include <stdio.h>


    /**

        @param id identificador del proceso

        @param total_proc total de procesos

    */
  

int main(int argc,char* argv[]){
    int id, total_proc, i, tag = 99;

    MPI_Status status;
    MPI_Init(&argc,&argv); //Se inicializa el ambiente de paralelización, palabra difícil xD

    MPI_Comm_rank(MPI_COMM_WORLD,&id); /* Obtenemos los id */

    MPI_Comm_size(MPI_COMM_WORLD,&total_proc); /* Numero total de procesos */

    printf("Hola Solvetic desde el proceso %d de un total de %d \n", id, total_proc);
    if(id == 0){ // Se identifica el proceso que va enviar el mensaje

        i = 23; // mensaje a enviar
        /*

            MPI_Send(dato, contador de cambios, tipo, a quien envia, prioridad, ambiente paralelo);
        */

        MPI_Send(&i, 1, MPI_INT, 1, tag, MPI_COMM_WORLD);       
    }

    if(id == 1){
        /*

            MPI_Recv(dato, contador de cambios, tipo, quien me lo envio, prioridad, ambiente paralelo, estado del mensaje);
        */

     MPI_Recv(&i,1,MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
     printf("Proceso %d ha recibido %d \n",id,i);

    }
    MPI_Finalize(); // se finaliza el entorno

    return 0;
   

}

Se utilizan los mismos comandos para compilar y ejecutar.

Como se observa en el ejemplo, es bastante sencillo, pruébenlo, bastaría con definir quién es el que envía, y quien es el que recibe, en este caso. Se utilizan dos funciones respectivamente. Bueno chicos, esto ha sido todo por hoy, cualquier duda o inquietud comente y compartan. Saludos.