Adding OpenMP

Objectives

1. Add a parallel component to lab1.

Notes

• Perform the following steps
  1. Download the lab2.cpp
  2. Add the library linking command to the Makefile
     • Edit the Makefile and add LDLIBS = -fopenmp near the top.
     • This will cause the final program to link with the OpenMP library
     • Make sure you are building the correct program as well.
  3. Add the include file for OpenMP
     • #include <omp.h>
  4. Parallelize the loop that builds the image in the main routine.
     • Add the command to mark the parallel block
       • After the vector is declared, but before the for loop
       • #pragma omp parallel
       • Then put the for loop in a code block.

       • int main() {
             vector<vector<PixelT>> image(XDIM,vector<PixelT>(YDIM));
         
             #pragma omp parallel
             {
                 for(int i = 0; i < XDIM; ++i) {
                 ...
                 } // end of for i loop
              } // parallel block 

     • Mark the outside for loop as parallel
       • #pragma omp parallel for
       • Before the first for loop

         #pragma omp parallel for
         for(int i = 0; i <        #pragma omp parallel for
                 for(int i = 0; i < image.size(); ++i) {
          image.size(); ++i) {
             ...  

     • Done, you can run this to see if you have any improvement.
       • My program is called finalProduct
       • time finalProduct
         • man 1 time
           • Wallclock time
           • User CPU time (this process does a lot of I/O)
           • System time : time spent in system calls (most of the process time
     • What is using all the time?
  5. Add a timer or two to the process.
     • double omp_get_wtime(void)
     • Returns the number of seconds since some time in the past.
     • The time in the past will not change.
     • Get time1 before the loop
     • Get time2 after the loop
     • Total wall clock time = time2 - time1
     • Report this for loop and save time.

     • Total time: 0.85 sec
       Loop time:  0.08 sec
       Write time: 0.77 sec
                   

     • Looks like AMDHAL got us.
  6. Add some controls so we can test things beter
     • -w n, set the width to be n, n ≥ 100
     • -h n, set the height to be n, n ≥ 100
       • demote XDIM and YDIM to local variables in the main
       • Set them to 100
       • Parse the command line arguments BEFORE image is declared
         • I love vectors, they are dynamic and can be declared at run time.
       • change the loop controls to be image.size() and image[0].size()
       • Remove all other references to XDIM and YDIM as above.
     • -t n, set the number of threads to be n, n ≥ 1
       • Declare a variable in main called threads
       • Default to 1
       • Parse args.
       • We will use this later.
     • -x, do not write the file
       • Declare a variable in main called doWrite
       • Set this to true.
       • Wrap the WriteImage in a if statement base on this variable.
     • -v, be verbose
       • Declare a variable verbose
       • false by default
       • If true, report configuration and write times.
       • Otherwise do not report anything.

         [bennett@mirkwood lab2]> finalProduct -v -w 1000 -h 1000
                 Creating a 1000 x 1000 image.
                 Using 1 threads.
                 Writing the output file to foo
         
         Total time: 2.09 sec
         Loop time:  0.20 sec
         Write time: 1.89 sec
         
         [bennett@mirkwood lab2]> finalProduct
         [bennett@mirkwood lab2]>
         

     • You might want to add an output file name flag. (-f name)
  7. Add control over thread count:
     • void omp_set_num_threads(int num_threads);.
     • Also int omp_get_num_threads();
     • Place it anywhere before the parallel directive.
  8. Just for a test, we might change the array initalization

     •  int id = omp_get_thread_num()+1;
        for()
          for()
             for() 
                  //image[i][j].color[k] = rand()%255;
                  image[i][j].color[k] = 255/id;
       
             }
          } 
        } 

     • Then the image will be striped.
  9. Test it a bit with 255/id
     • You might want to try something like -w 10000 -h 10000
     • Do you get speed improvement in parallel?
     • What is your speedup.
  10. Test it a bit with rand()%255
      • What happened?
      • rand is not reentrant ie it is not designed to work in parallel.
      • rand_r(unsigned int & seed) is.
      • Replace rand with rand_r and try again.
  11. Compute the speedup for a fixed size for a variety of threads.
      • Select a resonabley large sized array
      • Run with 1,2, 4, 8, ... threads and record the time.
      • Graph the results.
      • On Euler, I got
        • 
        • 
        • 
        • 
  My final version is finalProduct.cpp