Element types that can be used with the blockwise filling functions.

This class is mainly used to define the touch method. This is used internally in the imeplementation of Repa to prevent let-binding from being floated inappropriately by the GHC simplifier. Doing a seq sometimes isn't enough, because the GHC simplifier can erase these, and still move around the bindings.

Class of manifest array representations that can be constructed in parallel.

Compute all elements defined by an array and write them to a manifest target representation.

Note that instances require that the source array to have a delayed representation such as D or C. If you want to use a pre-existing manifest array as the source then delay it first.

Compute a range of elements defined by an array and write them to a fillable representation.

O(n). Construct a manifest array from a list.

Sequential computation of array elements.

Parallel computation of array elements.

• The source array must have a delayed representation like D, C or P, and the result a manifest representation like U or F.
• If you want to copy data between manifest representations then use copyP instead.
• If you want to convert a manifest array back to a delayed representation then use delay instead.

Suspended parallel computation of array elements.

This version creates a thunk that will evaluate the array on demand. If you force it when another parallel computation is already running then you will get a runtime warning and evaluation will be sequential. Use deepSeqArray and now to ensure that each array is evaluated before proceeding to the next one.

If unsure then just use the monadic version computeP. This one ensures that each array is fully evaluated before continuing.

Sequential copying of arrays.

Parallel copying of arrays.

• This is a wrapper that delays an array before calling computeP.
• You can use it to copy manifest arrays between representations.

Suspended parallel copy of array elements.

Monadic version of deepSeqArray.

Forces an suspended array computation to be completed at this point in a monadic computation.

 do  let arr2 = suspendedComputeP arr1
     ...
     arr3 <- now $ arr2
     ...

Fill something sequentially.

• The array is filled linearly from start to finish.

Fill something in parallel.

• The array is split into linear chunks, and each thread linearly fills one chunk.

Fill something in parallel, using a separate IO action for each thread.

• The array is split into linear chunks, and each thread linearly fills one chunk.

Fill something in parallel.

• The array is split into linear chunks and each thread fills one chunk.

Fill a block in a rank-2 array in parallel.

• Blockwise filling can be more cache-efficient than linear filling for rank-2 arrays.
• Coordinates given are of the filled edges of the block.
• We divide the block into columns, and give one column to each thread.
• Each column is filled in row major order from top to bottom.

Fill a block in a rank-2 array, sequentially.

• Blockwise filling can be more cache-efficient than linear filling for rank-2 arrays.
• The block is filled in row major order from top to bottom.

Fill a block in a rank-2 array, sequentially.

• Blockwise filling can be more cache-efficient than linear filling for rank-2 arrays.
• Using cursor functions can help to expose inter-element indexing computations to the GHC and LLVM optimisers.
• Coordinates given are of the filled edges of the block.
• The block is filled in row major order from top to bottom.

Fill a block in a rank-2 array in parallel.

• Blockwise filling can be more cache-efficient than linear filling for rank-2 arrays.
• Using cursor functions can help to expose inter-element indexing computations to the GHC and LLVM optimisers.
• Coordinates given are of the filled edges of the block.
• We divide the block into columns, and give one column to each thread.
• Each column is filled in row major order from top to bottom.

Select indices matching a predicate.

• This primitive can be useful for writing filtering functions.

Select indices matching a predicate, in parallel.

• This primitive can be useful for writing filtering functions.
• The array is split into linear chunks, with one chunk being given to each thread.
• The number of elements in the result array depends on how many threads you're running the program with.