Kan du ge ett exempel på att använda MPI -sändning i en parallell datorapplikation?

Okej, låt oss ge ett exempel på att använda MPI -sändning i en parallell datorapplikation. Jag väljer ett relativt enkelt scenario:distribuera de initiala villkoren för en numerisk simulering till alla processer.

Scenario:

Föreställ dig att vi kör en parallell simulering (t.ex. modellering av befolkningstillväxten). Vi har en global parameter `initial_population` som måste kännas av * varje * process i MPI -kommunikatören. Endast rotprocessen (process med rang 0) känner initialt detta värde. Vi använder `mpi_bcast` för att distribuera` initial_population` till alla processer.

Kod Exempel (C ++)

`` `C ++

#include

#include

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

int rang, storlek;

dubbel initial_population; // global parameter

Mpi_init (&argc, &argv);

MPI_COMM_RANK (MPI_COMM_WORLD, &RANK);

MPI_COMM_SIZE (MPI_COMM_WORLD, &STORLEK);

// Initialisera initial_population endast på rotprocessen

if (rang ==0) {

initial_population =1000,0; // Exempel initialvärde

std ::cout <<"Process 0:initial population =" < } annat {

initial_population =0,0; // Andra processer initialiseras till ett standardvärde (spelar ingen roll)

}

// sända den ursprungliga populationen från process 0 till alla processer.

Mpi_bcast (&initial_population, 1, mpi_double, 0, mpi_comm_world);

// Nu har alla processer rätt värde på initial_population.

// Utför simuleringsberäkningar med hjälp av distribuerade data

// Exempel:

dubbel tillväxt_rat =0,05; // 5% tillväxttakt

dubbel final_population =initial_population * (1.0 + tillväxt_rate);

std ::cout <<"process" <

- direkt skicka: Rotprocessen skickar direkt uppgifterna till alla andra processer. Detta är enkelt men kan bli ineffektivt för ett stort antal processer.

- trädbaserad sändning: Rotprocessen skickar data till några andra processer, som sedan vidarebefordrar dem till andra och bildar ett trädliknande distributionsnätverk. Detta är i allmänhet mer skalbart än direkt skicka.

- Pipeline Broadcast: Roten skickas till en process, som skickas till en annan och så vidare. Detta är i allmänhet effektivare för stora meddelanden.

För att kompilera och köra den här koden:

1. spara: Spara koden som en ".cpp" -fil (t.ex. `sadcast_example.cpp`).

2. kompilera: Använd en MPI-Aware-kompilator (som `mpic ++` eller `mpicc`):

`` `bash

MPIC ++ Broadcast_example.cpp -o Broadcast_example

`` `

3. Run: Använd `mpirun` eller` mpiexec` för att utföra programmet med önskat antal processer:

`` `bash

mpirun -n 4./broadcast_example # Kör med 4 processer

`` `

Utgång (exempel med 4 processer):

`` `

Process 0:Initial population =1000

Process 0:Initial population =1000, simulerad slutlig befolkning =1050

Process 1:Initial population =1000, simulerad slutpopulation =1050

Process 2:Initial population =1000, simulerad slutpopulation =1050

Process 3:Initial population =1000, simulerad slutpopulation =1050

`` `

Nyckel takeaways:

- `mpi_bcast 'är avgörande för att distribuera data från en process (roten) till alla andra processer i en kommunikatör.

- Det är en * blockerande * operation. Alla processer väntar tills sändningen är klar.

- Det används vanligtvis för att distribuera initiala data, konfigurationsparametrar eller annan information som behövs av alla processer för att starta eller fortsätta en parallell beräkning.

- rotprocessen * måste * ha rätt datavärde före sändningen.

- Alla processer * måste * ringa `mpi_bcast '(till och med rotprocessen). De tillhandahåller alla en minnesplats för att * ta emot * uppgifterna.

Detta exempel ger en grundläggande förståelse av `mpi_bcast '. Du kan anpassa den till mer komplexa parallella applikationer där distribution av data till alla processer krävs. Kom ihåg att välja rotprocessen noggrant och se till att de uppgifter som ska sändas är korrekt initialiserade på den processen.