Changes between Version 122 and Version 123 of IR

Timestamp:

12/09/15 21:40:17 (10 years ago)

Author:

siegel

Comment:

--

IR

@@ -246 +246 @@
 * `tuple(S,<e0,e1,...>)` : value of tuple type `S` (tuple literal)
 * `tsel(e1,i)` : tuple selection of component i of e1.  i must be a literal natural number.
+
 Unions
-
 * `union_inj(U,i,x)` : `x` is in `Ti`, result is in the union type `U`
 * `union_sel(U,i,y)` : `y` is in `U`, result is in `Ti` (or exception if `y` is not in image of injection from `Ti`)
@@ -330 +330 @@
 * `ATOMIC_ENTER;`
 * `ATOMIC_EXIT;`
-* `PARSPAWN p, d, f;` : spawn a sequence of procs
+* `PARSPAWN p, d, f;` : spawn a sequence of procs, one for each element in a domain
  * `p` has type `Pointer[Proc]`,  `d` has `Domain` type and `f` has `Function` type.
-
-The CIVL-C code `$parfor(int i,j: dom) S;` is translated into the following:
-{{{
-  var p:Array[Proc];
-
-  fun f(i: Integer, j: Integer)
-  {
-    S;
-  }
-
-  PARSPAWN addr(asub(p,0)), dom, f;
-  WAITALL addr(asub(p,0)), domsize(dom);
-}}}
-
+ * the new procs are entered into `p[0]`, `p[1]`, ..., `p[d-1]`, where `d` is the size of the domain.  Hence `p` must point into an array of `Proc` big enough to hold `d` elements.
+ * the function `f` must have the following signature: it consumes `n` `Integer`s, where `n` is the dimension of the `Domain` `d`.  It returns nothing.
 * `NEXT <i,j,...>, dom, flag;` : move to next element in domain
  * `i`,`j`,... have integral types
@@ -354 +342 @@
  * `flag`=`false` in post-state indicates there is no next element
  * `flag`=`true` in post-state indicates the next element is in `<i,j,...>`
+
+Notes on translation:
+
+The CIVL-C code `$parfor(int i,j: dom) S;` is translated into the following:
+{{{
+  var p:Array[Proc];
+
+  fun f(i: Integer, j: Integer)
+  {
+    S;
+  }
+
+  PARSPAWN addr(asub(p,0)), dom, f;
+  WAITALL addr(asub(p,0)), domsize(dom);
+}}}
 
 The CIVL-C code `$for(int i,j: dom) S;` is translated into the following:
@@ -412 +415 @@
 }}}
 
-Function modifiers that may be placed in the brackets after fun:
+Function modifiers that may be placed in the brackets after `fun`:
 * `pure` : the function has no side effects, but may be nondeterministic
-* `abstract`: function is a pure, mathematical function: deterministic function of inputs
-* `atomic`: function definition is atomic, and it never blocks
- * **ISN'T THIS TRUE OF EVERY SYSTEM FUNCTION?  IN WHICH CASE, IS THIS ONLY FOR NON-SYSTEM FUNCTIONS?**
+ * **DO WE NEED TWO SEPARATE MODIFIERS?  One that says no side-effects, one that says deterministic?  For example, `choose_int` has no side-effects, but is not deterministic.  And a non-deterministic function can NOT be used as an expression.
+* `abstract`: an uninterpreted function.  The result of a function call on such a function is a symbolic expression "`f(arg1, ...)`".
+* `atomic`: function definition is atomic, and it never blocks.  A function call to such a function occurs in a single atomic transition.  It is slightly different than a function in which the entire body is atomic, because in the latter case the call and return happen as two separate transitions.
+ * Since every system function is atomic, this option is only useful for non-system functions.
 * `package="..."`: the package where a system function is implemented
 * `lib="..."`: function is a system function defined in specified library