3.2.2 Parallel loop with chunks of one with 2 methods of random number streams¶

You should study the code for this version, focusing on the for loop and how it differs from the previous version.

Note

Rule of thumb: splitting a for loop into equal chunks requires the #pragma omp for syntax. You do not use this syntax if you move forward the proper amount per thread yourself in the code. Note how this is how we accomplish “chunks of one” in the loop on line 117 by incrementing the loop counter by the number of threads (i+=numThreads).

#include <stdio.h>        // printf()
 #include <time.h>        // time()

#include <omp.h>

#include <trng/yarn2.hpp>  // trng YARN (yet another random number) generator class
 #include <trng/uniform_dist.hpp>   // we'll use a uniform distribution
                                   // of the random numbers

#define LEAPFROG 0
 #define BLOCKSPLIT 1

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

// set up what conditions we will use:
   //  - defult size of repetitions in the loop
   //  - whether to use a constant seed so we can repeat and
   //    get same random values in stream

int repetitions = 8;
   int useConstantSeed = 0; // for same stream, set this to 1 on cammand line with -c

// rnage for uniform distribution of random numbers
   int min = 1;
   int max = 99;
   // for method the random generator with use to dole out the numbers
   int doleOut = LEAPFROG;

// for openMP
   int numThreads = 1;

// gather command line arguments
   getArguments(argc, argv, &numThreads, &repetitions, &useConstantSeed, &doleOut);

// openMP additions +++++++++++++++++++++++++++++++++++++++++++
   int tid =0;
   omp_set_num_threads(numThreads);
   // Print out info
   printf("trng random number stream will be split ");
   if (doleOut == LEAPFROG) {
     printf("using leapfrog.\n");
   } else {
     printf("into blocks.\n");
   }
   printf("The loop is partitioned into chunks of 1 per thread.\n");
   printf("This means the loop index for each thread starts at its tid and updates by the number of threads.\n");
   printf("the output is printed like this:\n");
   printf("thread (loop index):randNumber\n");
   // openMP additions +++++++++++++++++++++++++++++++++++++++++++++

// /////////////////  random generator setup /////////////////////

// random numbers start from a seed value
   long unsigned int seedValue;  // note for trng this is long unsigned

// same constant seed will generate the same sequence of rndom numbers
   // use for testing to varify same sequence regardless of number of threads
   if (useConstantSeed) {
     seedValue = 888777666;
   } else {  // variable seed based on computer clock time
     seedValue = (long unsigned int)time(NULL); // enables variation; use for simulations
   }

// For threaded openMP version, each thread will fork and have a private copy of:
 //
 //  its thread id
 //
 // These are also automatically private because they are declared inside the pragma block:
 //  -the generator and the distribution
 //  -the next value that will comback from the generator via the distribution
 //  -the loop counter
 //
 //  Since seedValue and repetitions are read but not written, they are shared.
 //
 // ////////////////////   begin fork here by using pragma for the compiler
 #pragma omp parallel default (none) \
 private(tid) \
 shared(seedValue,repetitions, min, max, numThreads, doleOut)
   {
     // number generation needs two things: a generator and a distribution of the numbers
     // declare the generator object
     trng::yarn2 randGen;
     // declare the distribution to use (here it is uniform with vallues in the range min to max)
     trng::uniform_dist<> uniform(min, max);

// Set the starting point of the generator by seeding it
     randGen.seed(seedValue);

// OpenMP addition: get my thread number
     tid = omp_get_thread_num();

// Addition for openMP and parallel in general: the generator must be set to give
     // the thread its portion of the random numbers.
     // Note if single thread, this isn't necessary.
     if (numThreads > 1) {
       if (doleOut == LEAPFROG) {
         // thread will get substream tid from numThread separate substreams
         randGen.split((unsigned)numThreads, tid);  // this is the leapfrog setup
       } else {
         // thread will get substream as a block:
         // thread 0 starts at 0, thread 1 starts at repetitions / numThreads, etc.
         randGen.jump(tid * (repetitions / numThreads));   // block split
       }
     }
     // /////////////////////// end PRNG setup ///////////////////////////////////

// /////////////// get a portion of the stream //////////////////////////////
     int nextRandValue;   // holds the next value as we go through the loop

// loop to get each number in the PRNG stream and print it
     // Note here a different loop structure- programmer decides which
     // parts of the loop a thread will complete.
     int i;
   // no openMP pragma for this version
     for (i=tid; i < repetitions; i+=numThreads) {
       // get next number in the stream from the distribution
       nextRandValue = uniform(randGen);
       // print tid(i):nextRandValue
       printf("t%2d(%2d):%2d \n", tid, i, nextRandValue);
     }

} // end of parallel block

return 0;
 }

As a reference, here is the set of numbers when using one thread, which is the same as the sequential version:

t 0( 0):83
t 0( 1):63
t 0( 2):97
t 0( 3):21
t 0( 4):62
t 0( 5):54
t 0( 6):14
t 0( 7):46

