Module0 (hjlib-cooperative 0.1.5-SNAPSHOT API)

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

Direct Known Subclasses:

Module1
```
public class Module0
extends Object
```
A facade to all the Habanero-Java operations like finish, async, forallNb, forasyncNb, finish-accumulators, phasers, abstract metrics, etc. The calls delegate to the actual HjRuntime instance.

Author:

Shams Imam (shams@rice.edu)

Field Summary

Fields
Modifier and Type Field and Description

protected static AtomicBoolean runtimeInitialized
Constant runtimeInitialized

Fields
Modifier and Type	Field and Description
`protected static AtomicBoolean`	`runtimeInitialized` Constant `runtimeInitialized`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Module0()
Private constructor to disallow instance creation.

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

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static HjMetrics`	`abstractMetrics()` Returns the metrics report for the currently executing task.
`static void`	`asyncNb(HjRunnable runnable)` Creates a new asynchronous task to execute the wrapped statements.
`static void`	`asyncNbAt(HjPlace place, HjRunnable runnable)`
`static <T> void`	`asyncNbAwait(HjFuture<T> f1, HjFuture<T> f2, HjFuture<T> f3, HjRunnable runnable)` Construct to create an asynchronous task which is executed when all the futures are resolved.
`static <T> void`	`asyncNbAwait(HjFuture<T> f1, HjFuture<T> f2, HjRunnable runnable)` Construct to create an asynchronous task which is executed when both the futures are resolved.
`static <T> void`	`asyncNbAwait(HjFuture<T> f1, HjRunnable runnable)` Construct to create an asynchronous task which is executed when the futureNb is resolved.
`static <T> void`	`asyncNbAwait(List<HjFuture<T>> dependences, HjRunnable runnable)` Construct to create an asynchronous task which is executed when all the futureNb are resolved.
`static void`	`asyncNbSeq(boolean sequentialize, HjRunnable runnable)` Similar to the regular `asyncNb(edu.rice.hj.api.HjRunnable)` except that the boolean condition is used as a tuning parameter to determine if the async should just be executed sequentially (when the condition is true) in the parent task.
`static void`	`asyncNbSeq(boolean sequentialize, HjRunnable seqRunnable, HjRunnable parRunnable)` Similar to the regular `asyncNb(edu.rice.hj.api.HjRunnable)` except that the boolean condition is used as a tuning parameter to determine if the async should just be executed sequentially (when the condition is true) in the parent task.
`static void`	`asyncPhased(HjPhaserPair phaserPair1, HjPhaserPair phaserPair2, HjSuspendable suspendable)` Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
`static void`	`asyncPhased(HjPhaserPair phaserPair, HjSuspendable suspendable)` Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
`static void`	`asyncPhased(List<HjPhaserPair> phaserList, HjSuspendable suspendable)` Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
`protected static int`	`computeDefaultChunkSize(int startInc, int endInc)` Computes the chunk size based on the number of iterations and the number of worker threads.
`static void`	`doWait()` wait on each phaser that task is registered on with a wait capability (WAIT, SIG_WAIT). wait is a potentially blocking operation.
`static void`	`doWork(long n)` Used by abstract performance metrics to report work done by the currently executing task.
`static void`	`dumpEventLog(PrintStream printStream)` Dumps the events tracked by the runtime.
`static void`	`emergencyShutdown(Throwable cause)` Immediately exit the program due to an execution error.
`static void`	`finalizeHabanero()` Cleans up all Habanero-Java state.
`static void`	`finish(HjFinishAccumulator f1, HjFinishAccumulator f2, HjFinishAccumulator f3, HjSuspendable suspendable)` finish.
`static void`	`finish(HjFinishAccumulator f1, HjFinishAccumulator f2, HjSuspendable suspendable)` finish.
`static void`	`finish(HjFinishAccumulator f1, HjSuspendable suspendable)` finish.
`static void`	`finish(HjSuspendable suspendable)` Creates a new finish scope to execute the wrapped statements.
`static void`	`finish(List<HjFinishAccumulator> accumulators, HjSuspendable suspendable)` finish.
`static void`	`forallNb(HjRegion.HjRegion1D hjRegion, HjProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forallNb(HjRegion.HjRegion2D hjRegion, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forallNb(HjRegion.HjRegion3D hjRegion, HjProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forallNb(int startInc, int endInc, HjProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forallNb(int s0, int e0, int s1, int e1, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forallNb(Iterable<T> iterable, HjProcedure<T> body)` Construct to represent loop-level parallelism.
`static void`	`forallNbChunked(HjRegion.HjRegion1D hjRegion, HjProcedureInt1D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallNbChunked(HjRegion.HjRegion2D hjRegion, HjProcedureInt2D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallNbChunked(HjRegion.HjRegion3D hjRegion, HjProcedureInt3D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallNbChunked(int startInc, int endInc, HjProcedure<Integer> body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallNbChunked(int startInc, int endInc, int chunkSize, HjProcedure<Integer> body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallNbChunked(int s0, int e0, int s1, int e1, HjProcedureInt2D body)` Construct to represent loop-level parallelism using chunking/grouping.
`static void`	`forallPhased(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` In forallPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
`static <T> void`	`forallPhased(Iterable<T> iterable, HjSuspendingProcedure<T> body)` In forallPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
`static void`	`forasync(HjRegion.HjRegion1D hjRegion, HjProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncChunked(HjRegion.HjRegion1D hjRegion, HjProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNb(HjRegion.HjRegion2D hjRegion, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNb(HjRegion.HjRegion3D hjRegion, HjProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNb(int startInc, int endInc, HjProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNb(int s0, int e0, int s1, int e1, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forasyncNb(Iterable<T> iterable, HjProcedure<T> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNbChunked(HjRegion.HjRegion2D hjRegion, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNbChunked(HjRegion.HjRegion3D hjRegion, HjProcedureInt3D body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNbChunked(int startInc, int endInc, HjProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncNbChunked(int startInc, int endInc, int chunkSize, HjProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forasyncPhased(int startInc, int endInc, HjSuspendingProcedure<Integer> body)` In forasyncPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
`static void`	`forasyncPhased(int startInc, int endInc, List<HjPhaserPair> phaserList, HjSuspendingProcedure<Integer> body)` In this variant of forasyncPhased, you have phasers registered with the spawned asyncs (there is one async for each iteration of the loop) explicitly.
`static <T> void`	`forasyncPhased(Iterable<T> iterable, List<HjPhaserPair> phaserList, HjSuspendingProcedure<T> body)` In this variant of forasyncPhased, you have phasers registered with the spawned asyncs (there is one async for each iteration of the loop) explicitly.
`static void`	`forseqNb(HjRegion.HjRegion1D hjRegion, HjProcedureInt1D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseqNb(HjRegion.HjRegion2D hjRegion, HjProcedureInt2D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseqNb(HjRegion.HjRegion3D hjRegion, HjProcedureInt3D body)` Construct to represent a sequential loop while working with regions.
`static void`	`forseqNb(int startInc, int endInc, HjProcedure<Integer> body)` Construct to represent loop-level parallelism.
`static void`	`forseqNb(int s0, int e0, int s1, int e1, HjProcedureInt2D body)` Construct to represent loop-level parallelism.
`static <T> void`	`forseqNb(Iterable<T> iterable, HjProcedure<T> body)` Construct to represent loop-level parallelism.
`static <V> HjFuture<V>`	`futureNb(HjCallable<V> callable)` Construct to create an asynchronous task that returns a result which will be available in the futureNb.
`static <T,V> HjFuture<V>`	`futureNbAwait(HjFuture<T> f1, HjCallable<V> callable)` futureNbAwait.
`static <T,V> HjFuture<V>`	`futureNbAwait(HjFuture<T> f1, HjFuture<T> f2, HjCallable<V> callable)` futureNbAwait.
`static <T,V> HjFuture<V>`	`futureNbAwait(HjFuture<T> f1, HjFuture<T> f2, HjFuture<T> f3, HjCallable<V> callable)` futureNbAwait.
`static <T,V> HjFuture<V>`	`futureNbAwait(List<HjFuture<T>> dependences, HjCallable<V> callable)` futureNbAwait.
`static <V> HjFuture<V>`	`futureNbSeq(boolean sequentialize, HjCallable<V> callable)` Construct to create an asynchronous task that returns a result which will be available in the future.
`static <V> HjFuture<V>`	`futureNbSeq(boolean sequentialize, HjCallable<V> seqCallable, HjCallable<V> parCallable)` Similar to the regular `futureNb(edu.rice.hj.api.HjCallable)` except that the boolean condition is used as a tuning parameter to determine if the future should just be executed sequentially (when the condition is true) in the parent task.
`static List<HjRegion.HjRegion1D>`	`group(HjRegion.HjRegion1D hjRegion, int processorGrid)` Evenly divides the loop iteration space into `processorGrid` chunks.
`static List<HjRegion.HjRegion2D>`	`group(HjRegion.HjRegion2D hjRegion, int processorGrid0, int processorGrid1)` Evenly divides the loop iteration space into `processorGrid0 x processorGrid1` chunks.
`static HjPlace`	`here()`
`static void`	`initializeHabanero()` Initialize the Habanero-Java execution environment.
`static void`	`launchHabaneroApp(HjSuspendable suspendable)` Launches the fragment of code to be run by the habanero runtime.
`static void`	`launchHabaneroApp(HjSuspendable suspendable, Runnable preFinalizeCallback)` Launches the fragment of code to be run by the habanero runtime.
`static HjRegion.HjRegion1D`	`myGroup(int groupId, HjRegion.HjRegion1D hjRegion, int groupSize)` Retrieves the region represented for the given `groupId` when the iteration space is divided into `groupSize` groups.
`static RectangularRegion2D`	`myGroup(int groupId0, int groupId1, HjRegion.HjRegion2D hjRegion, int groupSize0, int groupSize1)` Retrieves the region represented for the given `(groupId0, groupId1)` when the iteration space is divided into `groupSize0 x groupSize1` groups.
`static <V> HjDataDrivenFuture<V>`	`newDataDrivenFuture()` Factory method to create a DataDrivenFuture instance.
`static <V> HjDataDrivenFuture<V>`	`newDataDrivenFuture(boolean allowDuplicatePuts)` Factory method to create a DataDrivenFuture instance.
`static <V> HjDataDrivenFuture<V>`	`newDDF()` Factory method to create a DataDrivenFuture instance.
`static <V> HjDataDrivenFuture<V>`	`newDDF(boolean allowDuplicates)` Factory method to create a DataDrivenFuture instance.
`static HjFinishAccumulator`	`newFinishAccumulator(HjOperator ope, Class type)` Factory method to create a HjFinishAccumulator object.
`static HjPhaser`	`newPhaser(HjPhaserMode phaserMode)` Factory method to create a new `HjPhaser` with the specified mode.
`static HjPhaser`	`newPhaser(HjPhaserMode phaserMode, int busyWaitLimit)` Factory method to create a new `HjPhaser` with the specified mode.
`static HjPoint`	`newPoint(int... values)` Factory method to create new HjPoint instances.
`static HjRegion.HjRegion1D`	`newRectangularRegion1D(int pMinInc, int pMaxInc)` Factory method to create a 1D rectangular region object.
`static HjRegion.HjRegion2D`	`newRectangularRegion2D(int pMinInc0, int pMaxInc0, int pMinInc1, int pMaxInc1)` Factory method to create a 2D rectangular region object.
`static HjRegion.HjRegion3D`	`newRectangularRegion3D(int pMinInc0, int pMaxInc0, int pMinInc1, int pMaxInc1, int pMinInc2, int pMaxInc2)` Factory method to create a 3D rectangular region object.
`static void`	`next()` Advance each phaser that this task is registered on to its next phase, in accordance with this task's registration mode.
`static int`	`numPlaces()`
`static int`	`numWorkerThreads()` Return the number of worker threads employed by the runtime.
`static HjPlace`	`place(int id)`
`static void`	`printBuildInfo(PrintStream outputStream)` Prints the String representing of the build information.
`static void`	`signal()` signal each phaser that task is registered on with a signal capability (SIG, SIG_WAIT, SIGNAL). signal is a non-blocking operation - computation between signal and next serves as a 'split phase barrier'
`static boolean[]`	`waitAll(HjFuture[] futures)` Blocks until all of the operations associated with the active requests in the array have completed.
`static boolean[]`	`waitAny(HjFuture[] futures)` Blocks until one of the operations associated with the active requests in the array has completed successfully.

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

- Field Detail
  - runtimeInitialized
```
protected static AtomicBoolean runtimeInitialized
```
    Constant runtimeInitialized
- Constructor Detail
  - Module0
```
protected Module0()
```
    Private constructor to disallow instance creation.
- Method Detail
  - printBuildInfo
```
public static void printBuildInfo(PrintStream outputStream)
```
    Prints the String representing of the build information.
  - launchHabaneroApp
```
public static void launchHabaneroApp(HjSuspendable suspendable)
```
    Launches the fragment of code to be run by the habanero runtime.
  - launchHabaneroApp
```
public static void launchHabaneroApp(HjSuspendable suspendable,
                                     Runnable preFinalizeCallback)
```
    Launches the fragment of code to be run by the habanero runtime.
  - finish
```
public static void finish(HjSuspendable suspendable)
                   throws SuspendableException
```
    Creates a new finish scope to execute the wrapped statements.
    Usage:
```
   finish(() -> S1);
 
```
    OR
```
   finish(() -> {S1; S2;...});
 
```
    Execute statements S1, S2, ..., but wait until all (transitively) spawned asyncs and futures enclosed in the statements scope have terminated. Also, propagate a list of all exceptions thrown by asyncs spawned within statements's scope.
    Parameters:
    
    suspendable - a HjSuspendable object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.finish(edu.rice.hj.api.HjSuspendable)
  - initializeHabanero
```
public static void initializeHabanero()
```
    Initialize the Habanero-Java execution environment.
  - finalizeHabanero
```
public static void finalizeHabanero()
```
    Cleans up all Habanero-Java state.
  - emergencyShutdown
```
public static void emergencyShutdown(Throwable cause)
```
    Immediately exit the program due to an execution error.
    
    Parameters:
    
    cause - a Throwable object.
    
    See Also:
    
    HjRuntime.emergencyShutdown(Throwable)
  - numWorkerThreads
```
public static int numWorkerThreads()
```
    Return the number of worker threads employed by the runtime. Usage:
```
   final int numThreads = numWorkerThreads();
 
```
    Returns:
    
    the number of worker threads employed by the runtime.
    
    See Also:
    
    HjRuntime.numWorkerThreads()
  - asyncNb
```
public static void asyncNb(HjRunnable runnable)
```
    Creates a new asynchronous task to execute the wrapped statements.
    Usage:
```
   HjRunnable aRunnable = () -> { S1; };
   async(aRunnable);
 
```
    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:
    
    runnable - a HjRunnable object.
    
    See Also:
    
    HjRuntime.asyncSeqAt(boolean, edu.rice.hj.api.HjPlace, edu.rice.hj.api.HjRunnable)
  - asyncNbSeq
```
public static void asyncNbSeq(boolean sequentialize,
                              HjRunnable runnable)
```
    Similar to the regular asyncNb(edu.rice.hj.api.HjRunnable) except that the boolean condition is used as a tuning parameter to determine if the async should just be executed sequentially (when the condition is true) in the parent task.
    The semantics of
```
   asyncNbSeq(cond, () -> S1)
 
```
    are as follows:
```
   if (cond)
     S1;
   else
     async(() -> S1);
 
```
    Parameters:
    
    sequentialize - a boolean.
    
    runnable - a HjRunnable object.
    
    See Also:
    
    HjRuntime.asyncSeqAt(boolean, edu.rice.hj.api.HjPlace, edu.rice.hj.api.HjRunnable)
  - asyncNbSeq
```
public static void asyncNbSeq(boolean sequentialize,
                              HjRunnable seqRunnable,
                              HjRunnable parRunnable)
```
    Similar to the regular asyncNb(edu.rice.hj.api.HjRunnable) except that the boolean condition is used as a tuning parameter to determine if the async should just be executed sequentially (when the condition is true) in the parent task.
    The semantics of
```
   asyncNbSeq(cond, () -> S1, () -> S2)
 
```
    are as follows:
```
   if (cond)
     S1;
   else
     async(() -> S2);
 
```
    Parameters:
    
    sequentialize - The flag that determines whether the runtime should consider running the body asynchronously.
    
    seqRunnable - The body of the code to run when sequentialize flag is true.
    
    parRunnable - The body of the code to run when sequentialize flag is false.
    
    See Also:
    
    HjRuntime.asyncSeqAt(boolean, edu.rice.hj.api.HjPlace, edu.rice.hj.api.HjRunnable)
  - forseqNb
```
public static <T> void forseqNb(Iterable<T> iterable,
                                HjProcedure<T> body)
```
    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 HjProcedure object.
  - forallNb
```
public static <T> void forallNb(Iterable<T> iterable,
                                HjProcedure<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 HjProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(Iterable, edu.rice.hj.api.HjProcedure)
  - forasyncNb
```
public static <T> void forasyncNb(Iterable<T> iterable,
                                  HjProcedure<T> body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   forasyncNb(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 HjProcedure object.
  - forseqNb
```
public static void forseqNb(int startInc,
                            int endInc,
                            HjProcedure<Integer> body)
```
    Construct to represent loop-level parallelism. An implicit finish is included for all iterations of the forallNb.
    The semantics of
```
   forseqNb(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 HjProcedure object.
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - newRectangularRegion1D
```
public static HjRegion.HjRegion1D newRectangularRegion1D(int pMinInc,
                                                         int pMaxInc)
```
    Factory method to create a 1D rectangular region object.
    
    Parameters:
    
    pMinInc - a int.
    
    pMaxInc - a int.
    
    Returns:
    
    a HjRegion.HjRegion1D object.
    
    See Also:
    
    RegionFactory.newRectangularRegion1D(int, int)
  - forallNb
```
public static void forallNb(int startInc,
                            int endInc,
                            HjProcedure<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 HjProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNb
```
public static void forasyncNb(int startInc,
                              int endInc,
                              HjProcedure<Integer> body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   forasyncNb(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 HjProcedure object.
  - forallNbChunked
```
public static void forallNbChunked(int startInc,
                                   int endInc,
                                   HjProcedure<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 forallNb(int, int, edu.rice.hj.api.HjProcedure), forallNbChunked(int, int, int, edu.rice.hj.api.HjProcedure), and forasyncNbChunked(int, int, int, edu.rice.hj.api.HjProcedure)
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjProcedure object.
    
    Throws:
    
    SuspendableException
  - computeDefaultChunkSize
```
protected static int computeDefaultChunkSize(int startInc,
                                             int endInc)
```
    Computes the chunk size based on the number of iterations and the number of worker threads.
    
    Returns:
    
    the chunk size
  - forallNbChunked
```
public static void forallNbChunked(int startInc,
                                   int endInc,
                                   int chunkSize,
                                   HjProcedure<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 forallNb(int, int, edu.rice.hj.api.HjProcedure) and forasyncNbChunked(int, int, int, edu.rice.hj.api.HjProcedure)
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    chunkSize - a int.
    
    body - a HjProcedure object.
    
    Throws:
    
    SuspendableException
  - forasyncNbChunked
```
public static void forasyncNbChunked(int startInc,
                                     int endInc,
                                     int chunkSize,
                                     HjProcedure<Integer> body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    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 HjProcedure object.
  - forasyncNbChunked
```
public static void forasyncNbChunked(int startInc,
                                     int endInc,
                                     HjProcedure<Integer> body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    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 HjProcedure object.
    
    See Also:
    
    forasyncNbChunked(int, int, int, edu.rice.hj.api.HjProcedure)
  - futureNb
```
public static <V> HjFuture<V> futureNb(HjCallable<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 = futureNb(aRunnable);
 
```
    OR
```
   HjFuture aFuture = futureNb(() -> { 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.futureSeq(boolean, edu.rice.hj.api.HjCallable)
  - futureNbSeq
```
public static <V> HjFuture<V> futureNbSeq(boolean sequentialize,
                                          HjCallable<V> callable)
```
    Construct to create an asynchronous task that returns a result which will be available in the future. Similar to the regular futureNb(edu.rice.hj.api.HjCallable) except that the boolean condition is used as a tuning parameter to determine if the future should just be executed sequentially (when the condition is true) in the parent task.
    See asyncNbSeq(boolean, edu.rice.hj.api.HjRunnable)
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    sequentialize - a boolean.
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSeq(boolean, edu.rice.hj.api.HjCallable)
  - futureNbSeq
```
public static <V> HjFuture<V> futureNbSeq(boolean sequentialize,
                                          HjCallable<V> seqCallable,
                                          HjCallable<V> parCallable)
```
    Similar to the regular futureNb(edu.rice.hj.api.HjCallable) except that the boolean condition is used as a tuning parameter to determine if the future should just be executed sequentially (when the condition is true) in the parent task.
    See asyncNbSeq(boolean, edu.rice.hj.api.HjRunnable, edu.rice.hj.api.HjRunnable)
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    sequentialize - The flag that determines whether the runtime should consider running the body asynchronously.
    
    seqCallable - The body of the code to run when sequentialize flag is true.
    
    parCallable - The body of the code to run when sequentialize flag is false.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureSeq(boolean, edu.rice.hj.api.HjCallable)
  - newDDF
```
public static <V> HjDataDrivenFuture<V> newDDF()
```
    Factory method to create a DataDrivenFuture instance.
    
    Type Parameters:
    
    V - a V object.
    
    Returns:
    
    a HjDataDrivenFuture object.
    
    See Also:
    
    HjRuntime.newDataDrivenFuture(boolean)
  - newDDF
```
public static <V> HjDataDrivenFuture<V> newDDF(boolean allowDuplicates)
```
    Factory method to create a DataDrivenFuture instance.
    
    Type Parameters:
    
    V - a V object.
    
    Returns:
    
    a HjDataDrivenFuture object.
    
    See Also:
    
    HjRuntime.newDataDrivenFuture(boolean)
  - newDataDrivenFuture
```
public static <V> HjDataDrivenFuture<V> newDataDrivenFuture()
```
    Factory method to create a DataDrivenFuture instance.
    
    Type Parameters:
    
    V - a V object.
    
    Returns:
    
    a HjDataDrivenFuture object.
    
    See Also:
    
    HjRuntime.newDataDrivenFuture(boolean)
  - newDataDrivenFuture
```
public static <V> HjDataDrivenFuture<V> newDataDrivenFuture(boolean allowDuplicatePuts)
```
    Factory method to create a DataDrivenFuture instance.
    
    Type Parameters:
    
    V - a V object.
    
    Returns:
    
    a HjDataDrivenFuture object.
    
    See Also:
    
    HjRuntime.newDataDrivenFuture(boolean)
  - asyncNbAwait
```
public static <T> void asyncNbAwait(HjFuture<T> f1,
                                    HjRunnable runnable)
```
    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
    
    runnable - The callback to execute asynchronously when the futureNb (or DDF) is resolved
    
    See Also:
    
    HjRuntime.asyncAwait(java.util.List, edu.rice.hj.api.HjRunnable)
  - asyncNbAwait
```
public static <T> void asyncNbAwait(List<HjFuture<T>> dependences,
                                    HjRunnable runnable)
```
    Construct to create an asynchronous task which is executed when all the futureNb are resolved.
    
    Parameters:
    
    dependences - a List object.
    
    runnable - a HjRunnable object.
    
    See Also:
    
    HjRuntime.asyncAwait(java.util.List, edu.rice.hj.api.HjRunnable)
  - asyncNbAwait
```
public static <T> void asyncNbAwait(HjFuture<T> f1,
                                    HjFuture<T> f2,
                                    HjRunnable runnable)
```
    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
    
    runnable - The callback to execute asynchronously when the both futures (or DDFs) are resolved
    
    See Also:
    
    HjRuntime.asyncAwait(java.util.List, edu.rice.hj.api.HjRunnable)
  - asyncNbAwait
```
public static <T> void asyncNbAwait(HjFuture<T> f1,
                                    HjFuture<T> f2,
                                    HjFuture<T> f3,
                                    HjRunnable runnable)
```
    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
    
    runnable - The callback to execute asynchronously when the all futures (or DDFs) are resolved
    
    See Also:
    
    HjRuntime.asyncAwait(java.util.List, edu.rice.hj.api.HjRunnable)
  - futureNbAwait
```
public static <T,V> HjFuture<V> futureNbAwait(HjFuture<T> f1,
                                              HjCallable<V> callable)
```
    futureNbAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureAwait(java.util.List, edu.rice.hj.api.HjCallable)
  - futureNbAwait
```
public static <T,V> HjFuture<V> futureNbAwait(List<HjFuture<T>> dependences,
                                              HjCallable<V> callable)
```
    futureNbAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    dependences - a List object.
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureAwait(java.util.List, edu.rice.hj.api.HjCallable)
  - futureNbAwait
```
public static <T,V> HjFuture<V> futureNbAwait(HjFuture<T> f1,
                                              HjFuture<T> f2,
                                              HjCallable<V> callable)
```
    futureNbAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    f2 - a HjFuture object.
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureAwait(java.util.List, edu.rice.hj.api.HjCallable)
  - futureNbAwait
```
public static <T,V> HjFuture<V> futureNbAwait(HjFuture<T> f1,
                                              HjFuture<T> f2,
                                              HjFuture<T> f3,
                                              HjCallable<V> callable)
```
    futureNbAwait.
    
    Type Parameters:
    
    V - a V object.
    
    Parameters:
    
    f1 - a HjFuture object.
    
    f2 - a HjFuture object.
    
    f3 - a HjFuture object.
    
    callable - a HjCallable object.
    
    Returns:
    
    a HjFuture object.
    
    See Also:
    
    HjRuntime.futureAwait(java.util.List, edu.rice.hj.api.HjCallable)
  - waitAll
```
public static boolean[] waitAll(HjFuture[] futures)
                         throws SuspendableException
```
    Blocks until all of the operations associated with the active requests in the array have completed. waitAll() is a like a finish scope for all requests in the array. NOTE: This operation blocks the worker thread!
    
    Parameters:
    
    futures - The input futureNb array, we need to wait on all of them.
    
    Returns:
    
    boolean array of statuses (true = completed successfully, false = there was an error in computing the result of the futureNb).
    
    Throws:
    
    SuspendableException
  - waitAny
```
public static boolean[] waitAny(HjFuture[] futures)
```
    Blocks until one of the operations associated with the active requests in the array has completed successfully. NOTE: This operation blocks the worker thread as there is a busy loop trying to match a successful futureNb!
    
    Parameters:
    
    futures - The input futureNb array, we need to wait on only one of them.
    
    Returns:
    
    boolean array of statuses (true = completed successfully, false = there was an error in computing the result of the futureNb).
  - newFinishAccumulator
```
public static HjFinishAccumulator newFinishAccumulator(HjOperator ope,
                                                       Class type)
```
    Factory method to create a HjFinishAccumulator object.
    
    Parameters:
    
    ope - a HjOperator object.
    
    type - a Class object.
    
    Returns:
    
    a HjFinishAccumulator object.
    
    See Also:
    
    HjRuntime.newFinishAccumulator(edu.rice.hj.api.HjOperator, Class)
  - finish
```
public static void finish(HjFinishAccumulator f1,
                          HjSuspendable suspendable)
                   throws SuspendableException
```
    finish.
    
    Parameters:
    
    f1 - a HjFinishAccumulator object.
    
    suspendable - a HjSuspendable object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.finish(java.util.List, edu.rice.hj.api.HjSuspendable)
  - finish
```
public static void finish(List<HjFinishAccumulator> accumulators,
                          HjSuspendable suspendable)
                   throws SuspendableException
```
    finish.
    
    Parameters:
    
    accumulators - a List object.
    
    suspendable - a HjSuspendable object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.finish(java.util.List, edu.rice.hj.api.HjSuspendable)
  - finish
```
public static void finish(HjFinishAccumulator f1,
                          HjFinishAccumulator f2,
                          HjSuspendable suspendable)
                   throws SuspendableException
```
    finish.
    
    Parameters:
    
    f1 - a HjFinishAccumulator object.
    
    f2 - a HjFinishAccumulator object.
    
    suspendable - a HjSuspendable object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.finish(java.util.List, edu.rice.hj.api.HjSuspendable)
  - finish
```
public static void finish(HjFinishAccumulator f1,
                          HjFinishAccumulator f2,
                          HjFinishAccumulator f3,
                          HjSuspendable suspendable)
                   throws SuspendableException
```
    finish.
    
    Parameters:
    
    f1 - a HjFinishAccumulator object.
    
    f2 - a HjFinishAccumulator object.
    
    f3 - a HjFinishAccumulator object.
    
    suspendable - a HjSuspendable object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.finish(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncPhased
```
public static void asyncPhased(HjPhaserPair phaserPair,
                               HjSuspendable suspendable)
```
    Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
    
    Parameters:
    
    phaserPair - a HjPhaserPair object.
    
    suspendable - a HjSuspendable object.
    
    See Also:
    
    HjRuntime.asyncPhased(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncPhased
```
public static void asyncPhased(HjPhaserPair phaserPair1,
                               HjPhaserPair phaserPair2,
                               HjSuspendable suspendable)
```
    Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
    
    Parameters:
    
    phaserPair1 - a HjPhaserPair object.
    
    phaserPair2 - a HjPhaserPair object.
    
    suspendable - a HjSuspendable object.
    
    See Also:
    
    HjRuntime.asyncPhased(java.util.List, edu.rice.hj.api.HjSuspendable)
  - asyncPhased
```
public static void asyncPhased(List<HjPhaserPair> phaserList,
                               HjSuspendable suspendable)
```
    Create an asynchronous task phased on a specified subset of its parent’s phasers with specified modes (e.g., phaser ph1 with mode1), or on the entire set of the parent's phasers and modes (by default, if no subset is specified).
    
    Parameters:
    
    phaserList - a List object.
    
    suspendable - a HjSuspendable object.
    
    See Also:
    
    HjRuntime.asyncPhased(java.util.List, edu.rice.hj.api.HjSuspendable)
  - forallPhased
```
public static void forallPhased(int startInc,
                                int endInc,
                                HjSuspendingProcedure<Integer> body)
                         throws SuspendableException
```
    In forallPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
    Example usage:
```
 forallPhased(0, m - 1, (i) -> {
   System.out.println("Hello " + i);
   next(); // Barrier
   System.out.println("Goodbye " + i);
 });
 
```
    Here, all the hellos appear before all the goodbyes.
    Please refer to forasyncPhased(int, int, edu.rice.hj.api.HjSuspendingProcedure) for additional semantics.
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncPhased(int, int, java.util.List, edu.rice.hj.api.HjSuspendingProcedure)
  - newPhaser
```
public static HjPhaser newPhaser(HjPhaserMode phaserMode)
```
    Factory method to create a new HjPhaser with the specified mode. Scope of phaser is limited to immediately enclosing finish.
    
    Parameters:
    
    phaserMode - a HjPhaserMode object.
    
    Returns:
    
    a HjPhaser object.
    
    See Also:
    
    HjRuntime.newPhaser(edu.rice.hj.api.HjPhaserMode, int)
  - forasyncPhased
```
public static void forasyncPhased(int startInc,
                                  int endInc,
                                  List<HjPhaserPair> phaserList,
                                  HjSuspendingProcedure<Integer> body)
```
    In this variant of forasyncPhased, you have phasers registered with the spawned asyncs (there is one async for each iteration of the loop) explicitly.
    Please refer to forasyncPhased(int, int, edu.rice.hj.api.HjSuspendingProcedure) for additional semantics.
    
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    phaserList - a List object.
    
    body - a HjProcedure object.
    
    See Also:
    
    forasyncPhased(int, int, java.util.List, edu.rice.hj.api.HjSuspendingProcedure)
  - newPhaser
```
public static HjPhaser newPhaser(HjPhaserMode phaserMode,
                                 int busyWaitLimit)
```
    Factory method to create a new HjPhaser with the specified mode. Scope of phaser is limited to immediately enclosing finish.
    
    Parameters:
    
    phaserMode - a HjPhaserMode object.
    
    busyWaitLimit - The busy wait iteration limit.
    
    Returns:
    
    a HjPhaser object.
    
    See Also:
    
    HjRuntime.newPhaser(edu.rice.hj.api.HjPhaserMode, int)
  - forallPhased
```
public static <T> void forallPhased(Iterable<T> iterable,
                                    HjSuspendingProcedure<T> body)
                             throws SuspendableException
```
    In forallPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
    Example usage:
```
 forallPhased(anIterable, (i) -> {
   System.out.println("Hello " + i);
   next(); // Barrier
   System.out.println("Goodbye " + i);
 });
 
```
    Here, all the hellos appear before all the goodbyes.
    Please refer to forasyncPhased(int, int, edu.rice.hj.api.HjSuspendingProcedure) for additional semantics.
    Type Parameters:
    
    T - a T object.
    
    Parameters:
    
    iterable - a Iterable object.
    
    body - a HjProcedure object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncPhased(int, int, java.util.List, edu.rice.hj.api.HjSuspendingProcedure)
  - forasyncPhased
```
public static <T> void forasyncPhased(Iterable<T> iterable,
                                      List<HjPhaserPair> phaserList,
                                      HjSuspendingProcedure<T> body)
```
    In this variant of forasyncPhased, you have phasers registered with the spawned asyncs (there is one async for each iteration of the loop) explicitly.
    Please refer to forasyncPhased(int, int, edu.rice.hj.api.HjSuspendingProcedure) for additional semantics.
    
    Type Parameters:
    
    T - a T object.
    
    Parameters:
    
    iterable - a Iterable object.
    
    phaserList - a List object.
    
    body - a HjProcedure object.
    
    See Also:
    
    forasyncPhased(Iterable, java.util.List, edu.rice.hj.api.HjSuspendingProcedure)
  - forasyncPhased
```
public static void forasyncPhased(int startInc,
                                  int endInc,
                                  HjSuspendingProcedure<Integer> body)
```
    In forasyncPhased, you have a phaser registered with the spawned asyncs (there is one async for each iteration of the loop) implicitly.
    The semantics of:
```
   forasyncPhased(0, m - 1, (i) -> { S(i); } );
 
```
    is equivalent to:
```
   final HjPhaser ph = newPhaser(SIG_WAIT);
   for(int ii = 0; ii <= m - 1; ii++) {
     final int i = ii;
     asyncPhased(ph.inMode(SIG_WAIT), () -> { S(i); });
   }
 
```
    Example usage:
```
 finish(() -> {
   forasyncPhased(0, m - 1, (i) -> {
     System.out.println("Hello " + i);
     next(); // Barrier
     System.out.println("Goodbye " + i);
   });
 });
 
```
    Here, all the hellos appear before all the goodbyes.
    Parameters:
    
    startInc - a int.
    
    endInc - a int.
    
    body - a HjProcedure object.
    
    See Also:
    
    forasyncPhased(int, int, java.util.List, edu.rice.hj.api.HjSuspendingProcedure)
  - next
```
public static void next()
                 throws SuspendableException
```
    Advance each phaser that this task is registered on to its next phase, in accordance with this task's registration mode. Wait on each phaser that task is registered on with a wait capability (WAIT, SIG_WAIT, SINGLE).
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.next()
  - signal
```
public static void signal()
```
    signal each phaser that task is registered on with a signal capability (SIG, SIG_WAIT, SIGNAL). signal is a non-blocking operation - computation between signal and next serves as a 'split phase barrier'
    
    See Also:
    
    HjRuntime.signal()
  - doWait
```
public static void doWait()
                   throws SuspendableException
```
    wait on each phaser that task is registered on with a wait capability (WAIT, SIG_WAIT). wait is a potentially blocking operation.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    HjRuntime.doWait()
  - doWork
```
public static void doWork(long n)
```
    Used by abstract performance metrics to report work done by the currently executing task.
    Usage:
```
 finish(() -> {
   async(() -> { doWork(1); ... });
   doWork(2);
   async(() -> { doWork(2); ... });
   async(() -> { doWork(3); ... });
 });
 final HjMetrics actualMetrics = abstractMetrics();
 AbstractMetricsManager.dumpStatistics(actualMetrics);
 
```
    Parameters:
    
    n - The units of work to record
    
    See Also:
    
    HjRuntime.doWork(long)
  - abstractMetrics
```
public static HjMetrics abstractMetrics()
```
    Returns the metrics report for the currently executing task.
    Usage:
```
   final HjMetrics actualMetrics = abstractMetrics();
   AbstractMetricsManager.dumpStatistics(actualMetrics);
 
```
    Returns:
    
    the metrics report for the currently executing task.
    
    See Also:
    
    HjRuntime.abstractMetrics()
  - dumpEventLog
```
public static void dumpEventLog(PrintStream printStream)
```
    Dumps the events tracked by the runtime.
    
    Parameters:
    
    printStream - The stream to use while dumping the events.
    
    See Also:
    
    HjRuntime.dumpEventLog(java.io.PrintStream)
  - newPoint
```
public static HjPoint newPoint(int... values)
```
    Factory method to create new HjPoint instances.
    An example use of creating a point representing the origin in 2D geometry:
```
   final HjPoint origin = newPoint(0, 0);
 
```
    Parameters:
    
    values - The individual terms of the point.
    
    Returns:
    
    a new Point instance.
    
    See Also:
    
    PointFactory.factory(int...)
  - newRectangularRegion3D
```
public static HjRegion.HjRegion3D newRectangularRegion3D(int pMinInc0,
                                                         int pMaxInc0,
                                                         int pMinInc1,
                                                         int pMaxInc1,
                                                         int pMinInc2,
                                                         int pMaxInc2)
```
    Factory method to create a 3D rectangular region object.
    
    Parameters:
    
    pMinInc0 - a int.
    
    pMaxInc0 - a int.
    
    pMinInc1 - a int.
    
    pMaxInc1 - a int.
    
    pMinInc2 - a int.
    
    pMaxInc2 - a int.
    
    Returns:
    
    a HjRegion.HjRegion3D object.
    
    See Also:
    
    RegionFactory.newRectangularRegion3D(int, int, int, int, int, int)
  - group
```
public static List<HjRegion.HjRegion1D> group(HjRegion.HjRegion1D hjRegion,
                                              int processorGrid)
```
    Evenly divides the loop iteration space into processorGrid chunks.
```
   final HjRegion1D iterSpace = newRectangularRegion1D(0, N - 1);
   final List hjRegionList = group(iterSpace, numWorkerThreads());
 
```
    Parameters:
    
    hjRegion - The iteration space of the loop
    
    processorGrid - The number of processors/threads to chunk the iteration space into
    
    Returns:
    
    A partition of the input region chunked so that each chunk can be run in the processor grid.
    
    See Also:
    
    RegionFactory.groupRegion(edu.rice.hj.api.HjRegion.HjRegion1D, int)
  - myGroup
```
public static HjRegion.HjRegion1D myGroup(int groupId,
                                          HjRegion.HjRegion1D hjRegion,
                                          int groupSize)
```
    Retrieves the region represented for the given groupId when the iteration space is divided into groupSize groups.
```
   final HjRegion1D iterSpace = newRectangularRegion1D(0, N - 1);
   forallNb(0, tasks - 1, (t) -> {
     final HjRegion1D myGroup = myGroup(t, iterSpace, tasks);
     ...
   });
 
```
    Parameters:
    
    groupId - The id of the group to retrieve. It should be less than groupSize
    
    hjRegion - The iteration space
    
    groupSize - The number of groups the iteration space should have been divided
    
    Returns:
    
    The region represented for the given groupId when the iteration space is divided into groupSize groups.
    
    See Also:
    
    RegionFactory.groupRegion(edu.rice.hj.api.HjRegion.HjRegion1D, int)
  - group
```
public static List<HjRegion.HjRegion2D> group(HjRegion.HjRegion2D hjRegion,
                                              int processorGrid0,
                                              int processorGrid1)
```
    Evenly divides the loop iteration space into processorGrid0 x processorGrid1 chunks.
```
   final HjRegion2D iterSpace = newRectangularRegion2D(1, M, 1, N);
   final List hjRegionList = group(iterSpace, 4, 6);
 
```
    Parameters:
    
    hjRegion - a HjRegion.HjRegion2D object.
    
    processorGrid0 - a int.
    
    processorGrid1 - a int.
    
    Returns:
    
    a List object.
    
    See Also:
    
    RegionFactory.groupRegion(edu.rice.hj.api.HjRegion.HjRegion2D, int, int)
  - myGroup
```
public static RectangularRegion2D myGroup(int groupId0,
                                          int groupId1,
                                          HjRegion.HjRegion2D hjRegion,
                                          int groupSize0,
                                          int groupSize1)
```
    Retrieves the region represented for the given (groupId0, groupId1) when the iteration space is divided into groupSize0 x groupSize1 groups.
```
   final HjRegion2D iterSpace = newRectangularRegion2D(1, M, 1, N);
   forallNb(0, X - 1, 0, Y - 1, (i, j) -> {
     final HjRegion2D myGroup = myGroup(i, j, iterSpace, M, N);
     ...
   });
 
```
    Parameters:
    
    groupId0 - a int.
    
    groupId1 - a int.
    
    hjRegion - a HjRegion.HjRegion2D object.
    
    groupSize0 - a int.
    
    groupSize1 - a int.
    
    Returns:
    
    a RectangularRegion2D object.
    
    See Also:
    
    RegionFactory.groupRegion(edu.rice.hj.api.HjRegion.HjRegion1D, int)
  - forseqNb
```
public static void forseqNb(HjRegion.HjRegion1D hjRegion,
                            HjProcedureInt1D body)
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion1D iterSpace = newRectangularRegion1D(startInc, endInc);
   forseqNb(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
  - forallNb
```
public static void forallNb(HjRegion.HjRegion1D hjRegion,
                            HjProcedureInt1D 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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasync
```
public static void forasync(HjRegion.HjRegion1D hjRegion,
                            HjProcedureInt1D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   final HjRegion1D iterSpace = newRectangularRegion1D(startInc, endInc);
   forasyncNb(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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forallNbChunked
```
public static void forallNbChunked(HjRegion.HjRegion1D hjRegion,
                                   HjProcedureInt1D 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 HjProcedureInt1D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncChunked
```
public static void forasyncChunked(HjRegion.HjRegion1D hjRegion,
                                   HjProcedureInt1D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    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 HjProcedureInt1D object.
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forseqNb
```
public static void forseqNb(int s0,
                            int e0,
                            int s1,
                            int e1,
                            HjProcedureInt2D body)
```
    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.
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - newRectangularRegion2D
```
public static HjRegion.HjRegion2D newRectangularRegion2D(int pMinInc0,
                                                         int pMaxInc0,
                                                         int pMinInc1,
                                                         int pMaxInc1)
```
    Factory method to create a 2D rectangular region object.
    
    Parameters:
    
    pMinInc0 - a int.
    
    pMaxInc0 - a int.
    
    pMinInc1 - a int.
    
    pMaxInc1 - a int.
    
    Returns:
    
    a HjRegion.HjRegion2D object.
    
    See Also:
    
    RegionFactory.newRectangularRegion2D(int, int, int, int)
  - forseqNb
```
public static void forseqNb(HjRegion.HjRegion2D hjRegion,
                            HjProcedureInt2D body)
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion2D iterSpace = newRectangularRegion2D(s0, e0, s1, e1);
   forseqNb(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
  - forallNb
```
public static void forallNb(int s0,
                            int e0,
                            int s1,
                            int e1,
                            HjProcedureInt2D 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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forallNb
```
public static void forallNb(HjRegion.HjRegion2D hjRegion,
                            HjProcedureInt2D 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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNb
```
public static void forasyncNb(HjRegion.HjRegion2D hjRegion,
                              HjProcedureInt2D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   final HjRegion2D iterSpace = newRectangularRegion2D(s0, e0, s1, e1);
   forasyncNb(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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNb
```
public static void forasyncNb(int s0,
                              int e0,
                              int s1,
                              int e1,
                              HjProcedureInt2D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   forasyncNb(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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure), forasyncNb(int, int, edu.rice.hj.api.HjProcedure), forasyncNb(int, int, edu.rice.hj.api.HjProcedure), forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forallNbChunked
```
public static void forallNbChunked(int s0,
                                   int e0,
                                   int s1,
                                   int e1,
                                   HjProcedureInt2D 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 HjProcedureInt2D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forallNbChunked
```
public static void forallNbChunked(HjRegion.HjRegion2D hjRegion,
                                   HjProcedureInt2D 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 HjProcedureInt2D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNbChunked
```
public static void forasyncNbChunked(HjRegion.HjRegion2D hjRegion,
                                     HjProcedureInt2D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    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 HjProcedureInt2D object.
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forseqNb
```
public static void forseqNb(HjRegion.HjRegion3D hjRegion,
                            HjProcedureInt3D body)
```
    Construct to represent a sequential loop while working with regions.
    The semantics of
```
   final HjRegion3D iterSpace = newRectangularRegion3D(s0, e0, s1, e1, s2, e2);
   forseqNb(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
  - forallNb
```
public static void forallNb(HjRegion.HjRegion3D hjRegion,
                            HjProcedureInt3D 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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNb
```
public static void forasyncNb(HjRegion.HjRegion3D hjRegion,
                              HjProcedureInt3D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    The semantics of
```
   final HjRegion3D iterSpace = newRectangularRegion3D(s0, e0, s1, e1, s2, e2);
   forasyncNb(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:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forallNbChunked
```
public static void forallNbChunked(HjRegion.HjRegion3D hjRegion,
                                   HjProcedureInt3D 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 HjProcedureInt3D object.
    
    Throws:
    
    SuspendableException
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - forasyncNbChunked
```
public static void forasyncNbChunked(HjRegion.HjRegion3D hjRegion,
                                     HjProcedureInt3D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish in the iterations of forasyncNb.
    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 HjProcedureInt3D object.
    
    See Also:
    
    forasyncNb(int, int, edu.rice.hj.api.HjProcedure)
  - numPlaces
```
public static int numPlaces()
```
    Returns:
    
    the number of configured places.
  - here
```
public static HjPlace here()
```
    Returns:
    
    the current place of execution
  - place
```
public static HjPlace place(int id)
```
    Returns:
    
    the place with the specified id
  - asyncNbAt
```
public static void asyncNbAt(HjPlace place,
                             HjRunnable runnable)
```
    Parameters:
    
    place - The place where the async task should run.
    
    runnable - The body of the code to run, possibly asynchronously.
    
    See Also:
    
    asyncNb(edu.rice.hj.api.HjRunnable)

Class Module0

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

runtimeInitialized

Constructor Detail

Module0

Method Detail

printBuildInfo

launchHabaneroApp

launchHabaneroApp

finish

initializeHabanero

finalizeHabanero

emergencyShutdown

numWorkerThreads

asyncNb

asyncNbSeq

asyncNbSeq

forseqNb

forallNb

forasyncNb

forseqNb

newRectangularRegion1D

forallNb

forasyncNb

forallNbChunked

computeDefaultChunkSize

forallNbChunked

forasyncNbChunked

forasyncNbChunked

futureNb

futureNbSeq

futureNbSeq

newDDF

newDDF

newDataDrivenFuture

newDataDrivenFuture

asyncNbAwait

asyncNbAwait

asyncNbAwait

asyncNbAwait

futureNbAwait

futureNbAwait

futureNbAwait

futureNbAwait

waitAll

waitAny

newFinishAccumulator

finish

finish

finish

finish

asyncPhased

asyncPhased

asyncPhased

forallPhased

newPhaser

forasyncPhased

newPhaser

forallPhased

forasyncPhased

forasyncPhased

next

signal

doWait

doWork

abstractMetrics

dumpEventLog

newPoint

newRectangularRegion3D

group

myGroup

group

myGroup

forseqNb

forallNb

forasync