Message Passing Interface

Jednou z nejdůležitějších věcí pro pochopení knihovny MPI jsou komunikátory. Komunikátory jsou skupiny procesů při běhu MPI aplikace. Komunikátory se dají dynamicky vytvářet. Skupina MPI_COMM_WORLD existuje vždy a obsahuje všechny procesy dané aplikace. Proces je identifikován podle ranku, což je jeho pořadové číslo od nuly uvnitř skupiny. Pro komunikaci jsou pak k dispozici dva mechanismy: message passing a remote memory access. [6]

Velká část funkcí v MPI je určena pro realizaci komunikace mezi dvěma procesy. Klasickým příkladem je funkce MPI_Send, která pošle zprávu od jednoho procesu jinému procesu. Často jsou tyto funkce používány na programových architekturách typu master-slave, kde je řídící uzel zodpovědný za činnost svých „sluhů“. Typicky master pošle dávky instrukcí nebo dat každému podřízenému, počká až přijdou všechny odpovědi a pak je poskládá do jednoho celku.

Blokující funkce:

int MPI_Recv(void* buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status)
int MPI_Send(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Parametr buf je ukazatel na data která chceme odeslat, respektive na místo v paměti, kam chceme uložit přijatou zprávu. count udává počet přijatých hodnot, datatype jejich datový typ (pomocí vynásobení velikosti datového typu a počtu hodnot pak funkce zjistí kolik bajtů přečíst), source identifikuje proces, od kterého chceme číst (pomocí ranku – pořadového čísla), tag identifikuje zprávu a slouží spíše pro vizualizaci nebo ladění, comm je handle komunikátoru a konečně status obsahuje informaci o stavu operace.

Neblokující funkce:

int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)
int MPI_Isend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Tyto funkce fungují stejně jako jejich blokující protějšky, pouze s tím rozdílem, že program nečeká na jejich dokončení.

Mezi funkce pro hromadnou komunikaci patří například:

int MPI_Bcast(void* buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm);
int MPI_Scatter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvcount, int root, MPI_Comm comm);
int MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm);
int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)

• MPI_Bcast – Pošle zprávu od procesu s rankem root všem ostatním procesům ve skupině
• MPI_Scatter – Pošle data od jedné úlohy všem ostatním ve skupině
• MPI_Gather – Shromáždí hodnoty ze skupiny procesů
• MPI_Reduce – Zredukuje data všech procesů na jednu hodnotu. Operaci redukce si lze vybrat v parametru op

Je původní implementací standardu MPI 1.x. Správná výslovnost této zkratky má být „em pí aj sí ejč“, nikoli jako „m-pitch“. Tato implementace vznikla v Argonne National Laboratory a na vývoji se také podílela Mississippi State University. První ze zmíněných pak pokračovala ve vývoji celé následující desetiletí a nyní nabízí MPICH 2, jež implementuje standard MPI 2.1. Tato knihovna je například součástí distribuce Debian.

LAM/MPI je zkratka z Local Area Multicomputer / Message Passing Interface. Tato implementace vznikla v Ohio Supercomputing Center. Dále se na jejím vývoji podílely týmy z Ohio State University, University of Notre Dame a Indiana University Ti nyní také udržují webové stránky knihovny. Více o autorech lze najít v [1]. Podle informací dostupných na oficiálních webových stránkách projektu [2] však byl vývoj LAM/MPI zastaven (přijímají již pouze bezpečnostní záplaty) a snaha jeho vývojářů LAM/MPI se přesunula k projektu Open MPI (viz dále). Uživatelé LAM/MPI jsou zároveň vyzýváni k přechodu na Open MPI.

Pro komunikaci mezi výpočetními uzly LAM/MPI podporuje TCP/IP, sdílenou paměť, Myrinet (GM) a Infiniband (mVAPI). LAM/MPI implementuje kompletně MPI-1 a z velké části také MPI-2. Aplikace psané pro LAM/MPI jsou plně kompatibilní a snadno portovatelné na jiné implementace standardu MPI. Navíc však LAM/MPI přidává kvalitní podporu ladění. Monitorování probíhá na dvou úrovních: Jednak knihovna dokáže kdykoli pozastavit proces a vytvořit jeho snímek (angl. snapshot) a odeslat informace o jeho stavu. Takovýto snapshot pak obsahuje veškeré aspekty synchronizace, členství ve skupinách komunikátorů a také obsah zpráv. A za druhé, knihovna MPI je navržena tak, aby mohla poskytnout globální záznam veškeré komunikace, a to jak za běhu, tak po jeho skončení. Tento záznam může být dokonce vizualizován.

Open MPI je poměrně nový, avšak slibný projekt, který se pokouší o spojení několika ostatních implementací MPI (FT-MPI, LA-MPI, LAM/MPI a PACX-MPI) s tím, že z každé implementace si vezme to, v čem je nejlepší. Vznikla tak kompletně nová implementace MPI-2. Za jejím vývojem stojí celé konsorcium firem a univerzit, mezi něž patří i např. University Of British Columbia, Cisco, IBM nebo Sun Microsystems. Kompletní seznam organizací podílejících se na vývoji lze najít v [3].

