Changes between Version 24 and Version 25 of OpenMPTransformation

Timestamp:

04/24/14 11:54:39 (12 years ago)

Author:

siegel

Comment:

--

OpenMPTransformation

@@ -26 +26 @@
 * `default(none`|`shared)`
 * `num_threads(`n`)`
+* `collapse(n)`
 * `schedule(static, n)`
 * `schedule(dynamic, n)`
@@ -73 +74 @@
 does a barrier on `_barrier` and a flush on all shared variables.
 
+PROBLEM: the above does not seem to guarantee that both the writing and reading thread do flushes.  According to the Standard, events should follow this order: thread 1 writes , thread 1 flushed, thread 2 flushes, thread 2 reads.     The protocol above doesn't require the thread 2 flush.
+
 
 == Modeling worksharing state ==
@@ -79 +82 @@
 * `$omp_gws`:  global work-sharing state
 * `$omp_ws`: local state.  A reference to a global object and a thread ID.
+
+The following object is used to specify the sequence of iterations to be assigned to one thread executing an omp for loop:
+{{{
+typedef struct {
+  int numIters;
+  int collapse;
+  int iters[][]; 
+} CIVL_omp_loop_info;
+}}}
+
+The dimensions are `iters[numIters][collapse]`.  The integer `iters[i][j]` is the value of the j-th loop variable in the i-th iteration performed by this thread.
+
+The following object is used to specify the subset of section assigned to one thread executing an omp sections construct:
+{{{
+typedef struct {
+  int numSections;
+  int sections[];
+} CIVL_omp_sections_info;
+}}} 
+The length of the array `sections` is `numSections`.  The integer `sections[i]` is the index of the i-th section that this thread will execute.
 
 API:
@@ -104 +127 @@
  * Parameter start is the initial value of the loop variable;
  * end is its final value; and inc is the increment (which can be
- * positive or negative). */
-$int_iter $omp_ws_arrive_loop($omp_ws ws, int location, int start, int end, int inc);
+ * positive or negative).   These values can all be obtained by getting
+ * the loop statement from the location and evaluating the expressions
+ * occurring there.*/
+CIVL_omp_loop_info $omp_ws_arrive_loop($omp_ws ws, int location);
 
 /* for sections: called at arrival, returns the sequence of sections to
  * be executed by calling thread.  The sections are numbered in order,
  * starting from 0. */
-$int_iter $omp_ws_arrive_sections($omp_ws ws, int location);
+CIVL_omp_sections_info $omp_ws_arrive_sections($omp_ws ws, int location);
 
 /* for single: called on arrival, returns whether or not to execute
@@ -188 +213 @@
 {{{
 {
-  $int_iter iter = $omp_ws_arrive_loop(_ws, 23, 0, n-1, 1);
-
-  while ($int_iter_hasNext(iter)) {
-    int i = $int_iter_next(iter);
+  CIVL_omp_loop_info info = $omp_ws_arrive_loop(_ws, 23);
+
+  int numIters = info.numIters;
+  for (int j=0; j<numIters; j++) {
+    int i = info.iters[j][0];
 
     translate(S);
@@ -200 +226 @@
 
 We vary the way the way iterators are chosen to explore different tradeoffs and strategies.  On one extreme, every kind of partition can be explored; on the other, some fixed strategy like round-robin with chunksize 1 can be used.  This only changes the definition of `$omp_ws_arrive_loop`, not the translation above.
+
+{{{
+// location 78:
+#pragma omp parallel for collapse(3)
+for (i=0; i<n; i++)
+  for (j=0; j<m; j++)
+    for (k=0; k<l; k++) {
+      S
+    }
+}}}
+
+=>
+
+{{{
+{
+  CIVL_omp_loop_info info = $omp_ws_arrive_loop(_ws, 78);
+
+  int numIters = info.numIters;
+  for (int count=0; count<numIters; count++) {
+    int i = info.iters[count][0];
+    int j = info.iters[count][1];
+    int k = info.iters[count][2];
+
+    translate(S);
+  }
+  barrier_and_flush();
+}
+}}}
+
 
 === Translating `sections` ===