Changes between Version 10 and Version 11 of OpenMPTransformation

Timestamp:

04/20/14 18:14:33 (12 years ago)

Author:

siegel

Comment:

--

OpenMPTransformation

@@ -118 +118 @@
     int _nthreads = 1+$choose_int(THREAD_MAX);
     $proc _threads[_nthreads];
+    $omp_gws _gws = $omp_gws_create($here, _nthreads);
     void _thread(int _tid) {
+      $omp_ws = $omp_ws_create(_gws, _tid);
+
       translate(S)
     }
@@ -134 +137 @@
 
 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!  Also, a thread does not have to execute its iterations in increasing order.  It can execute them in any order.
-
-Trying a few different things for now: picking a particular scheduling policy like round-robin (status with chunk size 1).  Of course you can always do this if schedule is specified to be static.
-
-The question is do we ever want to try to explore these interleavings?
-
-Is there any loss of generality  by just running all iterations concurrently?
-
-One approach: assume you have a function or macro `CIVL_owns(n, t, i)`.  It takes three ints and returns a boolean.  The arguments are `n`: the number of threads; `t`: a thread ID between 0 and `n`-1 (inclusive); and `i`, an iteration index.
-
-{{{
+Otherwise:
+
+{{{
+// location 23:
 #pragma omp parallel for
-  for (i...)
+for (i=0; i<n; i++)  
   S
 }}}
@@ -154 +149 @@
 
 {{{
-for (i...) {
-  if (CIVL_owns(_nthreads, _tid, i)) {
-    translate(S)
-  }
-}
-barrier (unless no wait)
-}}}
-
-
-More general way:
-
-{{{
-
-  {
-
-//use distributions
-  }
-
-
+{
+  $int_iter iter = $omp_ws_arrive_loop(_ws, 23, 0, n-1, 1);
+
+  while ($int_iter_hasNext(iter)) {
+    int i = $int_iter_next(iter);
+
+    translate(S);
+  }
+}
 }}}
 
@@ -181 +166 @@
 
 {{{
+// location 42:
 #pragma omp sections
-  {
-  #pragma omp section
-  ...
-  #pragma omp section
-  ...
-  }
-}}}
-
-=>
-
-{{{
-  {
-    void section0() {
-      ...
-    }
-    void section1() {
-      ...
+#pragma omp section
+  S0
+#pragma omp section
+  S1
+...
+}}}
+
+=>
+
+{{{
+{
+  $int_iter iter = $omp_ws_arrive_sections(ws, 42);
+
+  while ($int_iter_hasNext(iter)) {
+    int _i = $int_iter_next(iter);
+
+    switch (_i) {
+    case 0: {
+      translate(S0);
+      break;
+    }
+    case 1: {
+      translate(S1);
+      break;
     }
     ...
-    if (CIVL_owns(_nthreads, _tid, 0)
-      section0();
-    if (CIVL_owns(_nthreads, _tid, 1)
-      section1();
-    ...
-    barrier unless nowait;
-  }
-}}}
+    }
+  }
+}}}
+
 
 === Translating `single` ===
 
-Nondeterministically choose a thread, i.e, `$choose_int(threads)`.   That thread executes the code, the rest skip it.
-The question is, which thread does the choosing?  The first thread to arrive at that construct?
-
-Once again, try to determine if it matters.  If the modifications and reads do not involve any private data, it doesn't matter which thread does it, so make it thread 0.
-
-There is a barrier at the end.
+{{{
+// location 33:
+#pragma omp single
+S
+}}}
+
+=>
+
+{{{
+if ($omp_arrive_single(ws, 33)) {
+  translate(S);
+}
+}}}
 
 
 === Translating `barrier` ===
 
-Provide some system functions for this.   All the threads in the team (threads[i]) register with a barrier object and partake in the barrier.  Can re-use that barrier object for multiple barriers.
+{{{
+// location 58:
+#pragma omp barrier
+}}}
+
+=>
+
+{{{
+$omp_barrier_arrive(ws, 58);
+$barrier...
+}}}
 
 === Translating `critical` ===