OpenMP Constructs

• parallel
  • private(list)
  • firstprivate(list)
  • copyin(list)
  • shared(list)
  • default(none|shared)
  • num_threads(n)
  • reduction(op:list)

• sections
  • private(list)
  • firstprivate(list)
  • lastprivate(list)
  • reduction(op:list)
  • nowait

• section

• single
  • private(list)
  • firstprivate(list)
  • copyprivate(list)
  • nowait

• for
  • private(list)
  • firstprivate(list)
  • lastprivate(list)
  • reduction
  • schedule
  • collapse
  • nowait

• simd
  • safelen(n)
  • linear(n)
  • aligned(n)
  • private
  • lastprivate
  • reduction
  • collaplse

• for simd
  • safelen(n)
  • linear(n)
  • aligned(n)
  • private
  • lastprivate
  • reduction
  • collapse
  • firstprivate
  • nowait
  • schedule

• declare simd
  • simdlen(n)
  • linear
  • aligned(n)
  • uniform
  • inbranch
  • notinbranch

• barrier

• critical
  • [name]

• atomic
  • read | write | update | capture
  • seq_cst

• master

OpenMP Types

• omp_lock_t

OpenMP Functions

• omp_get_num_threads()
• omp_get_thread_num()
• omp_get_wtime()

OpenMP Functions

• omp_init_lock
• omp_destroy_lock
• omp_set_lock
• omp_unset_lock
• omp_test_lock

Plan

• We are going to get rid of the current OMP2CIVL transformer and come up a new transformer that assumes given OpenMP programs are sequentially consistent
• We are gong to improve the current OmpSimplifier using pointer alias analysis
• Note that a flush without a list is outside of the sequentially consistent subset of the language, we need a way to deal with that.

Notes

• Currently, the simplifier is not aware of the cases that out-of-bound access on multiple dimensional arrays can raise data race. For example,

  int a[10][5];
  #pragma omp parallel for 
  for (int i = 0; i < 5; i++)
    for (int j = 1; j < 10; j++)
      a[i][j] = a[i][j-1] // a[0][4] and a[1][-1] refer to the same element
  

The current simplifier will incorrectly sequentialize the example above without realizing the fact that this example is sequentializable if and only if no "logical" out-of-bound happens during the execution. A fix for the simplifier could be sequentializing the example with inserted assertion for making sure that there is no "logical" out-of-bound error.