Module1 (hjlib-cooperative 0.1.5-SNAPSHOT API)

java.lang.Object
- edu.rice.hj.Module0
- - edu.rice.hj.Module1

Direct Known Subclasses:

Module2, ModuleS
```
public class Module1
extends Module0
```
A facade to all the Habanero-Java operations like async, forallNb, forasync, etc. The calls delegate to the actual HjRuntime instance.

Author:

Shams Imam (shams@rice.edu)

Field Summary
- Fields inherited from class edu.rice.hj.Module0
  runtimeInitialized

Constructor Summary

Constructors
Modifier Constructor and Description

protected Module1()
Private constructor to disallow instance creation.

Constructors
Modifier	Constructor and Description
`protected`	`Module1()` Private constructor to disallow instance creation.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`async(HjSuspendable suspendable)` Creates a new asynchronous task to execute the wrapped statements.
`static <T> void`	`asyncAwait(HjFuture<T> f1, HjFuture<T> f2, HjFuture<T> f3, HjSuspendable suspendable)` Construct to create an asynchronous task which is executed when all the futures are resolved.
`static <T> void`	`asyncAwait(HjFuture<T> f1, HjFuture<T> f2, HjSuspendable suspendable)` Construct to create an asynchronous task which is executed when both the futures are resolved.
`static <T> void`	`asyncAwait(HjFuture<T> f1, HjSuspendable suspendable)` Construct to create an asynchronous task which is executed when the futureNb is resolved.
`static <T> void`	`asyncAwait(List<HjFuture<T>> dependences, HjSuspendable suspendable)` Construct to create an asynchronous task which is executed when all the futureNb are resolved.
`static void`	`forall(HjRegion.HjRegion1D hjRegion, HjSuspendingProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forall(HjRegion.HjRegion2D hjRegion, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forall(HjRegion.HjRegion3D hjRegion, HjSuspendingProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forall(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forall(int s0, int e0, int s1, int e1, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forall(Iterable<T> iterable, HjSuspendingProcedure<T> body)` Construct to represent loop-level parallelism.
`static void`	`forallChunked(HjRegion.HjRegion1D hjRegion, HjSuspendingProcedureInt1D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallChunked(HjRegion.HjRegion2D hjRegion, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallChunked(HjRegion.HjRegion3D hjRegion, HjSuspendingProcedureInt3D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallChunked(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallChunked(int startInc, int endInc, int chunkSize, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallChunked(int s0, int e0, int s1, int e1, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forasync(HjRegion.HjRegion1D hjRegion, HjSuspendingProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forasync(HjRegion.HjRegion2D hjRegion, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forasync(HjRegion.HjRegion3D hjRegion, HjSuspendingProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forasync(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forasync(int s0, int e0, int s1, int e1, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forasync(Iterable<T> iterable, HjSuspendingProcedure<T> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(HjRegion.HjRegion1D hjRegion, HjSuspendingProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(HjRegion.HjRegion2D hjRegion, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(HjRegion.HjRegion3D hjRegion, HjSuspendingProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(int startInc, int endInc, int chunkSize, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forseq(HjRegion.HjRegion1D hjRegion, HjSuspendingProcedureInt1D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseq(HjRegion.HjRegion2D hjRegion, HjSuspendingProcedureInt2D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseq(HjRegion.HjRegion3D hjRegion, HjSuspendingProcedureInt3D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseq(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forseq(int s0, int e0, int s1, int e1, HjSuspendingProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forseq(Iterable<T> iterable, HjSuspendingProcedure<T> body)` Construct to represent loop-level parallelism.
`static <V> HjFuture<V>`	`future(HjSuspendingCallable<V> callable)` Construct to create an asynchronous task that returns a result which will be available in the futureNb.
`static <T,V> HjFuture<V>`	`futureAwait(HjFuture<T> f1, HjFuture<T> f2, HjFuture<T> f3, HjSuspendingCallable<V> callable)` futureAwait.
`static <T,V> HjFuture<V>`	`futureAwait(HjFuture<T> f1, HjFuture<T> f2, HjSuspendingCallable<V> callable)` futureAwait.
`static <T,V> HjFuture<V>`	`futureAwait(HjFuture<T> f1, HjSuspendingCallable<V> callable)` futureAwait.
`static <T,V> HjFuture<V>`	`futureAwait(List<HjFuture<T>> dependences, HjSuspendingCallable<V> callable)` futureAwait.

