PCDP

java.lang.Object
- edu.rice.pcdp.PCDP

```
public final class PCDP
extends java.lang.Object
```
The main class of the PCDP framework, containing most of the user-visible APIs.

Field Summary

Fields
Modifier and Type Field and Description

protected static java.lang.String missingFinishMsg

Fields
Modifier and Type	Field and Description
`protected static java.lang.String`	`missingFinishMsg`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`async(java.lang.Runnable runnable)` async creates an asynchronously executing task.
`static void`	`asyncAwait(java.lang.Runnable runnable, java.util.concurrent.Future<? extends java.lang.Object>... futures)` Creates an asynchronous task whose execution is predicated on the satisfaction of the futures passed to asyncAwait.
`static void`	`finish(java.lang.Runnable runnable)` finish waits for all tasks spawned in runnable to complete, as well as any transitively spawned child, granchild, etc tasks.
`static void`	`forall(int startInc, int endInc, ProcedureInt1D body)` A similar loop-parallel construct to forasync, with the only difference being that forall includes an implicit finish wrapping all asynchronous tasks created.
`static void`	`forall2d(int startInc0, int endInc0, int startInc1, int endInc1, ProcedureInt2D body)` A two-dimensional variant on forall.
`static void`	`forall2dChunked(int start0, int endInclusive0, int start1, int endInclusive1, int chunkSize, ProcedureInt2D body)` A two-dimensional variant of forallChunked.
`static void`	`forall2dChunked(int start0, int endInclusive0, int start1, int endInclusive1, ProcedureInt2D body)` A variant of two-dimensional forallChunked that internally selects a sane chunk size.
`static void`	`forallChunked(int start, int endInclusive, int chunkSize, ProcedureInt1D body)` A chunked variant of the forall APIs.
`static void`	`forallChunked(int start, int endInclusive, ProcedureInt1D body)` A variant of one-dimensional forallChunked that internally selects a sane chunk size.
`static void`	`forasync(int startInc, int endInc, ProcedureInt1D body)` Construct to represent loop-level parallelism.
`static void`	`forasync2d(int startInc0, int endInc0, int startInc1, int endInc1, ProcedureInt2D body)` A two-dimensional variant on forasync, analogous to two nested parallel loops.
`static void`	`forasync2dChunked(int start0, int endInclusive0, int start1, int endInclusive1, int chunkSize, ProcedureInt2D body)` A two-dimensional variant of forasyncChunked.
`static void`	`forasync2dChunked(int start0, int endInclusive0, int start1, int endInclusive1, ProcedureInt2D body)` A variant of two-dimensional forasyncChunked that internally selects a sane chunk size.
`static void`	`forasyncChunked(int start, int endInclusive, int chunkSize, ProcedureInt1D body)` Semantically equivalent to forasync, but internally the runtime chunks the defined parallel loop according to chunkSize.
`static void`	`forasyncChunked(int start, int endInclusive, ProcedureInt1D body)` A variant of one-dimensional forasyncChunked that internally selects a sane chunk size.
`static void`	`forseq(int start, int endInclusive, ProcedureInt1D body)` An API in the same style as PCDP's parallel loop APIs, but which executes the defined loop sequentially.
`static void`	`forseq2d(int start0, int endInclusive0, int start1, int endInclusive1, ProcedureInt2D body)` An API in the same style as PCDP's parallel loop APIs, but which executes the defined loop sequentially.
`static <R> java.util.concurrent.Future<R>`	`future(java.util.concurrent.Callable<R> body)` Spawn an asynchronous task that returns a value of type .
`static <R> java.util.concurrent.Future<R>`	`futureAwait(java.util.concurrent.Callable<R> runnable, java.util.concurrent.Future<? extends java.lang.Object>... futures)` A hybridization of future() and asyncAwait().
`static void`	`isolated(java.lang.Object obj1, java.lang.Object obj2, java.lang.Runnable runnable)` Object-based isolation on two objects, obj1 and obj2.
`static void`	`isolated(java.lang.Object obj, java.lang.Runnable runnable)` Object-based isolation on a single object.
`static void`	`isolated(java.lang.Runnable runnable)` Global isolated statement.
`static int`	`numThreads()` Retrieve the number of software threads the PCDP runtime was configured with.

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

