== 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 an atomic construct without `seq_cst` 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.

== Related ==
* [[wiki: StaticAnalysis| Static Analysis]]