The OpenMP Programming Model

• We initiate the OpenMP programming model with the aid of a simple program. OpenMP directives in C and C++ are based on the #pragma compiler directives. The directive itself consists of a directive name followed by clauses.

  1   #pragma omp directive [clause list]
  

• OpenMP programs execute serially until they encounter the parallel directive. This directive is responsible for creating a group of threads.
• The exact number of threads can be specified in the directive, set using an environment variable, or at runtime using OpenMP functions.
• The main thread that encounters the parallel directive becomes the master of this group of threads and is assigned the thread id 0 within the group. The parallel directive has the following prototype:

  1   #pragma omp parallel [clause list] 
  2   /* structured block */ 
  3
  

• Each thread created by this directive executes the structured block specified by the parallel directive.
• The clause list is used to specify conditional parallelization, number of threads, and data handling.
  • Conditional Parallelization: The clause if (scalar expression) determines whether the parallel construct results in creation of threads. Only one if clause can be used with a parallel directive.
  • Degree of Concurrency: The clause num_threads (integer expression) specifies the number of threads that are created by the parallel directive.
  • Data Handling: The clause private (variable list) indicates that the set of variables specified is local to each thread - i.e., each thread has its own copy of each variable in the list. The clause firstprivate (variable list) is similar to the private clause, except the values of variables on entering the threads are initialized to corresponding values before the parallel directive. The clause shared (variable list) indicates that all variables in the list are shared across all the threads, i.e., there is only one copy. Special care must be taken while handling these variables by threads to ensure serializability.

Figure 5.1: A sample OpenMP program along with its Pthreads translation that might be performed by an OpenMP compiler.

• It is easy to understand the concurrency model of OpenMP when viewed in the context of the corresponding Pthreads translation. In Figure 5.1, one possible translation of an OpenMP program to a Pthreads program is shown (such a translation can easily be automated through a Yacc or CUP script).

  #include <omp.h>
  main ()  {
  int var1, var2, var3;
  Serial code 
        .
        .
  Beginning of parallel section. Fork a team of threads.
  Specify variable scoping 
  #pragma omp parallel private(var1, var2) shared(var3)
    {
    Parallel section executed by all threads 
          .
          .
    All threads join master thread and disband 
    }  
  Resume serial code 
        .
        .
  }
  ************
  #include <omp.h>
  int a,b,num_threads;
  int main()
  {
    printf("I am in sequential part.\n");
  #pragma omp parallel num_threads (8) private (a) shared (b)
    {
      num_threads=omp_get_num_threads();
      printf("I am openMP parellized part and thread %d \n",omp_get_thread_num());
    }
  }
  

  Using the parallel directive

  1   #pragma omp parallel if (is_parallel == 1) num_threads(8) \ 
  2                        private (a) shared (b) firstprivate(c) 
  3   { 
  4       /* structured block */ 
  5   }
  

  Here, if the value of the variable is_parallel equals one, eight threads are created. Each of these threads gets private copies of variables a and c, and shares a single value of variable b. Furthermore, the value of each copy of c is initialized to the value of c before the parallel directive.
• The default state of a variable is specified by the clause default (shared) or default (none).
  • The clause default (shared) implies that, by default, a variable is shared by all the threads.
  • The clause default (none) implies that the state of each variable used in a thread must be explicitly specified. This is generally recommended, to guard against errors arising from unintentional concurrent access to shared data.
• Just as firstprivate specifies how multiple local copies of a variable are initialized inside a thread, the reduction clause specifies how multiple local copies of a variable at different threads are combined into a single copy at the master when threads exit.
  • The usage of the reduction clause is reduction (operator: variable list).
  • This clause performs a reduction on the scalar variables specified in the list using the operator. The variables in the list are implicitly specified as being private to threads. The operator can be one of

    +, *, -, &, |, ^, &&, and ||.
    

  Using the reduction clause

  1       #pragma omp parallel reduction(+: sum) num_threads(8) 
  2       { 
  3           /* compute local sums here */ 
  4       } 
  5       /* sum here contains sum of all local instances of sums */
  

  In this example, each of the eight threads gets a copy of the variable sum. When the threads exit, the sum of all of these local copies is stored in the single copy of the variable (at the master thread).
• Computing PI using OpenMP directives (presented a Pthreads program for the same problem). The omp_get_num_threads() function returns the number of threads in the parallel region and the omp_get_thread_num() function returns the integer i.d. of each thread (recall that the master thread has an i.d. 0).
• The parallel directive specifies that all variables except npoints, the total number of random points in two dimensions across all threads, are local.
• Furthermore, the directive specifies that there are eight threads, and the value of sum after all threads complete execution is the sum of local values at each thread.
• The function omp_get_num_threads is used to determine the total number of threads. A for loop generates the required number of random points (in two dimensions) and determines how many of them are within the prescribed circle of unit diameter.

  1   /* ****************************************************** 
  2      An OpenMP version of a threaded program to compute PI. 
  3      ****************************************************** */ 
  4 
  5       #pragma omp parallel default(private) shared (npoints) \ 
  6                            reduction(+: sum) num_threads(8) 
  7       { 
  8         num_threads = omp_get_num_threads(); 
  9         sample_points_per_thread = npoints / num_threads; 
  10        sum = 0; 
  11        for (i = 0; i < sample_points_per_thread; i++) { 
  12          rand_no_x =(double)(rand_r(&seed))/(double)((2<<14)-1); 
  13          rand_no_y =(double)(rand_r(&seed))/(double)((2<<14)-1); 
  14          if (((rand_no_x - 0.5) * (rand_no_x - 0.5) + 
  15              (rand_no_y - 0.5) * (rand_no_y - 0.5)) < 0.25) 
  16              sum ++; 
  17        } 
  18      }
  

  Note that this program is much easier to write in terms of specifying creation and termination of threads compared to the corresponding POSIX threaded program.