== OpenMP Constructs ==

* `parallel`
* worksharing
  * `for`
  * `sections` and `section`
  * `single`
* synchronization
  * `barrier`
  * `critical`
  * `atomic`
  * `ordered`
  * `master`
* `threadprivate`
* `flush`

Clauses
* `private(`list`)`
* `firstprivate(list)`
* `lastprivate(list)`
* `copyin(list)`
* `shared(`list`)`
* `default(none`|`shared)`
* `num_threads(`n`)`
* `schedule(static, n)`
* `schedule(dynamic, n)`
* ...
* `ordered`
* `nowait`

Functions
* `omp_get_num_threads()`
* `omp_get_thread_num()`

== Translation Strategies ==

=== Shared variables ===

=== `parallel` ===

`parallel`: this spawns some nondeterministic number of threads.  Each thread is assigned an ID.  The original ("master") thread has ID 0.  All threads execute the parallel region.

{{{
  #pragma omp parallel ...
  S
}}}

=>

{{{
  {
    int _nthreads = 1+$choose_int(THREAD_MAX);
    $proc _threads[_nthreads];
    void _thread(int _tid) {
      translate(S)
    }

    for (int i=0; i<_nthreads; i++) _threads[i]=$spawn _thread(i);
    for (int i=0; i<_nthreads; i++) $wait(_threads[i]);
  }
}}}

All variables that occur in the parallel construct, i.e., the lexical extent of the parallel construct, must be determined to be either private or shared.   This is determined by the clauses and the default rules as specified in the OpenMP Standard.  Obviously any variable declared within the construct itself must be private.

For all private variables `x` not declared within the parallel construct, create a new variable of the same type, `_x`.    The new variable is declared within the thread scope.  If `x` is also firstprivate,  then `_x` is initialized with the value of `x`, e.g. `int _x=x;`.  Otherwise, `_x` is uninitialized, so has an undefined value.

=== `for` ===

Try to determine whether the loop iterations are independent.  In that case, they can all be executed by one thread.

Otherwise, iterations must be distributed among the threads in some nondeterministic way.  This could blow up rapidly!