Added More Comments, Fixed Some Issues

structtest should now compile under more scenarios

Author: Thomas Weise

mpi/broadcast.c

@@ -1,22 +1,21 @@
-#include <mpi.h>
-#include <stdio.h>
+#include <mpi.h>   // import MPI header
+#include <stdio.h> // import for printf
 
 int main(int argc, char *argv[]) {
-  char message[60];
-  int rank, size;
-  MPI_Status status;
+  char message[60]; // space allocated for the message
+  int rank;         // variable for process id
 
-  MPI_Init(&argc, &argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Init(&argc, &argv); // initialize MPI
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get own rank
 
-  if (rank == 0) {
+  if (rank == 0) { // create message if process is "root" (rank = 0)
     sprintf(message, "Message from root (rank %d).", rank);
   }
 
+  // broadcast: send message to all if rank==0, otherwise receive
   MPI_Bcast(message, 60, MPI_CHAR, 0, MPI_COMM_WORLD);
   printf("The message sent/received at node %d is \"%s\"\n", rank, message);
 
-  MPI_Finalize();
+  MPI_Finalize(); // shutdown MPI
   return 0;
 }

mpi/deadlock.c

@@ -5,21 +5,21 @@
 int main(int argc, char **argv) {
   int         rank, size, prev, next;
   MPI_Status  status;
-  char        message[20];
+  char        messageIn[20], messageOut[20];
 
-  MPI_Init(&argc, &argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Init(&argc, &argv); // initialize MPI
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get own rank/ID
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // get total number of processes
 
-  prev = ((size + rank - 1) % size);
-  next = ((rank + 1) % size);
-  strcpy(message, "Important message!");
+  prev = ((size + rank - 1) % size); // get rank of process to receive from, wrap at 0
+  MPI_Recv(messageIn, 20, MPI_CHAR, prev, 0, MPI_COMM_WORLD, &status); // receive msg
+  printf("Process %d received message %s from process %d.\n", rank, messageIn, prev);
 
-  MPI_Recv(message, 20, MPI_CHAR, prev, 0, MPI_COMM_WORLD, &status);
-  printf("Process %d received message %s from process %d.\n", rank, message, prev);
-  printf("Process %d is sending message %s to process %d.\n", rank, message, next);
-  MPI_Send(message, 20, MPI_CHAR, next, 0, MPI_COMM_WORLD);
+  next = ((rank + 1) % size); // get rank of process to send message to
+  strcpy(messageOut, "Important message!"); // construct message
+  printf("Process %d is sending message %s to process %d.\n", rank, messageOut, next);
+  MPI_Send(messageOut, 20, MPI_CHAR, next, 0, MPI_COMM_WORLD); // send message
 
-  MPI_Finalize();
+  MPI_Finalize(); // shut down MPI
   return 0;
 }

mpi/gatherScatterBareBones.c

@@ -1,31 +1,31 @@
-#include <mpi.h>
-#include <stdio.h>
-#include <math.h>
+#include <mpi.h>    // import MPI header
+#include <stdio.h>  // needed for printf
 
-#define DATA_SIZE 1024
+#define DATA_SIZE 1024 // the data size
 
 int main(int argc, char *argv[]) {
   int send[DATA_SIZE], recv[DATA_SIZE];
   int rank, size, count, root, res;
   MPI_Status status;
 
-  MPI_Init(&argc, &argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Init(&argc, &argv); // initialize MPI
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get own rank/ID
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // get total number of processes
 
   if(rank == 0) { //If root: Generate data to be distributed.
   }
 
   //Send data to all nodes. here: an integer array of length "count".
-  count = (DATA_SIZE / size);
+  count = (DATA_SIZE / size); // each receive gets chunk of same size
+  // scatter: if rank=0, send data (and get own share); otherwise: receive data
   MPI_Scatter(send, count, MPI_INT, recv, count, MPI_INT, 0, MPI_COMM_WORLD);
 
-  // Each node now processes its share of data and sends the results (here: int "res") to root.
+  // Each node processes its share of data and sends the result (here: int "res") to root.
   MPI_Gather(&res, 1, MPI_INT, recv, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
   if(rank == 0) { //If root: process the received data.
   }
 
-  MPI_Finalize();
+  MPI_Finalize(); // shut down MPI
   return 0;
 }

mpi/gatherScatterPrimes.c

@@ -1,36 +1,38 @@
-#include <mpi.h>
-#include <stdio.h>
-#include <math.h>
+#include <mpi.h>    // import MPI header
+#include <stdio.h>  // needed for printf
+#include <math.h>   // needed for sqrt
 
-#define DATA_SIZE 1024
+#define DATA_SIZE 1024 // let's count the primes among the first 1024 numbers
 
 int main(int argc, char *argv[]) {
   int send[DATA_SIZE], recv[DATA_SIZE];
   int rank, size, count, root, res, i, j;
   MPI_Status status;
 
-  MPI_Init(&argc, &argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Init(&argc, &argv); // initialize MPI
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get own rank/ID
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // get total number of processes
 
-  if(rank == 0) { //generate data if root
+  if(rank == 0) { //generate data (i.e., the first DATA_SIZE natural numbers) if root
     for(i = DATA_SIZE; (--i)>=0; ) { send[i] = (i + 1); }
   }
 
-  count = (DATA_SIZE / size);
+  count = (DATA_SIZE / size); // divide the data among _all_ processes
+  // scatter: if rank=0, send data (and get own share); otherwise: receive data
   MPI_Scatter(send, count, MPI_INT, recv, count, MPI_INT, 0, MPI_COMM_WORLD);
 
-  // each node now processes its share of data
+  // each node now processes its share of the numbers
   res = count; //here: count how many prime numbers are contained in the array
-  outer: for(i = count; (--i) >= 0; ) {
-    for(j = ((int)(sqrt(recv[i]))|1); j>1; j--) {
-      if((recv[i] % j) == 0) {
-        res--;
-        break; }
+  for(i = count; (--i) >= 0; ) { //j: test all odd numbers 1<j<sqrt(j)|1
+    for(j = ((int)(sqrt(recv[i]))|1); j>1; j -= 2) {
+      if((recv[i] % j) == 0) { // if a number can be divided by j
+        res--; // it cannot be a prime number, reduce number of primes
+        break; } // break inner loop to test next number
     }
   }
   printf("Process %d discovered %d primes in the numbers from %d to %d.\n", rank, res, recv[0], recv[count-1]);
 
+  // gather: all processes send data to root, only root receives data
   MPI_Gather(&res, 1, MPI_INT, recv, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
   if(rank == 0) { //if root, process the received data

mpi/nonBlockingPointToPoint.c

@@ -1,29 +1,30 @@
-#include <mpi.h>
-#include <stdio.h>
+#include <mpi.h>    // import MPI header
+#include <stdio.h>  // needed for printf
 
 int main(int argc, char *argv[]) {
   int           rank, size, prev, next;
-  char          buffer[30], buffer2[30];
-  MPI_Request   request, request2;
+  char          receiveBuffer[30], sendBuffer[30];
+  MPI_Request   receiveRequest, sendRequest;
   MPI_Status    status;
 
-  MPI_Init(&argc,&argv);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Init(&argc,&argv); // initialize MPI
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // get own rank / ID
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get total number of processes
 
-  next = ((rank + 1) % size);
-  prev = ((rank + size - 1) % size);
+  next = ((rank + 1) % size); // get rank of process to receive from
+  // _initiate_ receive operation, but do not wait for its completion
+  MPI_Irecv(receiveBuffer, 30, MPI_CHAR, prev, 42, MPI_COMM_WORLD, &receiveRequest);
 
-  MPI_Irecv(buffer, 30, MPI_CHAR, prev, 42, MPI_COMM_WORLD, &request);
+  prev = ((rank + size - 1) % size); // get rank of process to send to
+  sprintf(sendBuffer, "Non-blocking from %d!", rank);
+  // _initiate_ send operation, but do not wait for its completion
+  MPI_Isend(sendBuffer, 30, MPI_CHAR, next, 42, MPI_COMM_WORLD, &sendRequest);
 
-  sprintf(buffer2, "Non-blocking from %d!", rank);
-  MPI_Isend(buffer2, 30, MPI_CHAR, next, 42, MPI_COMM_WORLD, &request2);
+  MPI_Wait(&receiveRequest, &status); // wait for receive to complete
+  printf("%d received \"%s\"\n", rank, receiveBuffer); // print received msg
 
-  MPI_Wait(&request, &status);
-  printf("%d received \"%s\"\n", rank, buffer);
+  MPI_Wait(&sendRequest, &status); // wait for send to complete
 
-  MPI_Wait(&request2, &status);
-
-  MPI_Finalize();
+  MPI_Finalize(); // shut down MPI
   return 0;
 }

mpi/piGatherScatter.c

@@ -1,8 +1,8 @@
-#include <mpi.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <stdio.h>
+#include <mpi.h>    // import MPI header
+#include <stdio.h>  // needed for printf
+#include <stdlib.h> // for rand and RAND_MAX
+#include <string.h> // for memset
+#include <time.h>   // for srand(time(NULL));
 
 int main(int argc, char **argv) {
   int           i, size, rank;     double     x, y;

mpi/reducePrimes.c

@@ -1,41 +1,44 @@
-#include <mpi.h>
-#include <stdio.h>
-#include <math.h>
+#include <mpi.h>    // import MPI header
+#include <stdio.h>  // needed for printf
+#include <math.h>   // needed for sqrt
 
-#define DATA_SIZE 1024
+#define DATA_SIZE 1024 // let's count the primes among the first 1024 numbers
 
 int main(int argc, char *argv[]) {
-  int sent[DATA_SIZE], recv[DATA_SIZE];
+  int send[DATA_SIZE], recv[DATA_SIZE];
   int rank, size, count, root, res, i, j;
   MPI_Status status;
 
-  MPI_Init(&argc, &argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
+  MPI_Init(&argc, &argv); // initialize MPI
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank); // get own rank/ID
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // get total number of processes
 
-  if(rank == 0) { //generate data if root
-    for(i = DATA_SIZE; (--i)>=0; ) { sent[i] = (i + 1); }
+  if(rank == 0) { //generate data (i.e., the first DATA_SIZE natural numbers) if root
+    for(i = DATA_SIZE; (--i)>=0; ) { send[i] = (i + 1); }
   }
 
-  count = (DATA_SIZE / size);
-  MPI_Scatter(sent, count, MPI_INT, recv, count, MPI_INT, 0, MPI_COMM_WORLD);
+  count = (DATA_SIZE / size); // divide the data among _all_ processes
+  // scatter: if rank=0, send data (and get own share); otherwise: receive data
+  MPI_Scatter(send, count, MPI_INT, recv, count, MPI_INT, 0, MPI_COMM_WORLD);
 
-  // each node now processes its share of data
+  // each node now processes its share of the numbers
   res = count; //here: count how many prime numbers are contained in the array
-  outer: for(i = count; (--i) >= 0; ) {
-    for(j = ((int)(sqrt(recv[i]))|1); j>1; j--) {
-      if((recv[i] % j) == 0) {
-        res--;
-        break; }
+  for(i = count; (--i) >= 0; ) { //j: test all odd numbers 1<j<sqrt(j)|1
+    for(j = ((int)(sqrt(recv[i]))|1); j>1; j -= 2) {
+      if((recv[i] % j) == 0) { // if a number can be divided by j
+        res--; // it cannot be a prime number, reduce number of primes
+        break; } // break inner loop to test next number
     }
   }
   printf("Process %d discovered %d primes in the numbers from %d to %d.\n", rank, res, recv[0], recv[count-1]);
 
+  // reduce: each node takes results, applies operator MPI_SUM locally, sends result to root, where MPI_SUM is
+  // applied again. (here: locally summing up does not matter, as only 1 number). The final result is returned.
   MPI_Reduce(&res, recv, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
   if(rank == 0) { //if root, print
     printf("The total number of primes in the first %d natural numbers is %d.\n", (count*size), recv[0]);
   }
 
-  MPI_Finalize();
+  MPI_Finalize(); // shut down MPI
   return 0;
 }

mpi/structTest.c

@@ -1,23 +1,26 @@
 #include <stdio.h>
 
-typedef struct {  int     myIntA;
-                  int     myIntB;
-                  short   myShort;
-                  double  myDouble;
-                  char    myChar;
-                  float   myFloat;  } myStruct;
+typedef struct {  int     myIntA; // an integer (usually 4 bytes)
+                  int     myIntB; // another integer (usually 4 bytes)
+                  short   myShort; // a short integer (usually 2 bytes)
+                  double  myDouble; // a double-precision floating point number  (usually 8 bytes)
+                  char    myChar; // a char = 1 single byte  (usually 1 byte)
+                  float   myFloat; // a single-precision floating point number  (usually 4 bytes)
+                                   } myStruct; // name of new data type = myStruct
+
+#define LU(expression) ((long unsigned int)(expression)) // macro for type cast
 
 int main(int argc, char *argv[]) {
-  myStruct ds;
+  myStruct ds; // the data structure
 
-  printf("Struct is %lu bytes large.\n", sizeof(ds));
-  printf("Field \"myIntA\"   begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myIntA)   - ((long)&ds)), sizeof(ds.myIntA));
-  printf("Field \"myIntB\"   begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myIntB)   - ((long)&ds)), sizeof(ds.myIntB));
-  printf("Field \"myShort\"  begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myShort)  - ((long)&ds)), sizeof(ds.myShort));
-  printf("Field \"myDouble\" begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myDouble) - ((long)&ds)), sizeof(ds.myDouble));
-  printf("Field \"myChar\"   begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myChar)   - ((long)&ds)), sizeof(ds.myChar));
-  printf("Field \"myFloat\"  begins at offset %lu and is %lu bytes large.\n", (((long)&ds.myFloat)  - ((long)&ds)), sizeof(ds.myFloat));
-  printf("Effectively used data size is %lu.\n", (sizeof(ds.myIntA) + sizeof(ds.myIntB) + sizeof(ds.myShort) + sizeof(ds.myDouble) +
-                                                 sizeof(ds.myChar) + sizeof(ds.myFloat)));
+  printf("Struct is %lu bytes large.\n", LU(sizeof(ds)));
+  printf("Field \"myIntA\"   begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myIntA)   - LU(&ds)), LU(sizeof(ds.myIntA)));
+  printf("Field \"myIntB\"   begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myIntB)   - LU(&ds)), LU(sizeof(ds.myIntB)));
+  printf("Field \"myShort\"  begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myShort)  - LU(&ds)), LU(sizeof(ds.myShort)));
+  printf("Field \"myDouble\" begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myDouble) - LU(&ds)), LU(sizeof(ds.myDouble)));
+  printf("Field \"myChar\"   begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myChar)   - LU(&ds)), LU(sizeof(ds.myChar)));
+  printf("Field \"myFloat\"  begins at offset %lu and is %lu bytes large.\n", LU(LU(&ds.myFloat)  - LU(&ds)), LU(sizeof(ds.myFloat)));
+  printf("Effectively used data size is %lu.\n", LU(sizeof(ds.myIntA) + sizeof(ds.myIntB) + sizeof(ds.myShort) + sizeof(ds.myDouble) +
+                                                    sizeof(ds.myChar) + sizeof(ds.myFloat)));
   return 0;
 }