RangeChunk

Usage

use RangeChunk;

or

import RangeChunk;

Utility routines for splitting a range into multiple chunks.

The RangeChunk module assists with dividing a bounded range of any idxType and stride into numChunks. Chunks are 0-based, with the 0 index chunk including range.lowBound and the numChunks - 1 index chunk including range.highBound.

Chunks are accessible in several ways:

as a range, through an iterator

as a range, through a query

as a tuple of 0-based orders into the range, through an iterator

as a tuple of 0-based orders into the range, through a query

Given that it will be uncommon for the length of a given range to be divisible by numChunks, there are three different remainder policies available, expressed by the enum RemElems.

enum RemElems { Thru, Pack, Mod }

RemElems specifies the distribution of remainder elements.

enum constant Thru: Default policy; remainder elements will be distributed throughout numChunks chunks

enum constant Pack: Chunks at the front will receive ceil(range.size / numChunks) elements, then one chunk will receive what is left over; the actual number of chunks may be less than numChunks

enum constant Mod: In numChunks chunks, every chunk that has an index less than range.size % numChunks will receive a remainder element

iter chunks(r: range(?), numChunks: integral, remPol: RemElems = Thru): Iterates through chunks 0 to numChunks - 1 of range r, emitting each as a range. The remainders will be distributed according to remPol.

proc chunk(r: range(?), numChunks: integral, idx: integral, remPol: RemElems = Thru): Returns the idx chunk of range r as a range. The remainders will be distributed according to remPol.

iter blockCyclicChunks(r: range(?), blockSize: integral, tid: integral, nTasks: integral)

iter chunksOrder(r: range(?RT, boundKind.both, ?), numChunks: integral, remPol: RemElems = Thru) : 2*(RT): Iterates through chunks 0 to numChunks - 1 of range r, emitting each as a 0-based order tuple. The remainders will be distributed according to remPol.

proc chunkOrder(r: range(?RT, boundKind.both, ?), numChunks: integral, idx: integral, remPol: RemElems = Thru) : 2*(RT): Returns the idx chunk of range r as a 0-based order tuple. The remainders will be distributed according to remPol.