Menu
▾
▴
[X10-commits] SF.net SVN: x10:[7913] trunk
|
From: <vj...@us...> - 2009-03-12 23:13:28
|
Revision: 7913
http://x10.svn.sourceforge.net/x10/?rev=7913&view=rev
Author: vj0
Date: 2009-03-12 23:13:26 +0000 (Thu, 12 Mar 2009)
Log Message:
-----------
Added safe annotations to get/set/apply etc methods on Array and related classes. Fixed tests in examples/Constructs/Async.
Modified Paths:
--------------
trunk/x10.runtime.17/src-x10/x10/array/BaseArray.x10
trunk/x10.runtime.17/src-x10/x10/array/DistArray.x10
trunk/x10.runtime.17/src-x10/x10/array/FastArray.x10
trunk/x10.runtime.17/src-x10/x10/array/LocalArray.x10
trunk/x10.runtime.17/src-x10/x10/array/MatBuilder.x10
trunk/x10.runtime.17/src-x10/x10/array/ValRow.x10
trunk/x10.runtime.17/src-x10/x10/array/VarRow.x10
trunk/x10.runtime.17/src-x10/x10/lang/Array.x10
trunk/x10.tests/examples/Constructs/Async/AsyncTest3.x10
trunk/x10.tests/examples/Constructs/Async/ClockAsyncTest.x10
Modified: trunk/x10.runtime.17/src-x10/x10/array/BaseArray.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/BaseArray.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/BaseArray.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -58,7 +58,13 @@
as Array[T]{rank==1 && rect && zeroBased}; // XXXX
}
+ public static def makeVar1[T](rail: ValRail[T]): Array[T]{rank==1&&rect&&zeroBased} {
+ val r = Region.makeRectangular(0, rail.length-1);
+ return makeVar[T](r, ((p:Point)=>rail(p(0))) as Box[(Point)=>T])
+ as Array[T]{rank==1 && rect && zeroBased}; // XXXX
+ }
+
//
// expose these if performance demands
//
@@ -72,16 +78,16 @@
// high-performance methods are in subclass to facilitate inlining
//
- public final def apply(pt: Point(rank)): T {
+ public final safe def apply(pt: Point(rank)): T {
if (checkPlace) checkPlace(pt);
if (checkBounds) checkBounds(pt);
return raw()(layout().offset(pt));
}
- public final def get(pt: Point(rank)): T = apply(pt);
+ public final safe def get(pt: Point(rank)): T = apply(pt);
// XXXX settable order
- public final def set(v: T, pt: Point(rank)): T {
+ public final safe def set(v: T, pt: Point(rank)): T {
if (checkPlace) checkPlace(pt);
if (checkBounds) checkBounds(pt);
raw()(layout().offset(pt)) = v;
@@ -112,43 +118,43 @@
val place = (pt:Point):RuntimeException =>
new BadPlaceException("point " + pt + " not defined at " + here);
- def checkBounds(pt: Point(rank)) {
+ safe def checkBounds(pt: Point(rank)) {
(region as BaseRegion(rank)).check(bounds, pt);
}
- def checkBounds(i0: int) {
+ safe def checkBounds(i0: int) {
(region as BaseRegion).check(bounds, i0);
}
- def checkBounds(i0: int, i1: int) {
+ safe def checkBounds(i0: int, i1: int) {
(region as BaseRegion).check(bounds, i0, i1);
}
- def checkBounds(i0: int, i1: int, i2: int) {
+ safe def checkBounds(i0: int, i1: int, i2: int) {
(region as BaseRegion).check(bounds, i0, i1, i2);
}
- def checkBounds(i0: int, i1: int, i2: int, i3: int) {
+ safe def checkBounds(i0: int, i1: int, i2: int, i3: int) {
(region as BaseRegion).check(bounds, i0, i1, i2, i3);
}
- def checkPlace(pt: Point(rank)) {
+ safe def checkPlace(pt: Point(rank)) {
(dist.get(here) as BaseRegion(rank)).check(place, pt);
}
- def checkPlace(i0: int) {
+ safe def checkPlace(i0: int) {
(dist.get(here) as BaseRegion).check(place, i0);
}
- def checkPlace(i0: int, i1: int) {
+ safe def checkPlace(i0: int, i1: int) {
(dist.get(here) as BaseRegion).check(place, i0, i1);
}
- def checkPlace(i0: int, i1: int, i2: int) {
+ safe def checkPlace(i0: int, i1: int, i2: int) {
(dist.get(here) as BaseRegion).check(place, i0, i1, i2);
}
- def checkPlace(i0: int, i1: int, i2: int, i3: int) {
+ safe def checkPlace(i0: int, i1: int, i2: int, i3: int) {
(dist.get(here) as BaseRegion).check(place, i0, i1, i2, i3);
}
@@ -158,16 +164,16 @@
// views
//
- public def restriction(r: Region(rank)): Array[T] {
+ public safe def restriction(r: Region(rank)): Array[T] {
return restriction(dist.restriction(r));
}
- public def restriction(p: Place): Array[T] {
+ public safe def restriction(p: Place): Array[T] {
return restriction(dist.restriction(p));
}
// must be internal only - assumes Dist places match
- protected abstract def restriction(d: Dist): Array[T];
+ protected abstract safe def restriction(d: Dist): Array[T];
//
@@ -177,34 +183,34 @@
public def lift(op:(T)=>T): Array[T](dist)
= Array.make[T](dist, (p:Point)=>op(this(p as Point(rank))));
- incomplete public def reduce(op:(T,T)=>T, unit:T):T;
+ // incomplete public def reduce(op:(T,T)=>T, unit:T):T;
//
// seems to be causing non-deterministic typechecking failures in
// a(pt). perhaps related to XTENLANG-128 and/or XTENLANG-135
//
-// public def reduce(op:(T,T)=>T, unit:T):T {
-//
-// // scatter
-// val ps = dist.places();
-// val results = Rail.makeVal[Future[T]](ps.length, (p:nat) => {
-// future (ps(p)) {
-// var result: T = unit;
-// val a = (this | here) as Array[T](rank);
-// for (pt:Point(rank) in a)
-// result = op(result, a(pt));
-// return result;
-// }
-// });
-//
-// // gather
-// var result: T = unit;
-// for (var i:int=0; i<results.length; i++)
-// result = op(result, results(i).force());
-//
-// return result;
-// }
+ public def reduce(op:(T,T)=>T, unit:T):T {
+ // scatter
+ val ps = dist.places();
+ val results = Rail.makeVal[Future[T]](ps.length, (p:nat) => {
+ future(ps(p)) {
+ var result: T = unit;
+ val a = (this | here) as Array[T](rank);
+ for (pt:Point(rank) in a)
+ result = op(result, a(pt));
+ return result;
+ }
+ });
+
+ // gather
+ var result: T = unit;
+ for (var i:int = 0; i < results.length; i++)
+ result = op(result, results(i).force());
+
+ return result;
+ }
+
// LocalArray only for now!
incomplete public def scan(op:(T,T)=>T, unit:T): Array[T](dist);
@@ -213,24 +219,24 @@
// ops
//
- public def $bar(r: Region(rank)): Array[T] = restriction(r);
- public def $bar(p: Place): Array[T] = restriction(p);
+ public safe def $bar(r: Region(rank)): Array[T] = restriction(r);
+ public safe def $bar(p: Place): Array[T] = restriction(p);
- incomplete public def $plus(): Array[T];
- incomplete public def $minus(): Array[T];
+ incomplete public safe def $plus(): Array[T];
+ incomplete public safe def $minus(): Array[T];
- incomplete public def $plus(that: Array[T]): Array[T];
- incomplete public def $minus(that: Array[T]): Array[T];
- incomplete public def $times(that: Array[T]): Array[T];
- incomplete public def $over(that: Array[T]): Array[T];
- incomplete public def $percent(that: Array[T]): Array[T];
+ incomplete public safe def $plus(that: Array[T]): Array[T];
+ incomplete public safe def $minus(that: Array[T]): Array[T];
+ incomplete public safe def $times(that: Array[T]): Array[T];
+ incomplete public safe def $over(that: Array[T]): Array[T];
+ incomplete public safe def $percent(that: Array[T]): Array[T];
- incomplete public def $eq(x: Array[T]): boolean;
- incomplete public def $lt(x: Array[T]): boolean;
- incomplete public def $gt(x: Array[T]): boolean;
- incomplete public def $le(x: Array[T]): boolean;
- incomplete public def $ge(x: Array[T]): boolean;
- incomplete public def $ne(x: Array[T]): boolean;
+ incomplete public safe def $eq(x: Array[T]): boolean;
+ incomplete public safe def $lt(x: Array[T]): boolean;
+ incomplete public safe def $gt(x: Array[T]): boolean;
+ incomplete public safe def $le(x: Array[T]): boolean;
+ incomplete public safe def $ge(x: Array[T]): boolean;
+ incomplete public safe def $ne(x: Array[T]): boolean;
// incomplete public def sum(): T; // XTENLANG-116
Modified: trunk/x10.runtime.17/src-x10/x10/array/DistArray.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/DistArray.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/DistArray.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -31,25 +31,25 @@
// XXX but ref to here and rail accesses make this not so high performance
//
- final public def apply(i0: int): T {
+ final public safe def apply(i0: int): T {
if (checkPlace) checkPlace(i0);
if (checkBounds) checkBounds(i0);
return raw()(layout().offset(i0));
}
- final public def apply(i0: int, i1: int): T {
+ final public safe def apply(i0: int, i1: int): T {
if (checkPlace) checkPlace(i0, i1);
if (checkBounds) checkBounds(i0, i1);
return raw()(layout().offset(i0,i1));
}
- final public def apply(i0: int, i1: int, i2: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int): T {
if (checkPlace) checkPlace(i0, i1, i2);
if (checkBounds) checkBounds(i0, i1, i2);
return raw()(layout().offset(i0,i1,i2));
}
- final public def apply(i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int, i3: int): T {
if (checkPlace) checkPlace(i0, i1, i2, i3);
if (checkBounds) checkBounds(i0, i1, i2, i3);
return raw()(layout().offset(i0,i1,i2,i3));
@@ -61,28 +61,28 @@
// XXX but ref to here and rail accesses make this not so high performance
//
- final public def set(v: T, i0: int): T {
+ final public safe def set(v: T, i0: int): T {
if (checkPlace) checkPlace(i0);
if (checkBounds) checkBounds(i0);
raw()(layout().offset(i0)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int): T {
+ final public safe def set(v: T, i0: int, i1: int): T {
if (checkPlace) checkPlace(i0, i1);
if (checkBounds) checkBounds(i0, i1);
raw()(layout().offset(i0,i1)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int): T {
if (checkPlace) checkPlace(i0, i1, i2);
if (checkBounds) checkBounds(i0, i1, i2);
raw()(layout().offset(i0,i1,i2)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
if (checkPlace) checkPlace(i0, i1, i2, i3);
if (checkBounds) checkBounds(i0, i1, i2, i3);
raw()(layout().offset(i0,i1,i2,i3)) = v;
@@ -123,7 +123,7 @@
* restriction view
*/
- public def restriction(d: Dist) {
+ public safe def restriction(d: Dist) {
if (d.constant)
return new LocalArray[T](this, d as Dist{constant});
else
Modified: trunk/x10.runtime.17/src-x10/x10/array/FastArray.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/FastArray.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/FastArray.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -36,25 +36,25 @@
val delta2: int;
val delta3: int;
- final public def apply(i0: int): T {
+ final public safe def apply(i0: int): T {
var offset:int = i0;
return raw(offset);
}
- final public def apply(i0: int, i1: int): T {
+ final public safe def apply(i0: int, i1: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
return raw(offset);
}
- final public def apply(i0: int, i1: int, i2: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
offset = offset*delta2 + i2;
return raw(offset);
}
- final public def apply(i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int, i3: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
offset = offset*delta2 + i2;
@@ -66,20 +66,20 @@
//
//
- final public def set(v: T, i0: int): T {
+ final public safe def set(v: T, i0: int): T {
var offset:int = i0;
raw(offset) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int): T {
+ final public safe def set(v: T, i0: int, i1: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
raw(offset) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
offset = offset*delta2 + i2;
@@ -87,7 +87,7 @@
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
var offset:int = i0;
offset = offset*delta1 + i1;
offset = offset*delta2 + i2;
@@ -168,7 +168,7 @@
* restriction view
*/
- public def restriction(d: Dist): Array[T] {
+ public safe def restriction(d: Dist): Array[T] {
return new FastArray[T](this, d as Dist{constant});
}
Modified: trunk/x10.runtime.17/src-x10/x10/array/LocalArray.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/LocalArray.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/LocalArray.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -29,22 +29,22 @@
// NB: local array, so don't do place checking
//
- final public def apply(i0: int): T {
+ final public safe def apply(i0: int): T {
if (checkBounds) checkBounds(i0);
return raw(layout.offset(i0));
}
- final public def apply(i0: int, i1: int): T {
+ final public safe def apply(i0: int, i1: int): T {
if (checkBounds) checkBounds(i0, i1);
return raw(layout.offset(i0,i1));
}
- final public def apply(i0: int, i1: int, i2: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int): T {
if (checkBounds) checkBounds(i0, i1, i2);
return raw(layout.offset(i0,i1,i2));
}
- final public def apply(i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def apply(i0: int, i1: int, i2: int, i3: int): T {
if (checkBounds) checkBounds(i0, i1, i2, i3);
return raw(layout.offset(i0,i1,i2,i3));
}
@@ -56,25 +56,25 @@
// NB: local array, so don't do place checking
//
- final public def set(v: T, i0: int): T {
+ final public safe def set(v: T, i0: int): T {
if (checkBounds) checkBounds(i0);
raw(layout.offset(i0)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int): T {
+ final public safe def set(v: T, i0: int, i1: int): T {
if (checkBounds) checkBounds(i0, i1);
raw(layout.offset(i0,i1)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int): T {
if (checkBounds) checkBounds(i0, i1, i2);
raw(layout.offset(i0,i1,i2)) = v;
return v;
}
- final public def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
+ final public safe def set(v: T, i0: int, i1: int, i2: int, i3: int): T {
if (checkBounds) checkBounds(i0, i1, i2, i3);
raw(layout.offset(i0,i1,i2,i3)) = v;
return v;
@@ -148,7 +148,7 @@
* restriction view
*/
- public def restriction(d: Dist): Array[T] {
+ public safe def restriction(d: Dist): Array[T] {
return new LocalArray[T](this, d as Dist{constant});
}
Modified: trunk/x10.runtime.17/src-x10/x10/array/MatBuilder.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/MatBuilder.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/MatBuilder.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -21,43 +21,43 @@
need(rows);
}
- public def add(row:Row) {
+ public safe def add(row:Row) {
mat.add(row);
}
- public def add(a:(nat)=>int) {
+ public safe def add(a:(nat)=>int) {
mat.add(new VarRow(cols, a));
}
- public def set(v:int, i:int, j:int) {
+ public safe def set(v:int, i:int, j:int) {
need(i+1);
mat(i)(j) = v;
}
- public def setDiagonal(i:nat, j:nat, n:nat, v:(nat)=>int) {
+ public safe def setDiagonal(i:nat, j:nat, n:nat, v:(nat)=>int) {
need(i+n);
for (var k:int=0; k<n; k++)
mat(i+k)(j+k) = v(k);
}
- public def setColumn(i:nat, j:nat, n:nat, v:(nat)=>int) {
+ public safe def setColumn(i:nat, j:nat, n:nat, v:(nat)=>int) {
need(i+n);
for (var k:int=0; k<n; k++)
mat(i+k)(j) = v(k);
}
- public def setRow(i:nat, j:nat, n:nat, v:(nat)=>int) {
+ public safe def setRow(i:nat, j:nat, n:nat, v:(nat)=>int) {
need(i+1);
for (var k:int=0; k<n; k++)
mat(i)(j+k) = v(k);
}
- private def need(n:int) {
+ private safe def need(n:int) {
while (mat.size()<n)
mat.add(new VarRow(cols));
}
- public def toXformMat() {
+ public safe def toXformMat() {
return new XformMat(mat.size(), cols, (i:nat,j:nat)=>mat(i)(j));
}
}
Modified: trunk/x10.runtime.17/src-x10/x10/array/ValRow.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/ValRow.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/ValRow.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -25,9 +25,9 @@
row = Rail.makeVal[int](cols, init);
}
- public def apply(i:nat) = row(i);
+ public safe def apply(i:nat) = row(i);
- public def set(v:int, i:nat):int {
+ public safe def set(v:int, i:nat):int {
throw new IllegalOperationException("ValRow.set");
}
}
Modified: trunk/x10.runtime.17/src-x10/x10/array/VarRow.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/array/VarRow.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/array/VarRow.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -17,7 +17,7 @@
row = Rail.makeVar[int](cols);
}
- public def apply(i:nat) = row(i);
+ public safe def apply(i:nat) = row(i);
- public def set(v:int, i:nat) = (row(i) = v);
+ public safe def set(v:int, i:nat) = (row(i) = v);
}
Modified: trunk/x10.runtime.17/src-x10/x10/lang/Array.x10
===================================================================
--- trunk/x10.runtime.17/src-x10/x10/lang/Array.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.runtime.17/src-x10/x10/lang/Array.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -82,6 +82,8 @@
public static def make[T](rail: Rail[T]): Array[T]{rank==1&&rect&&zeroBased}
= BaseArray.makeVar1[T](rail);
+ public static def make[T](rail: ValRail[T]): Array[T]{rank==1&&rect&&zeroBased}
+ = BaseArray.makeVar1[T](rail);
public static def make[T](size: nat, init: Box[(Point)=>T]): Array[T](1)
= makeVar[T](0..size-1, init) as Array[T](1);
@@ -103,31 +105,31 @@
// operations
//
- public abstract def apply(pt: Point(rank)): T;
- public abstract def apply(i0: int) {rank==1}: T;
- public abstract def apply(i0: int, i1: int) {rank==2}: T;
- public abstract def apply(i0: int, i1: int, i2: int) {rank==3}: T;
- public abstract def apply(i0: int, i1: int, i2: int, i3:int) {rank==4}: T;
+ public abstract safe def apply(pt: Point(rank)): T;
+ public abstract safe def apply(i0: int) {rank==1}: T;
+ public abstract safe def apply(i0: int, i1: int) {rank==2}: T;
+ public abstract safe def apply(i0: int, i1: int, i2: int) {rank==3}: T;
+ public abstract safe def apply(i0: int, i1: int, i2: int, i3:int) {rank==4}: T;
- public abstract def set(v:T, pt: Point(rank)): T;
- public abstract def set(v:T, i0: int) {rank==1}: T;
- public abstract def set(v:T, i0: int, i1: int) {rank==2}: T;
- public abstract def set(v:T, i0: int, i1: int, i2: int) {rank==3}: T;
- public abstract def set(v:T, i0: int, i1: int, i2: int, i3:int) {rank==4}: T;
+ public abstract safe def set(v:T, pt: Point(rank)): T;
+ public abstract safe def set(v:T, i0: int) {rank==1}: T;
+ public abstract safe def set(v:T, i0: int, i1: int) {rank==2}: T;
+ public abstract safe def set(v:T, i0: int, i1: int, i2: int) {rank==3}: T;
+ public abstract safe def set(v:T, i0: int, i1: int, i2: int, i3:int) {rank==4}: T;
- public abstract def restriction(r: Region(rank)): Array[T];
- public abstract def restriction(p: Place): Array[T];
+ public abstract safe def restriction(r: Region(rank)): Array[T];
+ public abstract safe def restriction(p: Place): Array[T];
- public abstract def $plus(): Array[T];
- public abstract def $minus(): Array[T];
+ public abstract safe def $plus(): Array[T];
+ public abstract safe def $minus(): Array[T];
- public abstract def $plus(that: Array[T]): Array[T];
- public abstract def $minus(that: Array[T]): Array[T];
- public abstract def $times(that: Array[T]): Array[T];
- public abstract def $over(that: Array[T]): Array[T];
+ public abstract safe def $plus(that: Array[T]): Array[T];
+ public abstract safe def $minus(that: Array[T]): Array[T];
+ public abstract safe def $times(that: Array[T]): Array[T];
+ public abstract safe def $over(that: Array[T]): Array[T];
- public abstract def $bar(r: Region(rank)): Array[T];
- public abstract def $bar(p: Place): Array[T];
+ public abstract safe def $bar(r: Region(rank)): Array[T];
+ public abstract safe def $bar(p: Place): Array[T];
//
@@ -155,9 +157,10 @@
//
//
- incomplete public static def $convert[T](r: Rail[T]): Array[T];
- incomplete public static def $convert[T](r: ValRail[T]): Array[T];
+ public static def $convert[T](r: Rail[T]): Array[T] = make(r);
+ public static def $convert[T](r: ValRail[T]): Array[T] = make(r);
+
public def iterator(): Iterator[Point(rank)] = region.iterator() as Iterator[Point(rank)];
Modified: trunk/x10.tests/examples/Constructs/Async/AsyncTest3.x10
===================================================================
--- trunk/x10.tests/examples/Constructs/Async/AsyncTest3.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.tests/examples/Constructs/Async/AsyncTest3.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -22,40 +22,36 @@
*/
public class AsyncTest3 extends x10Test {
- public def run(): boolean = {
+ public def run() {
+ try {
val A: Array[int] = Array.make[int](Dist.makeUnique());
chk(Place.MAX_PLACES >= 2);
chk(A.dist(0) == here);
chk(A.dist(1) != here);
- val x: X = new X();
+ val x= new X();
finish async(here) { A(0) += 1; }
A(0) += 1;
-
-
-
- finish async(here) { A(1) += 1; }
- A(1) += 1; // remote communication
- x10.io.Console.OUT.println("1");
+ finish async(here) { A(1) += 1; }
+ A(1) += 1; // remote communication
+ x10.io.Console.OUT.println("1");
finish async(here) { A(x.zero()) += 1; }
A(x.zero()) += 1;
+ finish async(here) { A(0) += A(x.one()); }
+ A(0) += A(x.one());// remote communication
+ x10.io.Console.OUT.println("2");
-
- finish async(here) { A(0) += A(x.one()); }
- A(0) += A(x.one());// remote communication
- x10.io.Console.OUT.println("2");
-
-
- chk(A(0) == 8 && A(1) == 2);
- x10.io.Console.OUT.println("3");
-
-
+ chk(A(0) == 8 && A(1) == 2);
+ x10.io.Console.OUT.println("3");
+ return false;
+ } catch (z:BadPlaceException) {
return true;
+ }
}
- public static def main(var args: Rail[String]): void = {
+ public static def main(var args: Rail[String]) {
new AsyncTest3().execute();
}
@@ -65,8 +61,8 @@
*/
static class X {
public var z: Array[int] = [ 1, 0 ];
- def zero(): int = { return z(z(z(1))); }
- def one(): int = { return z(z(z(0))); }
- def modify(): void = { z(0)++; }
+ def zero() = z(z(z(1)));
+ def one() = z(z(z(0)));
+ def modify() { z(0)++; }
}
}
Modified: trunk/x10.tests/examples/Constructs/Async/ClockAsyncTest.x10
===================================================================
--- trunk/x10.tests/examples/Constructs/Async/ClockAsyncTest.x10 2009-03-12 23:09:24 UTC (rev 7912)
+++ trunk/x10.tests/examples/Constructs/Async/ClockAsyncTest.x10 2009-03-12 23:13:26 UTC (rev 7913)
@@ -8,27 +8,28 @@
import harness.x10Test;
/**
- * Code generation for clocked async uses "clocks" as the name of the clock
- * list.
- * This test will fail at runtime, because the wrong clocks variable is being used.
+ * Test that creating an array of clocks will not work -- you need to
+ * do the following instead:
+ val clocks = Array.make[Clock](0..5, (point)=>null);
+ for ((i) in 0..5) clocks(i) = Clock.make();
+
* @author Tong Wen 7/2006
*/
public class ClockAsyncTest extends x10Test {
- public def run(): boolean = {
- finish async{
- val clocks: Array[Clock] = Array.make[Clock]([0..5], ((i): Point): Clock => Clock.make());
- val i: int = 0;
- async (here) clocked (clocks(i)){
- next;
- }
- }
- return true;
+ public def run(): boolean = {
+ try {
+ val clocks = Array.make[Clock](0..5, (Point)=>Clock.make());
+ finish async (here) clocked (clocks(0)){
+ next;
+ }
+ } catch (x:ClockUseException) {
+ return true;
}
+ return false;
+ }
-
-
- public static def main(var args: Rail[String]): void = {
- new ClockAsyncTest().execute();
- }
+ public static def main(var args: Rail[String]) {
+ new ClockAsyncTest().execute();
+ }
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