Její vývoj začal v říjnu roku 2005 [4]. V březnu roku 2006 spatřilo světlo světa verze 1.0. Vývoj pak pokračoval plynule dále. Dvacátého šestého června 2013 pak vyšla momentálně (v době psaní tohoto textu) aktuální stabilní verze 1.6.5. Kromě toho je také možné si stáhnout nestabilní snapshot vývojové verze, které vychází každý den, nebo rovnou získat aktuální obsah vývojového repozitáře pomocí SVN. Tato knihovna je také součástí mnoha populárních distribucí Linuxu (Fedora, Ubuntu, openSUSE...).

Prvním krokem úspěšného vytvoření MPI aplikace je instalace potřebných knihoven. Instalace z vaší distribuce bude pravděpodobně nejrychlejší, kdežto instalace kompilací zdrojových kódů stažených přímo z oficiálních stránek vám přinese nejčerstvější verzi. Dále je potřeba vytvořit soubor obsahující zdrojový text, např. main.c, do kterého napíšeme standardní kostru programu v jazyce C a navíc přidáme tyto tři řádky:

• na začátek souboru: #include <mpi.h> // dovoz rozhraní MPI
• na začátek funkce main: MPI_Init(&argc, &argv); // inicializace knihovny
• na konec funkce main: MPI_Finalize(); // ukončení práce s MPI

Tím jsme získali minimální kostru MPI aplikace.

K běhu takovéto aplikace nám bude stačit jeden počítač. Kompilace se provede příkazem:

  $ mpicc main.c

Spuštění pak jako obvykle:

  $ ./a.out

V případě, že budeme chtít v programu používat více procesů a tedy i počítačů (kvůli tomu jsme přece MPI instalovali…), musíme nejprve vytvořit soubor openmpi_hosts, do kterého dáme jména těchto počítačů a kolik slotů mají používat. Jestliže potřebujeme používat více strojů, ale máme jen jeden, můžeme využít možnost takzvaných slotů: jednoduše napíšeme, kolik procesů může běžet na kterém stroji. Takže jestliže potřebujeme deset procesů a všechny na našem počítači, napíšeme do openmpi_hosts pouze toto:

localhost slots=10

Takto můžeme pro každý počítač specifikovat počet procesů na něm běžících. Takže takový soubor pak může vypadat například takto:

# Sample hostfile for OpenMPI
localhost slots=1
merlin    slots=2
eva       slots=2
adela     slots=2

V tomto případě však již nemůžeme aplikaci spouštět jako předtím, ale musíme k tomu použít již výše zmíněný démon mpiexec:

$ mpiexec --hostfile openmpi_hosts -np 10 ./a.out

Parametr -np pak udává, kolik kopií programu se má spustit a parametr - -hostfile udává cestu k souboru mapujícímu procesy na hosty.

 HelloWorld

Nyní již známe některé základní funkce knihovny MPI a také jak aplikaci zkompilovat a spustit, a proto si již můžeme vytvořit legendární Hello World (dle anglické wikipedie):

/*
  "Hello World" s využitím MPI
 */
 #include <mpi.h>
 #include <stdio.h>
 #include <string.h>
 
 #define BUFSIZE 128
 #define TAG 0
 
 int main(int argc, char *argv[])
 {
   char idstr[32];
   char buff[BUFSIZE];
   int numprocs;
   int myid;
   int i;
   MPI_Status stat; 
 
   MPI_Init(&argc,&argv); /* inicializace MPI */
   MPI_Comm_size(MPI_COMM_WORLD,&numprocs); /* zjistíme, kolik procesů běží */
   MPI_Comm_rank(MPI_COMM_WORLD,&myid); /* zjistíme id svého procesu */
 
   /* Protože všechny programy mají stejný kód (Same Program, Multiple Data – SPMD) rozdělíme činnost
      programů podle jejich ranku. Program s rankem 0 rozešle postupně všem zprávu a přijme od všech
       odpověď 
   */
   if(myid == 0)
   {
     printf("%d: We have %d processors\n", myid, numprocs);
     for(i=1;i<numprocs;i++)
     {
       sprintf(buff, "Hello %d! ", i);
       MPI_Send(buff, BUFSIZE, MPI_CHAR, i, TAG, MPI_COMM_WORLD);
     }
     for(i=1;i<numprocs;i++)
     {
       MPI_Recv(buff, BUFSIZE, MPI_CHAR, i, TAG, MPI_COMM_WORLD, &stat);
       printf("%d: %s\n", myid, buff);
     }
   }
   else
   {
     /* obdržíme zprávu od procesu s rankem 0: */
     MPI_Recv(buff, BUFSIZE, MPI_CHAR, 0, TAG, MPI_COMM_WORLD, &stat);
     sprintf(idstr, "Processor %d ", myid);
     strcat(buff, idstr);
     strcat(buff, "OK\n");
     /* Odpovíme na zprávu: */
     MPI_Send(buff, BUFSIZE, MPI_CHAR, 0, TAG, MPI_COMM_WORLD);
   }
 
   MPI_Finalize(); 
   return 0;
 }

Program zkompilujeme a spustíme:

[michel@localhost pokusy]$ mpicc HelloWorld.c && mpiexec --hostfile openmpi_hosts -np 4 ./a.out
0: We have 4 processors
0: Hello 1! Processor 1 OK

0: Hello 2! Processor 2 OK

0: Hello 3! Processor 3 OK