Add MPI exercises and project description.

Author: ptal

7-mpi/demo/circular.cpp

@@ -0,0 +1,31 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+  int rank, num_procs;
+
+  /* Initialize the infrastructure necessary for communication */
+  MPI_Init(&argc, &argv);
+
+  /* Identify this process */
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  /* Find out how many total processes are active */
+  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+  std::string ping("ping");
+  std::string rdata(4, ' ');
+  int next_rank = (rank + 1) % num_procs;
+  int prev_rank = ((rank + num_procs) - 1) % num_procs;
+  printf("%d: send ping to %d...\n", rank, next_rank);
+  MPI_Ssend(ping.data(), ping.size(), MPI_CHAR, next_rank, 0, MPI_COMM_WORLD);
+  printf("%d: receive ping from %d...\n", rank, prev_rank);
+  MPI_Recv(rdata.data(), rdata.size(), MPI_CHAR, prev_rank, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+
+  /* Tear down the communication infrastructure */
+  MPI_Finalize();
+  return 0;
+}

7-mpi/demo/hello_world.cpp

@@ -0,0 +1,61 @@
+/*
+  "Hello World" MPI Test Program (from Wikipedia)
+*/
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+    char buf[256];
+    int my_rank, num_procs;
+
+    /* Initialize the infrastructure necessary for communication */
+    MPI_Init(&argc, &argv);
+
+    /* Identify this process */
+    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
+
+    /* Find out how many total processes are active */
+    MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+    /* Until this point, all programs have been doing exactly the same.
+       Here, we check the rank to distinguish the roles of the programs */
+    if (my_rank == 0) {
+        int other_rank;
+        printf("We have %i processes.\n", num_procs);
+
+        /* Send messages to all other processes */
+        for (other_rank = 1; other_rank < num_procs; other_rank++)
+        {
+            sprintf(buf, "Hello %i!", other_rank);
+            MPI_Send(buf, 256, MPI_CHAR, other_rank,
+                     0, MPI_COMM_WORLD);
+        }
+
+        /* Receive messages from all other processes */
+        for (other_rank = 1; other_rank < num_procs; other_rank++)
+        {
+            MPI_Recv(buf, 256, MPI_CHAR, other_rank,
+                     0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+            printf("%s\n", buf);
+        }
+
+    } else {
+        /* Receive message from process #0 */
+        MPI_Recv(buf, 256, MPI_CHAR, 0,
+                 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+        assert(memcmp(buf, "Hello ", 6) == 0);
+
+        /* Send message to process #0 */
+        sprintf(buf, "Process %i reporting for duty.", my_rank);
+        MPI_Send(buf, 256, MPI_CHAR, 0,
+                 0, MPI_COMM_WORLD);
+
+    }
+
+    /* Tear down the communication infrastructure */
+    MPI_Finalize();
+    return 0;
+}

7-mpi/demo/order_guarantee.cpp

@@ -0,0 +1,36 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+  int rank, num_procs;
+
+  /* Initialize the infrastructure necessary for communication */
+  MPI_Init(&argc, &argv);
+
+  /* Identify this process */
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  /* Find out how many total processes are active */
+  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+  std::string hello("hello");
+  std::string world("world");
+
+  if(rank == 0) {
+    MPI_Send(hello.data(), hello.size(), MPI_CHAR, 1, 0, MPI_COMM_WORLD);
+    MPI_Send(world.data(), world.size(), MPI_CHAR, 1, 0, MPI_COMM_WORLD);
+  }
+  else if(rank == 1) {
+    MPI_Recv(hello.data(), hello.size(), MPI_CHAR, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(world.data(), world.size(), MPI_CHAR, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    std::cout << "We should receive hello world, and we received: " << hello << " " << world << std::endl;
+  }
+
+  /* Tear down the communication infrastructure */
+  MPI_Finalize();
+  return 0;
+}

7-mpi/demo/progress_guarantee.cpp

@@ -0,0 +1,40 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+  int rank, num_procs;
+
+  /* Initialize the infrastructure necessary for communication */
+  MPI_Init(&argc, &argv);
+
+  /* Identify this process */
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  /* Find out how many total processes are active */
+  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+  std::string hello("hello");
+  std::string world("world");
+  int tag1 = 1;
+  int tag2 = 2;
+  if(rank == 0) {
+    size_t buf_size = hello.size() * sizeof(char) + MPI_BSEND_OVERHEAD;
+    char* b = (char*)malloc(buf_size);
+    MPI_Buffer_attach(b, buf_size);
+    MPI_Bsend(hello.data(), hello.size(), MPI_CHAR, 1, tag1, MPI_COMM_WORLD);
+    MPI_Ssend(world.data(), world.size(), MPI_CHAR, 1, tag2, MPI_COMM_WORLD);
+  }
+  else if(rank == 1) {
+    MPI_Recv(world.data(), world.size(), MPI_CHAR, 0, tag2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(hello.data(), hello.size(), MPI_CHAR, 0, tag1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    std::cout << "We should receive hello world, and we received: " << hello << " " << world << std::endl;
+  }
+
+  /* Tear down the communication infrastructure */
+  MPI_Finalize();
+  return 0;
+}

7-mpi/exercises/ping_pong.cpp

@@ -0,0 +1,36 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+    int rank, num_procs;
+
+    /* Initialize the infrastructure necessary for communication */
+    MPI_Init(&argc, &argv);
+
+    if(argc < 2) {
+        printf("usage: %s <num-ping-pong>\n", argv[0]);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+    int num_ping_pong = std::stoi(argv[1]);
+
+    /* Identify this process */
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    /* Find out how many total processes are active */
+    MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+    if(num_procs % 2 != 0) {
+        printf("This program must be ran with an even number of processes.\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+        exit(1);
+    }
+
+    /** TODO: processes exchange "ping" / "pong" messages `num_ping_pong` times. */
+
+    /* Tear down the communication infrastructure */
+    MPI_Finalize();
+    return 0;
+}

7-mpi/exercises/ping_pong_ring.cpp

@@ -0,0 +1,31 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+  int rank, num_procs;
+
+  /* Initialize the infrastructure necessary for communication */
+  MPI_Init(&argc, &argv);
+
+  if(argc < 2) {
+    printf("usage: %s <num-ping-pong>\n", argv[0]);
+    MPI_Abort(MPI_COMM_WORLD, 1);
+  }
+  int num_ping_pong = std::stoi(argv[1]);
+
+  /* Identify this process */
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  /* Find out how many total processes are active */
+  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+  /** TODO: ping pong ring. */
+
+  /* Tear down the communication infrastructure */
+  MPI_Finalize();
+  return 0;
+}

7-mpi/exercises/prime.cpp

@@ -0,0 +1,43 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+  int rank, num_procs;
+
+  /* Initialize the infrastructure necessary for communication */
+  MPI_Init(&argc, &argv);
+
+  if(argc < 2) {
+    printf("usage: %s <upper_bound_prime>\n", argv[0]);
+    MPI_Abort(MPI_COMM_WORLD, 1);
+  }
+  int n = std::stoi(argv[1]);
+
+  /* Identify this process */
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  /* Find out how many total processes are active */
+  MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+  /** This is a sequential loop: need to be parallelized. */
+  int totalPrimes = 0;
+  bool prime;
+  for(int i = 2; i <= n; i++) {
+    prime = true;
+    for(int j = 2; j < i; j++) {
+      if((i % j) == 0){
+        prime = false;
+        break;
+      }
+    }
+    totalPrimes += prime;
+  }
+
+  /* Tear down the communication infrastructure */
+  MPI_Finalize();
+  return 0;
+}

7-mpi/exercises/stop_when.cpp

@@ -0,0 +1,30 @@
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <mpi.h>
+
+int main(int argc, char **argv)
+{
+    int rank, num_procs;
+
+    /* Initialize the infrastructure necessary for communication */
+    MPI_Init(&argc, &argv);
+
+    /* Identify this process */
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    /* Find out how many total processes are active */
+    MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
+
+    if(num_procs != 3) {
+        printf("This program must be ran with 3 processes.\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+        exit(1);
+    }
+
+    /** TODO: Stop when either process 1 or 2 wakes up. */
+
+    /* Tear down the communication infrastructure */
+    MPI_Finalize();
+    return 0;
+}

README.md

@@ -162,3 +162,27 @@ contiguous lines of the global image. What do you observe in terms of speed-up c
 ### [Optional⭐] N-Queens
 
 * `6-pgas-chapel/exercises/nqueens.chpl`: Parallelize the N-queens code seen in a previous course using Chapel.
+
+## MPI
+
+* `7-mpi/exercises/ping_pong.cpp`: Given `N` processes, we pair processes `(0,1), (2,3), ...` such that `0` sends "ping" to `1` which replies with "pong". This is repeated `num_ping_pong` times as specified by a program's argument.
+* `7-mpi/exercises/ping_pong_ring.cpp`: Given `N` processes organized in a ring, a process send "ping" to its right, receive "ping" from its left, send "pong" to its left and receive "pong" from its right. This is repeated `num_ping_pong` times as specified by a program's argument.
+* `7-mpi/exercises/stop_when.cpp`: Given 3 processes, process 1 and 2 waits for a random number of seconds, and afterwards they send a message to the process 0 (can use `MPI_ANY_SOURCE`). Once process 0 receives the message, it broadcasts a termination message to everybody, and all processes *immediately* stop.
+* `7-mpi/exercises/sum.cpp`: Suppose we have `N` processes. The process 0 generates a random array `arr`. Using `MPI_Scatter`, the array is distributed among the processes. They all compute the local sum of the array. Using `MPI_Reduce` we retrieve the global sum and print it in the process 0.
+* Read [this paper](http://www1.cs.columbia.edu/~sedwards/papers/kahn1974semantics.pdf) on Kahn network.
+
+### Project: Maze Creation and Testing
+
+In this project, you will develop a parallel algorithm which creates a maze and test how many paths can enter and exit the maze.
+
+* Use randomized depth-first search to create a maze, or with any technique of your choice (see [here](https://en.wikipedia.org/wiki/Maze_generation_algorithm#Randomized_depth-first_search)).
+* Given the beginning and exit of the labyrinth, design three different algorithms with MPI (different communication and/or data-splitting strategies) finding *all different paths* in the labyrinth.
+* Compare the paths found (if the maze is small enough) or the number of paths found (otherwise) among the algorithms. You must obtain the same results, otherwise an algorithm is wrong.
+* Write a short report explaining the intuitions behind the three algorithms, and evaluate those algorithms on a set of generated maze (from small to large).
+* Give hypothesis on why an algorithm is working better than another.
+* The goal is to practice with MPI and different topologies/strategies. It is OK if your algorithm is slower than the others as long as you can explain why.
+* For students in the Master in HPC: it is mandatory to run some experiments on the HPC with the number of nodes >= 2.
+* The code you produce must be your own and *you cannot copy* an existing MPI algorithm from internet.
+* You can work in team of 3, each member must design and implement a different algorithm, and you must explicitly say in the report who wrote which algorithm.
+* Send the project before the exam at pierre.talbot@uni.lu with the subject "[MHPC][PGC] Project MPI".
+* *Optional*: Use the [Boost.MPI library](https://www.boost.org/doc/libs/1_86_0/doc/html/mpi.html) to create your application.