- Field Detail
  - missingFinishMsg
```
protected static final java.lang.String missingFinishMsg
```
    See Also:
    
    Constant Field Values
- Method Detail
  - finish
```
public static void finish(java.lang.Runnable runnable)
```
    finish waits for all tasks spawned in runnable to complete, as well as any transitively spawned child, granchild, etc tasks. The method call to finish will only return once all tasks have completed.
    
    Parameters:
    
    runnable - User-written body of the finish scope to execute.
  - async
```
public static void async(java.lang.Runnable runnable)
```
    async creates an asynchronously executing task.
    
    Parameters:
    
    runnable - User-written body of the task.
  - forasync
```
public static void forasync(int startInc,
                            int endInc,
                            ProcedureInt1D body)
```
    Construct to represent loop-level parallelism. There is no implicit finish on the iterations of a 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 - The start of the loop range this parallel loop executes over (inclusive).
    
    endInc - The end of the loop range this parllel loop executes over (exclusive).
    
    body - a ProcedureInt1D object defining the body of the parallel loop.
  - forasync2d
```
public static void forasync2d(int startInc0,
                              int endInc0,
                              int startInc1,
                              int endInc1,
                              ProcedureInt2D body)
```
    A two-dimensional variant on forasync, analogous to two nested parallel loops.
    
    Parameters:
    
    startInc0 - The starting value for the outermost sequential loop.
    
    endInc0 - The final value for the outermost sequential loop (inclusive).
    
    startInc1 - The starting value for the innermost sequential loop.
    
    endInc1 - The final value for the innermost sequential loop (inclusive).
    
    body - a ProcedureInt2D object defining the body of these nested loops.
  - forall
```
public static void forall(int startInc,
                          int endInc,
                          ProcedureInt1D body)
```
    A similar loop-parallel construct to forasync, with the only difference being that forall includes an implicit finish wrapping all asynchronous tasks created.
    
    Parameters:
    
    startInc - The start of the loop range this parallel loop executes over (inclusive).
    
    endInc - The end of the loop range this parllel loop executes over (exclusive).
    
    body - a ProcedureInt1D object defining the body of the parallel loop.
  - forall2d
```
public static void forall2d(int startInc0,
                            int endInc0,
                            int startInc1,
                            int endInc1,
                            ProcedureInt2D body)
```
    A two-dimensional variant on forall.
    
    Parameters:
    
    startInc0 - The starting value for the outermost sequential loop.
    
    endInc0 - The final value for the outermost sequential loop (inclusive).
    
    startInc1 - The starting value for the innermost sequential loop.
    
    endInc1 - The final value for the innermost sequential loop (inclusive).
    
    body - a ProcedureInt2D object defining the body of these nested loops.
  - forasyncChunked
```
public static void forasyncChunked(int start,
                                   int endInclusive,
                                   int chunkSize,
                                   ProcedureInt1D body)
```
    Semantically equivalent to forasync, but internally the runtime chunks the defined parallel loop according to chunkSize. If chunkSize does not evenly divide the loop range specified, the runtime will automatically cut off any extra loop iterations and not execute them.
    
    Parameters:
    
    start - The starting iteration for the parallel loop
    
    endInclusive - The ending iteration for the parallel loop (inclusive)
    
    chunkSize - The number of iterations to chunk together for processing by a single asynchronous task
    
    body - The body of the loop to execute
  - forasyncChunked
```
public static void forasyncChunked(int start,
                                   int endInclusive,
                                   ProcedureInt1D body)
```
    A variant of one-dimensional forasyncChunked that internally selects a sane chunk size.
    
    Parameters:
    
    start - The starting iteration for the parallel loop
    
    endInclusive - The ending iteration for the parallel loop (inclusive)
    
    body - The body of the loop to execute
  - forasync2dChunked