Methods inherited from class edu.rice.hj.Module0
abstractMetrics, asyncNb, asyncNbAt, asyncNbAwait, asyncNbAwait, asyncNbAwait, asyncNbAwait, asyncNbSeq, asyncNbSeq, asyncPhased, asyncPhased, asyncPhased, computeDefaultChunkSize, doWait, doWork, dumpEventLog, emergencyShutdown, finalizeHabanero, finish, finish, finish, finish, finish, forallNb, forallNb, forallNb, forallNb, forallNb, forallNb, forallNbChunked, forallNbChunked, forallNbChunked, forallNbChunked, forallNbChunked, forallNbChunked, forallPhased, forallPhased, forasync, forasyncChunked, forasyncNb, forasyncNb, forasyncNb, forasyncNb, forasyncNb, forasyncNbChunked, forasyncNbChunked, forasyncNbChunked, forasyncNbChunked, forasyncPhased, forasyncPhased, forasyncPhased, forseqNb, forseqNb, forseqNb, forseqNb, forseqNb, forseqNb, futureNb, futureNbAwait, futureNbAwait, futureNbAwait, futureNbAwait, futureNbSeq, futureNbSeq, group, group, here, initializeHabanero, launchHabaneroApp, launchHabaneroApp, myGroup, myGroup, newDataDrivenFuture, newDataDrivenFuture, newDDF, newDDF, newFinishAccumulator, newPhaser, newPhaser, newPoint, newRectangularRegion1D, newRectangularRegion2D, newRectangularRegion3D, next, numPlaces, numWorkerThreads, place, printBuildInfo, signal, waitAll, waitAny

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Module1
```
protected Module1()
```
    Private constructor to disallow instance creation.
- Method Detail
  - async
```
public static void async(HjSuspendable suspendable)
```
    Creates a new asynchronous task to execute the wrapped statements.
    Usage:
```
   HjSuspendable aSuspendable = () -> { S1; };
   async(aSuspendable);
 
```
    OR
```
   async(() -> S1);
 
```
    OR
```
   async(() -> {S1; S2;...});
 
```
    Spawn a new child task to execute statements S1, S2, ... asynchronously (i.e., before, after, or in parallel) with the remainder of the parent task.
    In general, an HJ program can create an unbounded number of tasks at runtime.
    The HJ runtime system is responsible for scheduling these tasks on a fixed number of processors.
    Parameters:
    
    suspendable - a HjSuspendable object.
    
    See Also:
    
    HjRuntime.asyncSuspAt(edu.rice.hj.api.HjPlace, edu.rice.hj.api.HjSuspendable)
  - future
```
public static <V> HjFuture<V> future(HjSuspendingCallable<V> callable)
```
    Construct to create an asynchronous task that returns a result which will be available in the futureNb. Usage:
```
   HjCallable aCallable = () -> { return S1; };
   HjFuture aFuture = future(aSuspendable);
 
```
    OR
```
   HjFuture aFuture = future(() -> { return S1; });
 
```
    Support for async tasks with return values. aFuture contains a "futureNb handle" to the newly created task and the operation aFuture.get() (also known as a force operation) can be performed to obtain the result of the futureNb task.
    The futureNb task executes statement S1 asynchronously (i.e., before, after, or in parallel) with the remainder of the parent task.
    In general, an HJ program can create an unbounded number of futures at runtime.
    The HJ runtime system is responsible for scheduling these futureNb tasks on a fixed number of processors.
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSusp(edu.rice.hj.api.HjSuspendingCallable)
  - forseq
