Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 1 vistas

    05 Programacion con MPI

    Cargado por

    Jesus Alan Melendez Hernandez

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    05 Programacion con MPI

    Cargado por

    Jesus Alan Melendez Hernandez
    1 vistas34 páginas

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    1 vistas34 páginas

    05 Programacion con MPI

    Cargado por

    Jesus Alan Melendez Hernandez

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    de 34

    Programación con MPI

    Cluster Beowulf

    • Un cluster Beowulf es una colección de computadoras personales


    (PC's) interconectadas por medio de una red privada de alta
    velocidad, corriendo como sistema operativo alguna distribución
    Linux.

    • Los nodos en el cluster son dedicados exclusivamente a ejecutar


    tareas asignadas al cluster.

    • Por lo general el cluster se encuentra comunicado al mundo exterior


    a través de un solo nodo, llamado nodo “Principal", el cual también
    esta reservado para accesar, compilar y manejar las aplicaciones a
    ejecutar.
    Arquitectura del Cluster

    nodo-01

    Servidor de Archivos
    nfs.pci.uas.edu.mx

    alfa.miservidor.mx
    nodo-02

    Internet
    Nodo Principal
    colhuacan.pci.uas.edu.mx
    maestro.miservidor.mx
    Nodo-03
    beta.miservidor.mx

    nodo-04
    ¿Qué es MPI?

    MPI (iniciales de Message Passing Interface) es:

    – una especificación para programación de paso de


    mensajes.

    – Proporciona una biblioteca de funciones para C, C++ o


    Fortran que son empleadas en los programas para
    comunicar datos entre procesos.
    ¿Quién define MPI?

    – MPI es la biblioteca de paso de mensajes estándar y


    portable, especificada por consenso por el MPI Forum,
    con unas 40 organizaciones participantes, como
    modelo que permita desarrollar programas que puedan
    ser migrados a diferentes computadoras paralelos.

    – http://www.mpi-forum.org

    – El primer estándar MPI 1.0 fue acabado y publicado en


    mayo 1994. El estándar ha sido actualizado desde
    entonces, estando actualmente en desarrollo el MPI 2.
    Características de MPI

    • Estándar actual de programación de los sistemas de


    memoria distribuida

    • Portabilidad: multiprocesadores y multicomputadoras.

    • Se basa en el envío y recepción de mensajes entre


    procesos.

    • Las implementaciones de MPI esta orientadas a Fortran


    y C.
    Implementaciones

    • MPICH (MPI/Chameleon). Producida por la


    Universidad del Estado de Mississippi.

    • LAM (Local Area Multicomputer) es un ambiente de


    programación y un sistema de desarrollo sobre redes
    de computadores heterogéneas. Esta implementación
    es del Centro de Supercomputación de Ohio.

    • OpenMPI es el sucesor de la herramienta LAM


    Funciones básicas de MPI

    • Cualquier programa paralelo con MPI puede


    implementarse con tan sólo 6 funciones, aunque hay
    más de 120 para aspectos avanzados.

    • Todas las funciones empiezan por MPI_ y obligan a


    que los programas MPI tengan #include <mpi.h>

    • Los programas MPI deben ser obligatoriamente


    inicializados y finalizados en MPI (MPI_Init,
    MPI_Finalize).
    Funciones de Inicio y Terminación

    • MPI_Init()
    • int MPI_Init(int *argc, char ***argv)

    • MPI_Finalize()
    • int MPI_Finalize(void)
    Ingreso

    Conexión remota con ssh


    $ ssh [email protected]
    //12AB34cd*

    Crear una carpeta personal


    $ mkdir nombre

    • Ingresar a la carpeta
    $ cd nombre
    Primer Programa

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

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

    MPI_Init(&argc, &argv);
    printf("Hola Mundo!!!\n");
    MPI_Finalize();
    }
    Compilación y Ejecución con OpenMPI

    Compilación
    • $ mpicc prog01.c -o prog01

    • Ejecutar programa
    • $ mpirun -np 4 prog01

    • Crear un archivo de nodos (ejem. nodos.lst) con


    • alfa
    • beta

    • Ejecutar programa
    • $ mpirun -hostfile nodos.lst -np 4 prog01
    Funciones de Información de Ambiente

    • Algunas de las preguntas que nos podemos hacer


    son:

    – ¿Cuántos procesos hay?

    – ¿Qué proceso soy?

    – ¿En dónde estoy corriendo?


    Comunicadores

    • Un comunicador corresponde a un grupo de procesos


    sobre el que se realiza la comunicación.

    • Dentro de un comunicador cada proceso tiene un


    rango que lo identifica.

    • Existe un comunicador básico MPI_COMM_WORLD


    que contiene a todos los procesos.

    • Existen funciones que nos permiten saber el rango y


    el número de procesos dentro de un comunicador.
    Numero de procesos

    El valor para el número de procesos se obtiene con

    int MPI_Comm_size(MPI_Comm comm, int *nproc)

    Retorna el número de procesos involucrados en una ejecución

    Entrada comm comunicador


    Salida nproc número de procesos en el grupo de comm
    Identificador de Proceso

    Para obtener el identificador o rango del proceso se utiliza

    int MPI_Comm_rank(MPI_Comm comm, int *idproc)

    Retorna el identificador o rango de un proceso

    Entrada comm comunicador


    Salida idproc rango del proceso en el grupo de comm

    El identificador o rango es un número entre cero (0) y el total de


    procesos menos uno (procesos -1).
    En múltiples
    En un solo nodo nodo (CLUSTER)
    Nombre del procesador

    Para saber donde se esta corriendo el proceso

    int MPI_Get_processor_name(char *name, int *resultlen)

    Retorna el nombre del procesador sobre el cual se esta


    corriendo al momento de hacer la llamada

    Salida name - nombre del procesador


    Salida resultlen - longitud en número de caracteres de name
    Segundo Ejemplo

    #include <stdio.h>
    #include <mpi.h>
    int idproc, nproc, resultlen;
    char nombre[30];
    int main (int argc, char** argv)
    {
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &idproc);
    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
    MPI_Get_processor_name(nombre, &resultlen);

    printf("Hola Mundo! Yo soy %d de %d corriendo en %s\n",idproc, nproc,


    nombre);
    MPI_Finalize();
    }
    Ejercicio

    • Desarrolle un programa que lea en paralelo 4 archivos que contienen


    una serie de números de tipo flotante, es necesario saber cual es el
    valor menor y mayor de cada archivo así como su promedio, se
    deben generar archivos para cada salida de información.

    • Procese los archivos en paralelo con 4 nodos con MPI.


    Tarea

    • Modifique el ejercicio anterior para que pueda realizar los cálculos


    para N archivos en N nodos.
    Funciones Básicas de Comunicación

    • La forma de comunicación en MPI es a través de


    mensajes que contienen datos.

    • La forma más simple es la comunicación punto a


    punto, donde se envía un mensaje de un proceso a
    otro.

    • Esto se realiza usando las funciones MPI_Send y


    MPI_ Recv.
    Funciones Básicas de Comunicación

    Envío de Datos

    int MPI Send(void *Datos, int cont, MPI_Datatype dtype, int


    destino, int tag, MPI_Comm comunicador)

    Recepción de datos

    int MPI Recv(void *Datos, int cont, MPI_Datatype dtype,


    int fuente, int tag, MPI_Comm comunicador,
    MPI_ Status *estado)
    Funciones Básicas de Comunicación

    void *Datos Datos de envío o recepción

    int cont Número de datos

    MPI_Datatype dtype Tipo de datos

    int destino/fuente rango del nodo al que se


    envía/recibe

    int tag Etiqueta que diferencia al


    mensaje, para ignorarla en
    puede pasar MPI_ANY_TAG
    en MPI_Recv
    Funciones Básicas de Comunicación

    MPI Comm comm Comunicador

    MPI_Status *estado Estado de la recepción (solo


    MPI_Recv) para ignorarlo
    pasar
    MPI_STATUS_IGNORE
    Tipos de Datos

    • Al enviar un dato es necesario especificar su tipo.

    • Cada tipo tiene una equivalencia con un instancia del


    tipo MPI_Datatype.

    • Esto permite el uso de MPI en ambientes


    heterogéneos.

    • Es posible generar tipos de datos más complejos,


    Tipos de Datos
    Tipo de dato MPI Tipo de dato C
    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 unsigned int
    MPI_UNSIGNED_LONG unsigned long int
    MPI_FLOAT float
    MPI_DOUBLE double
    MPI_LONG_DOUBLE long double
    MPI_BYTE
    Comunicación con bloqueo

    #include <stdio.h> else // Esclavos


    #include <stdlib.h> {
    #include <mpi.h> int length;
    printf("SLAVE (rank = %i)\n", rank);
    #define TAG_LENGTH 1
    #define TAG_DATA 2 MPI_Recv(&length, 1, MPI_INT, 0, TAG_LENGTH,
    → MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    int main(int argc, char** argv)
    { double* data = (double*)malloc(sizeof(double)*length);
    int size;
    int rank; MPI_Recv(data, length, MPI_DOUBLE, 0, TAG_DATA,
    → MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &size); free(data);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank); }

    if (rank == 0) // Maestro MPI_Finalize();


    { return 0;
    printf("MASTER (size = %i)\n", size); }
    int length = 20;
    double* data = (double*)malloc(sizeof(double)*length);
    for (int r = 1; r < size; ++r)
    {
    MPI_Send(&length, 1, MPI_INT, r, TAG_LENGTH,
    → MPI_COMM_WORLD);
    MPI_Send(data, length, MPI_DOUBLE, r, TAG_DATA,
    → MPI_COMM_WORLD);
    }
    free(data);
    }

    14/10/10
    Funciones colectivas

    • MPI_Bcast difunde un mensaje del proceso identificado


    como root a todos los procesos del grupo

    • int MPI_Bcast(void *Datos, int cont, MPI_Datatype tipo,


    int root, MPI_Comm comm)

    • Difunde datos desde root a todos los procesos


    • Entrada/Salida Datos dirección del buffer
    • Entrada cont número de elementos en el
    buffer de envio
    • Entrada tipo tipo de dato de los elementos
    Entrada root rango del proceso root
    • Entrada comm comunicador
    #include <mpi.h>
    #include <stdio.h>
    int main(int argc, char** argv)
    {
    int rank;
    int buf;
    const int root=0;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if(rank == root)
    buf = 777;
    printf("[%d]: Before Bcast, buf is %d\n", rank, buf);
    /* everyone calls bcast, data is taken from root and ends up in everyone's buf
    */
    MPI_Bcast(&buf, 1, MPI_INT, root, MPI_COMM_WORLD);
    printf("[%d]: After Bcast, buf is %d\n", rank, buf);
    MPI_Finalize();
    return 0;
    }
    Funciones colectivas

    MPI_Reduce combina los elementos provisto en el


    buffer de entrada (inbuf) de cada proceso en el grupo,
    usando la operación operador (puede ser una
    operación predefinida o definida por el usuario) y
    retorna el valor combinado en el buffer de salida
    (outbuf) del proceso root

    • int MPI_Reduce(void *DatoEnt, void *DatoSal, int


    cont, MPI_Datatype tipo, MPI_Op operador, int
    root, MPI_Comm comm)
    Funciones colectivas

    Entrada DatoEnt dirección del buffer de


    entrada
    Salida DatoSal dirección del buffer de salida
    Entrada cont número de elementos en el
    buffer de entrada
    Entrada tipo tipo de dato de los elementos
    del buffer de entrada
    Entrada operador operación (ver Tabla).
    Entrada root rango del proceso root
    Entrada comm comunicador
    Funciones colectivas

    • Operadores de reducción
    Operador Descripción

    MPI_SUM Suma

    MPI_MAXLOC Máximo y localización

    MPI_MINLOC Mínimo y localización


    Funciones colectivas
    #include <mpi.h>
    #include <stdio.h>
    int main(int argc, char** argv)
    {
    int rank, size, local_value, global_sum;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    local_value = rank;

    MPI_Reduce(&local_value, &global_sum, 1, MPI_INT, MPI_SUM, 0,


    MPI_COMM_WORLD);
    if (rank == 0)
    printf("The sum of all ranks is: %d\n", global_sum);

    MPI_Finalize();
    return 0;
    }

    También podría gustarte