```
public static void forasync2dChunked(int start0,
                                     int endInclusive0,
                                     int start1,
                                     int endInclusive1,
                                     int chunkSize,
                                     ProcedureInt2D body)
```
    A two-dimensional variant of forasyncChunked.
    
    Parameters:
    
    start0 - The starting iteration for the outermost parallel loop
    
    endInclusive0 - The ending iteration for the outermost parallel loop (inclusive)
    
    start1 - The starting iteration for the innermost parallel loop
    
    endInclusive1 - The ending iteration for the innermost parallel loop (inclusive)
    
    chunkSize - The number of iterations to chunk together for processing by a single asynchronous task
    
    body - The body of the loop to execute
  - forasync2dChunked
```
public static void forasync2dChunked(int start0,
                                     int endInclusive0,
                                     int start1,
                                     int endInclusive1,
                                     ProcedureInt2D body)
```
    A variant of two-dimensional forasyncChunked that internally selects a sane chunk size.
    
    Parameters:
    
    start0 - The starting iteration for the outermost parallel loop
    
    endInclusive0 - The ending iteration for the outermost parallel loop (inclusive)
    
    start1 - The starting iteration for the innermost parallel loop
    
    endInclusive1 - The ending iteration for the innermost parallel loop (inclusive)
    
    body - The body of the loop to execute
  - forallChunked
```
public static void forallChunked(int start,
                                 int endInclusive,
                                 int chunkSize,
                                 ProcedureInt1D body)
```
    A chunked variant of the forall APIs. forallChunked has the same chunking semantics as forasyncChunked, but with an implicit, blocking finish for all created tasks.
    
    Parameters:
    
    start - The starting iteration for the parallel loop
    
    endInclusive - The ending iteration for the parallel loop (inclusive)
    
    chunkSize - The number of iterations to chunk together for processing by a single asynchronous task
    
    body - The body of the loop to execute
  - forallChunked
```
public static void forallChunked(int start,
                                 int endInclusive,
                                 ProcedureInt1D body)
```
    A variant of one-dimensional forallChunked that internally selects a sane chunk size.
    
    Parameters:
    
    start - The starting iteration for the parallel loop
    
    endInclusive - The ending iteration for the parallel loop (inclusive)
    
    body - The body of the loop to execute
  - forall2dChunked
```
public static void forall2dChunked(int start0,
                                   int endInclusive0,
                                   int start1,
                                   int endInclusive1,
                                   int chunkSize,
                                   ProcedureInt2D body)
```
    A two-dimensional variant of forallChunked.
    
    Parameters:
    
    start0 - The starting iteration for the outermost parallel loop
    
    endInclusive0 - The ending iteration for the outermost parallel loop (inclusive)
    
    start1 - The starting iteration for the innermost parallel loop
    
    endInclusive1 - The ending iteration for the innermost parallel loop (inclusive)
    
    chunkSize - The number of iterations to chunk together for processing by a single asynchronous task
    
    body - The body of the loop to execute
  - forall2dChunked
```
public static void forall2dChunked(int start0,
                                   int endInclusive0,
                                   int start1,
                                   int endInclusive1,
                                   ProcedureInt2D body)
```
    A variant of two-dimensional forallChunked that internally selects a sane chunk size.
    
    Parameters:
    
    start0 - The starting iteration for the outermost parallel loop
    
    endInclusive0 - The ending iteration for the outermost parallel loop (inclusive)
    
    start1 - The starting iteration for the innermost parallel loop
    
    endInclusive1 - The ending iteration for the innermost parallel loop (inclusive)
    
    body - The body of the loop to execute
  - future
```
public static <R> java.util.concurrent.Future<R> future(java.util.concurrent.Callable<R> body)
```
    Spawn an asynchronous task that returns a value of type . Return a future object that can be used to wait on the completion of the spawned task, and fetch its resulting value.
    
    Type Parameters:
    
    R - Return type of the launched future task.
    
    Parameters:
    
    body - user-defined body of the task.
    
    Returns:
    
    A future that can be used to wait on the completion of the created task and fetch its return value.
  - asyncAwait