Now try different setups for this code, as you did for the equal chunks version:

['-c', '-n 8', '-d block', '-t 2']
['-c', '-n 8', '-d block', '-t 4']
['-c', '-n 8', '-d leapfrog', '-t 2']
['-c', '-n 8', '-d leapfrog', '-t 4']
['-c', '-n 8', '-d leapfrog', '-t 3']

Note that the output is explaining how it is running. You should be able to observe the following:

With block splitting and 2 threads, thread 0 still gets the first block of 4 values from the sequential version, and thread 1 gets the next block, even though the loop indexes it completes are different from the previous equal chunk loop version.
With leapfrog and 2 threads, each thread gets the same numbers as the equal chunk loop version:
- Thread 0 should get every other number: 83, 97, 62, 14
- Thread 1 should get every other number: 63, 21, 54, 46
Leapfrog works with 3 threads

Command line code for reference¶

This code block below has code for handling the command line arguments for the parallel versions in this subsection and the previous one.

void getArguments(int argc, char *argv[],
                 int * numThreads, int * N, int * useConstantSeed, int * doleOut);

int isNumber(char s[]);
 void exitWithError(char cmdFlag, char ** argv);
 void invalidChoice(char cmdFlag, char ** argv);
 void Usage(char *program);

#include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>  // C++ string comparison

#define LEAPFROG 0
 #define BLOCKSPLIT 1

void getArguments(int argc, char *argv[],
                   int * numThreads, int * N, int * useConstantSeed, int * doleOut)
 {

int c;        // result from getopt calls

// The : after a character means a value is expected
   // No colon means it is simply a flag with no associated value
   while ((c = getopt (argc, argv, "n:t:d:hc")) != -1) {

// getopt implicitly sets a value to a char * (string) called optarg
 // to what the user typed after -n
     switch (c)
       {
       // character string entered after the -N needs to be a number
       case 'n':
         if (isNumber(optarg)) {
           *N = atoi(optarg);
         } else {
           exitWithError(c, argv);
         }
         break;

// character string entered after the -t needs to be a number
       case 't':
         if (isNumber(optarg)) {
           *numThreads = atoi(optarg);
         } else {
           exitWithError(c, argv);
         }
         break;

case 'd':
         if (strcmp(optarg, "block") == 0) {
           *doleOut = BLOCKSPLIT;
         } else if (strcmp(optarg, "leapfrog") == 0) {
           *doleOut = LEAPFROG;
         } else {
           invalidChoice(c, argv);
         }
         break;
       // If the -h is encountered, then we provide usage
       case 'h':
         Usage(argv[0]);
         exit(0);
         break;

// If the -c is encountered, then we change the constant seed flag
       case 'c':
         *useConstantSeed = 1;
         break;

case ':':
         printf("Missing arg for %c\n", optopt);
         Usage(argv[0]);
         exit(EXIT_FAILURE);
         break;

case '?':
         if (
             (optopt == 'v') ||
             (optopt == 't')
           )
         {
           Usage(argv[0]);
           exit(EXIT_FAILURE);
         } else if (isprint (optopt)) {
           fprintf (stderr, "Unknown option `-%c'.\n", optopt);
           Usage(argv[0]);
           exit(EXIT_FAILURE);
         } else {
           fprintf (stderr,
                   "Unknown non-printable option character `\\x%x'.\n",
                   optopt);
           Usage(argv[0]);
           exit(EXIT_FAILURE);
         }
         break;

}
   }
 }

// Check a string as a number containing all digits
 int isNumber(char s[])
 {
     for (int i = 0; s[i]!= '\0'; i++)
     {
         if (isdigit(s[i]) == 0)
               return 0;
     }

return 1;
 }

// Called when isNumber() fails
 void exitWithError(char cmdFlag, char ** argv) {
   fprintf(stderr, "Option -%c needs a number value\n", cmdFlag);
   Usage(argv[0]);
   exit(EXIT_FAILURE);
 }

void invalidChoice(char cmdFlag, char ** argv) {
   fprintf(stderr, "unrecognized value for Option -%c needs 'block' or 'leapfrog'\n", cmdFlag);
   Usage(argv[0]);
   exit(EXIT_FAILURE);
 }

void Usage(char *program) {
   fprintf(stderr, "This program demonstrates use of a loop to create a stream of random numbers in parallel.\n");
   fprintf(stderr, "Usage: %s [-h] [-t numThreads] [-n numReps][-c] [-d block|leapfrog]\n", program);
   fprintf(stderr, "   -h shows this message and exits.\n");
   fprintf(stderr, "   -t indicates number of threads to use.\n");
   fprintf(stderr, "   -n indicates the number of repetitions of the loop (default is 8).\n");
   fprintf(stderr, "   -c indicates that a fixed seed will be used, resulting in the same stream of numbers each time this is run.\n");
   fprintf(stderr, "   -d indicates whether the trng generator will dole out numbers in blocks or in leapfrog fashion. default is leapfrog.\n");
 }

You have attempted of activities on this page