Changes between Version 50 and Version 51 of OpenMPTransformation

Timestamp:

08/12/14 17:31:31 (12 years ago)

Author:

zmanchun

Comment:

--

OpenMPTransformation

@@ -158 +158 @@
 of the system function dealing with shared objects.
 
-For each shared variable `v` introduce a second variable `v_state`.  The type of `v_state` is obtained from the type of `v` by replacing all primitive types (leaf nodes in the type tree) by `int`.  Initially all these ints are -1.  Both variables are declared in the same, shared, scope.
-
-In addition to the shared variable v, each thread has its own local copy named `_v`, declared in thread private scope.   It has the same type as `v`.
+For each shared variable `v`, a thread has a local copy of '_v' and a local status variable`v_state` (both are implemented as part of $omp_shared). `_v` has the same type as `v`. The type of `v_state` is obtained from the type of `v` by replacing all primitive types (leaf nodes in the type tree) by `int`.  Initially all these ints are -1.  Both variables are declared in thread private scope.
+
+For example, given a shared variable `a`, there will be:
+
+  shared copy of variable:
+    `double a[N]; // declared in shared scope`
+
+  local copy of variable:
+    `double a_local[N]; // declared in thread-local scope`
+
+  local status variable:
+    `int a_status[N]; // declared in thread-local scope`
+
+interepration of status value:
+  '0=EMPTY': local is empty
+  '1=FULL': local is occupied, no writes to it have been made
+  '2=MODIFIED': local is occupied, writes have been made to it
+
+Initially: `local=shared`, `status=FULL`
 
 Protocols for reads, writes, and flushes:
 
+A read from (some part of) the shared variable by thread tid:
+* if the status value is `EMPTY`, copy the shared data into the local copy;
+* read and return the data held by the local copy.
+  {{{
+  read (ptr into a_local[i]):
+    if (status is EMPTY) {
+      copy a[1] to a_local[i];
+      set a_status[i] to FULL;
+    }
+    read a_local[i];
+  }}}
+
 A write to (some part of) the shared variable by thread tid:
-* if the state value is -1, do the write to the local copy and set the state value to tid.  Now thread tid is the "owner" of that memory unit.
-* if the state value is tid, do the write to the local copy.
-* else report a memory model error: you are attempting to write to a variable when some other thread has un-flushed writes to the same variable.  The other thread should flush, then you should flush, before doing this write.
-
-A read from (some part of) the shared variable by thread tid:
-* if the state value is -1, read your local copy and compare it to the global copy.  If they differ, report a memory model error: some other thread has modified the variable and flushed, but you did not flush before performing the read. (If you had flushed, your local copy and the shared copy would be equal.)
-* if the state value is tid, read your local copy.
-* else report a memory model error: you are reading from a variable when another thread has un-flushed writes to that variable.  The other thread should flush, and then you should flush, before doing this read.
+* write the data to the local copy;
+* update the status to `MODIFIED`.
+  {{{
+  write (ptr into a_local[i]):
+    write to a_local[i];
+    set a_status[i] to MODIFIED;  
+  }}}
 
 Translating `flush`of (some part of) the shared variable by thread tid:
-* if the state value is -1: copy the global value to your local copy of the variable.
-* if the state value is tid: copy your local value to the global copy of the variable and set the state value to -1.
-* else: report a memory model error, since you are doing a flush when some other thread has un-flushed writes to the variable.  The other thread should flush first.
+* if the status value is `EMPTY`: no op;
+* if the status value is `FULL`: updates the status to `EMPTY`, sets local copy to default value;
+* if the status value is `MODIFIED`: copies the local copy to the shared copy, updates the status to `EMPTY`, sets local copy to default value.
+  {{{
+  flush (some set of memory units):
+    for each memory unit specified:
+      switch (status) {
+        case EMPTY: 
+          break; // nothing to do
+        case MODIFIED:
+          copy local to shared;
+        case FULL: 
+          set status to EMPTY; 
+          set local to default value; 
+          break;
+      }
+  }}}
 
 The function `$omp_barrier_and_flush` performs a barrier on the team and a flush on all shared variables.  After this completes, all local copies will agree with each other and with the shared copy of the variable, and all state variables will be -1.
+  {{{
+  barrier_and_flush(): // collective operation on all shared objects
+    barrier();
+    for each shared memory unit:
+      assert there is at most one thread for which this memory unit
+        has status MODIFIED;
+      flush(memory unit);
+    barrier();
+  }}}
 
 == Worksharing model ==