```
public static void asyncAwait(java.lang.Runnable runnable,
                              java.util.concurrent.Future<? extends java.lang.Object>... futures)
```
    Creates an asynchronous task whose execution is predicated on the satisfaction of the futures passed to asyncAwait. runnable will not start executing until all futures have been put on.
    
    Parameters:
    
    runnable - Body of the task.
    
    futures - Future objects to block the spawned task on.
  - futureAwait
```
public static <R> java.util.concurrent.Future<R> futureAwait(java.util.concurrent.Callable<R> runnable,
                                                             java.util.concurrent.Future<? extends java.lang.Object>... futures)
```
    A hybridization of future() and asyncAwait(). futureAwait creates an asynchronous task whose execution is both predicated on the provided futures, and which also returns a future that is satisfied when it completes.
    
    Type Parameters:
    
    R - Return type of the launched future task.
    
    Parameters:
    
    runnable - Body of the task.
    
    futures - Future objects to block the spawned task on.
    
    Returns:
    
    A future that can be used to wait on the completion of the created task and fetch its return value.
  - forseq
```
public static void forseq(int start,
                          int endInclusive,
                          ProcedureInt1D body)
```
    An API in the same style as PCDP's parallel loop APIs, but which executes the defined loop sequentially. All loops have an increment of +1.
    
    Parameters:
    
    start - The starting value for the sequential loop.
    
    endInclusive - The final value for the sequential loop (inclusive).
    
    body - a ProcedureInt1D object defining the body of these nested loops.
  - forseq2d
```
public static void forseq2d(int start0,
                            int endInclusive0,
                            int start1,
                            int endInclusive1,
                            ProcedureInt2D body)
```
    An API in the same style as PCDP's parallel loop APIs, but which executes the defined loop sequentially. All loops have an increment of +1.
    
    Parameters:
    
    start0 - The starting value for the outermost sequential loop.
    
    endInclusive0 - The final value for the outermost sequential loop (inclusive).
    
    start1 - The starting value for the innermost sequential loop.
    
    endInclusive1 - The final value for the innermost sequential loop (inclusive).
    
    body - a ProcedureInt2D object defining the body of these nested loops.
  - numThreads
```
public static int numThreads()
```
    Retrieve the number of software threads the PCDP runtime was configured with.
    
    Returns:
    
    The number of PCDP runtime threads.
  - isolated
```
public static void isolated(java.lang.Runnable runnable)
```
    Global isolated statement. runnable will execute in isolation with all other isolated blocks.
    
    Parameters:
    
    runnable - The body to be executed in isolation.
  - isolated
```
public static void isolated(java.lang.Object obj,
                            java.lang.Runnable runnable)
```
    Object-based isolation on a single object. isolated guarantees that runnable will not execute in parallel with any other global isolation blocks, or object-based isolated blocks that also are isolated on obj.
    
    Parameters:
    
    obj - The object to implement isolation on.
    
    runnable - The body to be executed in isolation.
  - isolated
```
public static void isolated(java.lang.Object obj1,
                            java.lang.Object obj2,
                            java.lang.Runnable runnable)
```
    Object-based isolation on two objects, obj1 and obj2. The body runnable is guaranteed to execute in mutual exclusion with any other global isolated blocks, or any object-based isolated blocks that are isolated on obj1 and/or obj2.
    
    Parameters:
    
    obj1 - The first object to implement isolation on.
    
    obj2 - The second object to implement isolation on.
    
    runnable - The body to be executed in isolation.

Class PCDP

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

missingFinishMsg

Method Detail

finish

async

forasync

forasync2d

forall

forall2d

forasyncChunked

forasyncChunked

forasync2dChunked

forasync2dChunked

forallChunked

forallChunked

forall2dChunked

forall2dChunked

future

asyncAwait

futureAwait

forseq

forseq2d

numThreads

isolated

isolated

isolated