```
public static <T> void forseq(Iterable<T> iterable,
                              HjSuspendingProcedure<T> body)
                       throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forseqNb(iterableOfT, (k) -> S2(k))
 
```
    are as follows:
```
   for (T k : iterableOfT) {
     S2(k);
   }
  
```
    Parameters:
    
    iterable - a Iterable object.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
  - forall
```
public static <T> void forall(Iterable<T> iterable,
                              HjSuspendingProcedure<T> body)
                       throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forallNb(iterableOfT, (k) -> S2(k))
 
```
    are as follows:
```
 finish(() -> {
   for (T k : iterableOfT) {
     final T kk = k;
     async(() -> {
       S2(kk);
     });
   }
 });
  
```
    Type Parameters:
    
    T - a T object.
    
    Parameters:
    
    iterable - a Iterable object.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(Iterable, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static <T> void forasync(Iterable<T> iterable,
                                HjSuspendingProcedure<T> body)
                         throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   forasync(iterableOfT, (k) -> S2(k))
 
```
    are as follows:
```
   for (T k : iterableOfT) {
     final T kk = k;
     async(() -> {
       S2(kk);
     });
   }
 
```
    Type Parameters:
    
    T - a T object.
    
    Parameters:
    
    iterable - a Iterable object.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
  - forseq
```
public static void forseq(int startInc,
                          int endInc,
                          HjSuspendingProcedure<Integer> body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forseq(startInc, endInc, (k) -> S2(k))
 
```
    are as follows:
```
   for (int k = startInc; k <= endInc; k++) {
     S2(k);
   }
 
```
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forall
```
public static void forall(int startInc,
                          int endInc,
                          HjSuspendingProcedure<Integer> body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forallNb(startInc, endInc, (k) -> S2(k))
 
```
    are as follows:
```
 finish(() -> {
   for (int k = startInc; k <= endInc; k++) {
     final int kk = k;
     async(() -> {
       S2(kk);
     });
   }
 });
 
```
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static void forasync(int startInc,
                            int endInc,
                            HjSuspendingProcedure<Integer> body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   forasync(startInc, endInc, (k) -> S2(k))
 
```
    are as follows:
```
   for (int k = startInc; k <= endInc; k++) {
     final int kk = k;
     async(() -> {
       S2(kk);
     });
   }
 
```
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjSuspendingProcedure object.
  - forallChunked
```
public static void forallChunked(int startInc,
                                 int endInc,
                                 HjSuspendingProcedure<Integer> body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    refer to forall(int, int, edu.rice.hj.api.HjSuspendingProcedure), forallChunked(int, int, int, edu.rice.hj.api.HjSuspendingProcedure), and forasyncChunked(int, int, int, edu.rice.hj.api.HjSuspendingProcedure)
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
  - forallChunked
```
public static void forallChunked(int startInc,
                                 int endInc,
                                 int chunkSize,
                                 HjSuspendingProcedure<Integer> body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    In this variant, the user has control over the chunk size used and hence the number of tasks created for the loop.
    refer to forall(int, int, edu.rice.hj.api.HjSuspendingProcedure) and forasyncChunked(int, int, int, edu.rice.hj.api.HjSuspendingProcedure)
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    chunkSize - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
  - forasyncChunked
```
public static void forasyncChunked(int startInc,
                                   int endInc,
                                   int chunkSize,
                                   HjSuspendingProcedure<Integer> body)
                            throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    In this variant, the user has control over the chunk size used and hence the number of tasks created for the loop.
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    chunkSize - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
  - forasyncChunked
```
public static void forasyncChunked(int startInc,
                                   int endInc,
                                   HjSuspendingProcedure<Integer> body)
                            throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjSuspendingProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncChunked(int, int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forseq
```
public static void forseq(HjRegion.HjRegion1D hjRegion,
                          HjSuspendingProcedureInt1D body)
                   throws SuspendableException
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion1D iterSpace = newRectangularRegion1D(startInc, endInc);
   forseq(iterSpace, (k) -> S2(k))
 
```
    are as follows:
```
   for (int k = startInc; k <= endInc; k++) {
     S2(k);
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
  - forall
```
public static void forall(HjRegion.HjRegion1D hjRegion,
                          HjSuspendingProcedureInt1D body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   final HjRegion1D iterSpace = newRectangularRegion1D(startInc, endInc);
   forallNb(iterSpace, (k) -> S2(k))
 
```
    are as follows:
```
 finish(() -> {
   for (int k = startInc; k <= endInc; k++) {
     final int kk = k;
     async(() -> {
       S2(kk);
     });
   }
 });
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static void forasync(HjRegion.HjRegion1D hjRegion,
                            HjSuspendingProcedureInt1D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   final HjRegion1D iterSpace = newRectangularRegion1D(startInc, endInc);
   forasync(iterSpace, (k) -> S2(k))
 
```
    are as follows:
```
   for (int k = startInc; k <= endInc; k++) {
     final int kk = k;
     async(() -> {
       S2(kk);
     });
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forallChunked
```
public static void forallChunked(HjRegion.HjRegion1D hjRegion,
                                 HjSuspendingProcedureInt1D body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion1D object.
    
    body - a HjSuspendingProcedureInt1D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasyncChunked
```
public static void forasyncChunked(HjRegion.HjRegion1D hjRegion,
                                   HjSuspendingProcedureInt1D body)
                            throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion1D object.
    
    body - a HjSuspendingProcedureInt1D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forseq
```
public static void forseq(int s0,
                          int e0,
                          int s1,
                          int e1,
                          HjSuspendingProcedureInt2D body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forallNb(s0, e0, s1, e1, (i, j) -> S2(i, j))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     for (int j = s1; j <= e1; j++) {
       S2(i, j);
     }
   }
  
```
    Parameters:
    
    body - The body of the loop
    
    s0 - a int.
    
    e0 - a int.
    
    s1 - a int.
    
    e1 - a int.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forseq
```
public static void forseq(HjRegion.HjRegion2D hjRegion,
                          HjSuspendingProcedureInt2D body)
                   throws SuspendableException
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion2D iterSpace = newRectangularRegion2D(s0, e0, s1, e1);
   forseq(iterSpace, (i, j) -> S2(i, j))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     for (int j = s1; j <= e1; j++) {
       S2(i, j);
     }
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
  - forall
```
public static void forall(int s0,
                          int e0,
                          int s1,
                          int e1,
                          HjSuspendingProcedureInt2D body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forallNb(s0, e0, s1, e1, (i, j) -> S2(i, j))
 
```
    are as follows:
```
 finish(() -> {
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       async(() -> {
         S2(ii, jj);
       });
     }
   }
 });
  
```
    Parameters:
    
    body - The body of the loop
    
    s0 - a int.
    
    e0 - a int.
    
    s1 - a int.
    
    e1 - a int.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forall
```
public static void forall(HjRegion.HjRegion2D hjRegion,
                          HjSuspendingProcedureInt2D body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   final HjRegion2D iterSpace = newRectangularRegion2D(s0, e0, s1, e1);
   forallNb(iterSpace, (i, j) -> S2(i, j))
 
```
    are as follows:
```
 finish(() -> {
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       async(() -> {
         S2(ii, jj);
       });
     }
   }
 });
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static void forasync(HjRegion.HjRegion2D hjRegion,
                            HjSuspendingProcedureInt2D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   final HjRegion2D iterSpace = newRectangularRegion2D(s0, e0, s1, e1);
   forasync(iterSpace, (i, j) -> S2(i, j))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       async(() -> {
         S2(ii, jj);
       });
     }
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static void forasync(int s0,
                            int e0,
                            int s1,
                            int e1,
                            HjSuspendingProcedureInt2D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   forasync(s0, e0, s1, e1, (i, j) -> S2(i, j))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       async(() -> {
         S2(ii, jj);
       });
     }
   }
  
```
    Parameters:
    
    body - The body of the loop
    
    s0 - a int.
    
    e0 - a int.
    
    s1 - a int.
    
    e1 - a int.
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forallChunked
```
public static void forallChunked(int s0,
                                 int e0,
                                 int s1,
                                 int e1,
                                 HjSuspendingProcedureInt2D body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    s0 - a int.
    
    e0 - a int.
    
    s1 - a int.
    
    e1 - a int.
    
    body - a HjSuspendingProcedureInt2D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forallChunked
```
public static void forallChunked(HjRegion.HjRegion2D hjRegion,
                                 HjSuspendingProcedureInt2D body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion2D object.
    
    body - a HjSuspendingProcedureInt2D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasyncChunked
```
public static void forasyncChunked(HjRegion.HjRegion2D hjRegion,
                                   HjSuspendingProcedureInt2D body)
                            throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion2D object.
    
    body - a HjSuspendingProcedureInt2D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forseq
```
public static void forseq(HjRegion.HjRegion3D hjRegion,
                          HjSuspendingProcedureInt3D body)
                   throws SuspendableException
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion3D iterSpace = newRectangularRegion3D(s0, e0, s1, e1, s2, e2);
   forseq(iterSpace, (i, j, k) -> S2(i, j, k))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     for (int j = s1; j <= e1; j++) {
       for (int k = s2; k <= e2; k++) {
         S2(i, j, k);
       }
     }
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
  - forall
```
public static void forall(HjRegion.HjRegion3D hjRegion,
                          HjSuspendingProcedureInt3D body)
                   throws SuspendableException
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   final HjRegion3D iterSpace = newRectangularRegion3D(s0, e0, s1, e1, s2, e2);
   forallNb(iterSpace, (i, j, k) -> S2(i, j, k))
 
```
    are as follows:
```
 finish(() -> {
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       for (int k = s2; k <= e2; k++) {
         final int kk = k;
         async(() -> {
           S2(ii, jj, kk);
         });
       }
     }
   }
 });
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasync
```
public static void forasync(HjRegion.HjRegion3D hjRegion,
                            HjSuspendingProcedureInt3D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The semantics of
```
   final HjRegion3D iterSpace = newRectangularRegion3D(s0, e0, s1, e1, s2, e2);
   forasync(iterSpace, (i, j, k) -> S2(i, j, k))
 
```
    are as follows:
```
   for (int i = s0; i <= e0; i++) {
     final int ii = i;
     for (int j = s1; j <= e1; j++) {
       final int jj = j;
       for (int k = s2; k <= e2; k++) {
         final int kk = k;
         async(() -> {
           S2(ii, jj, kk);
         });
       }
     }
   }
  
```
    Parameters:
    
    hjRegion - The region to loop over
    
    body - The body of the loop
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forallChunked
```
public static void forallChunked(HjRegion.HjRegion3D hjRegion,
                                 HjSuspendingProcedureInt3D body)
                          throws SuspendableException
```
    Construct to represent loop-level parallelism using chunking/grouping. An implicit finish is included for all iterations of the forallNb.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion3D object.
    
    body - a HjSuspendingProcedureInt3D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - forasyncChunked
```
public static void forasyncChunked(HjRegion.HjRegion3D hjRegion,
                                   HjSuspendingProcedureInt3D body)
                            throws SuspendableException
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasync.
    The HJ runtime ensures that it does not create more tasks than the number of available worker threads for the loop.
    
    Parameters:
    
    hjRegion - a HjRegion.HjRegion3D object.
    
    body - a HjSuspendingProcedureInt3D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasync(int, int, edu.rice.hj.api.HjSuspendingProcedure)
  - asyncAwait
```
public static <T> void asyncAwait(HjFuture<T> f1,
                                  HjSuspendable suspendable)
```
    Construct to create an asynchronous task which is executed when the futureNb is resolved.
    
    Parameters:
    
    f1 - The futureNb (or DDF) on which to register the callback
    
    suspendable - The callback to execute asynchronously when the futureNb (or DDF) is resolved
    
    See Also:
    
    HjRuntime.asyncSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncAwait
```
public static <T> void asyncAwait(List<HjFuture<T>> dependences,
                                  HjSuspendable suspendable)
```
    Construct to create an asynchronous task which is executed when all the futureNb are resolved.
    
    Parameters:
    
    dependences - a List object.
    
    suspendable - a HjSuspendable object.
    
    See Also:
    
    HjRuntime.asyncSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncAwait
```
public static <T> void asyncAwait(HjFuture<T> f1,
                                  HjFuture<T> f2,
                                  HjSuspendable suspendable)
```
    Construct to create an asynchronous task which is executed when both the futures are resolved.
    
    Parameters:
    
    f1 - The futureNb (or DDF) on which to register the callback
    
    f2 - The futureNb (or DDF) on which to register the callback
    
    suspendable - The callback to execute asynchronously when the both futures (or DDFs) are resolved
    
    See Also:
    
    HjRuntime.asyncSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncAwait
```
public static <T> void asyncAwait(HjFuture<T> f1,
                                  HjFuture<T> f2,
                                  HjFuture<T> f3,
                                  HjSuspendable suspendable)
```
    Construct to create an asynchronous task which is executed when all the futures are resolved.
    
    Parameters:
    
    f1 - The futureNb (or DDF) on which to register the callback
    
    f2 - The futureNb (or DDF) on which to register the callback
    
    f3 - The futureNb (or DDF) on which to register the callback
    
    suspendable - The callback to execute asynchronously when the all futures (or DDFs) are resolved
    
    See Also:
    
    HjRuntime.asyncSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendable)
  - futureAwait
```
public static <T,V> HjFuture<V> futureAwait(HjFuture<T> f1,
                                            HjSuspendingCallable<V> callable)
```
    futureAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    callable - a HjSuspendingCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendingCallable)
  - futureAwait
```
public static <T,V> HjFuture<V> futureAwait(List<HjFuture<T>> dependences,
                                            HjSuspendingCallable<V> callable)
```
    futureAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    dependences - a List object.
    
    callable - a HjSuspendingCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendingCallable)
  - futureAwait
```
public static <T,V> HjFuture<V> futureAwait(HjFuture<T> f1,
                                            HjFuture<T> f2,
                                            HjSuspendingCallable<V> callable)
```
    futureAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    f2 - a HjFuture object.
    
    callable - a HjSuspendingCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendingCallable)
  - futureAwait
```
public static <T,V> HjFuture<V> futureAwait(HjFuture<T> f1,
                                            HjFuture<T> f2,
                                            HjFuture<T> f3,
                                            HjSuspendingCallable<V> callable)
```
    futureAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    f2 - a HjFuture object.
    
    f3 - a HjFuture object.
    
    callable - a HjSuspendingCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSuspAwait(java.util.List, edu.rice.hj.api.HjSuspendingCallable)

Class Module1

Field Summary

Fields inherited from class edu.rice.hj.Module0

Constructor Summary

Method Summary

Methods inherited from class edu.rice.hj.Module0

Methods inherited from class java.lang.Object

Constructor Detail

Module1

Method Detail

async

future

forseq

forall

forasync

forseq

forall

forasync

forallChunked

forallChunked

forasyncChunked

forasyncChunked

forseq

forall

forasync

forallChunked

forasyncChunked

forseq

forseq

forall

forall

forasync

forasync

forallChunked

forallChunked

forasyncChunked

forseq

forall

forasync

forallChunked

forasyncChunked

asyncAwait

asyncAwait

asyncAwait

asyncAwait

futureAwait

futureAwait

futureAwait

futureAwait