Changes between Version 56 and Version 57 of IR

Timestamp:

11/25/15 11:29:13 (10 years ago)

Author:

zmanchun

Comment:

--

IR

@@ -159 +159 @@
   * **what particular notations for floating values?**
  * 'a', 'b', ... **UNICODE?**
- * `\cast(Array[T], {e0, e1, ...})` : values of type `Array[T]` **THIS IS NOT A CAST.  Need better notation **
- * `\cast(S, {e0, ...})` : values of type `S` (struct literal) **THIS IS NOT A CAST.  Need better notation **
+ * `\array(T, (e0, e1, e2, ...))`: values of type `Array[T]`; and `\array(T, n, e)`: an array of type `T` with `n` elements each of which being `e`
+ * `\tuple(S, (e0, e1, ...))` : values of type `S` (struct literal)
  * `e1..e2`, `e1..e2#e3` : values of type `\Range`
- * `\cast(Domain, {r1,...,rn})` : value of type `Domain[n]` **NOT A CAST**
+ * `\domain(r1,...,rn)` : value of type `Domain[n]`
  * `"abc"` : string literals: value of type `Array[Char]`
  * `\root`, `\here` : values of type `Scope`
@@ -169 +169 @@
 * variables
 * `\sizeof_type(t)` : the size of the dynamic type t
-* `\sizeof(e)` : the size of the value of expression `e` **Should this be \sizeof_expr since the other one is \sizeof_type ?**
+* `\sizeof_expr(e)` : the size of the value of expression `e`
 * `\new(t)` : new (default) value of specified dynamic type
 * `\defined(e)` : is `e` defined? Type is `Bool`
@@ -183 +183 @@
 * `\mod(e1, e2)` : modulus
 * `\array_subscript(e1, e2)` : array subscript expression.  Note that `e1` must have array type, not pointer type. (This is different from C.)   If `e1` has pointer type, use `\deref(\padd(e1, e2))` instead.  
- * **maybe shorten to `\sub`?**
+ * **maybe shorten to `\sub`? --do you mean `\array_sub` instead?**
 * `\deref(e)` : pointer dereference
-* `\address_of(e)` : address-of. **Or: \addressof ?   After all, we have \sizeof.**
+* `\addressof(e)` : address-of.
 * `\not(e)` : logical not
 * `\neg(e)` : negative
@@ -213 +213 @@
 
 * Assign:  `e1:=e2;`
-* Call: `\call e0, (e1,...,en);` and `\call e, e0, (e1,...,en);`
+* Call: `\call f, (e1,...,en);` and `\call e, f, (e1,...,en);`
  * regular function (one with flow graph)
  * ** distinguish this kind of call from an expression involving a pure system or abstract call???**
-* Spawn: `\spawn e0, (e1,...,en);` and `\spawn e, e0, (e1,...,en);`
+* Spawn: `\spawn f, (e1,...,en);` and `\spawn e, f, (e1,...,en);`
 * Wait: `\wait e;`
-* Wailtall: `\waitall e` where `e` is an array of process references (`Proc`) to be waited for;
+* Wailtall: `\waitall e, n` where `e` is a pointer to a process reference and `n` is the number of processes to be waited for 
 * Allocation
  * `\allocate e, h, t, e0;`, where 
-  * `h` as type `Heap`
+  * `e` has type `Pointer`
+  * `h` has type `Heap`
   * `t` has type `Dytype`
   * `e0` has integer type.
  * Allocates `e0` objects of type `t` on heap `h`
- * To translate the C `malloc` you first need to figure out the type of the elements being malloced.  If the argument to malloc is `n`, then you first need to insert an assertion `\eq(\mod(n, \sizeof_type(t)), 0)`, and then `\allocate(h,t,\div(n, \sizeof_t(t)))`.
+ * To translate the C `malloc` you first need to figure out the type of the elements being malloced.  If the argument to malloc is `n`, then you first need to insert an assertion `\eq(\mod(n, \sizeof_type(t)), 0)`, and then `\allocate e, h, t, \div(n, \sizeof_type(t))`.
 * Free: `\free p;`
 * Expression statement: `e;`, where `e` is side effect free except that it might contain error/exception (e.g., array index out of bound, division by zero);
@@ -233 +234 @@
 * Atomic_enter: `\atomic_enter;`
 * Atomic_exit: `\atomic_exit;`
-* Parfor_spawn: `\parspawn(int i,j,..: dom) f(i,j,...);`
-* Domain iterator: `\next(dom,i,j,…)` updates `i`, `j`, ... to be the value of the inter tuple in `dom` after `(i, j, ...)`
-* For_dom_enter (for domains): `\for_enter(i,j,k..: dom);`
+* Parfor_spawn: `\parspawn p, d, f;` where `p` is pointer to process reference, `d` has `Domain` type and `f` has `Function` type.
+* Domain iterator: `\next dom, (i,j,…)` updates `i`, `j`, ... to be the value of the inter tuple in `dom` after `(i, j, ...)`
+* For_dom_enter (for domains): `\for_enter dom;`
 
 == Declarations and Function Definitions ==
@@ -319 +320 @@
   \reads {\deref(buf)}
 {
-  if(\eq(cmd, SEND)){
-     send(\deref(buf), ...);
-  }else if(\eq(cmd, RECV)){
-    \deref(buf):=recv(...);
-  }
+L0:
+  when (\eq(cmd, SEND))
+     send(\deref(buf), ...); goto L1;
+  when (\eq(cmd, RECV))
+    \deref(buf):=recv(...); goto L1;
+  when (\and(\neq(cmd, SEND), \neq(cmd, RECV)))
+    ; goto L1;
+L1:
 }
 }}}