Utilities¶

Usage

use Utilities;

iter forEachLocale(): int¶

iter forEachLocale(param tag: iterKind): int

iter forEachCorePerLocale(): int¶

iter forEachCorePerLocale(param tag: iterKind): int

config const printLocaleStatistics = false¶

config param debugMode = false¶

config const profileCommDiagnostics = false¶

config const profileCommDiagnosticsVerbose = false¶

config const profileVisualDebug = false¶

proc debug(args ...)¶

Only prints if printDebugInformation is enabled; warning: Chapel still evaluates arguments so side-effects will still occur!

proc debug(args ...)

proc beginProfile(vdebugName = "vdebug")¶

proc endProfile()¶

record ArrayRef¶

Array reference wrapper; captures the privatization id and instance, and can be treated mostly as an array, except without the implicit by-value copying. Note that the lifetime of the original array is unaffected by this ‘reference’, hence care must be used to not use this after the original array goes out of scope.

var pid: int = -1¶

var instance¶

proc init(ref A: [])¶

proc _value¶

proc intersection(A: [] ?t, B: [] t)¶

Obtains the intersection of two arrays, A and B. This method is optimized for locality and will copy any remote arrays to be entirely local; this includes a locality check for the array and the domain itself (which will be remote if the user creates an implicit copy).

proc intersectionSize(A: [] ?t, B: [] t)¶

Obtains the intersection size of two arrays, A and B. This method is optimized for locality and will copy any remote arrays to be entirely local; this includes a locality check for the array and the domain itself (which will be remote if the user creates an implicit copy).

proc intersectionSizeAtLeast(A: [] ?t, B: [] t, s: integral)¶

Determines whether the size of the intersection of two arrays, A and B is at least ‘s’. This method is optimized for locality and will copy any remote arrays to be entirely local; this includes a locality check for the array and the domain itself (which will be remote if the user creates an implicit copy).

proc _intersectionSizeAtLeast(A: [] ?t, B: [] t, s: integral)¶

proc _arrayEquality(A: [] ?t, B: [] t)¶

proc arrayEquality(A: [] ?t, B: [] t)¶

type chpl_comm_nb_handle_t¶

proc chpl_comm_get_nb(addr: c_void_ptr, node: chpl_nodeID_t, raddr: c_void_ptr, size: size_t, typeIndex: int(32), commID: int(32), ln: c_int, fn: int(32)): chpl_comm_nb_handle_t¶

proc getAddr(ref x: ?t): c_void_ptr¶

proc getLocaleID(ref x: ?t): chpl_localeID_t¶

proc getNodeID(ref x: ?t): chpl_nodeID_t¶

proc get_nb(ref r1: ?t1): Future((t1))¶

var _globalIntRandomStream = intmakeRandomStreamparSafe = true¶

var _globalRealRandomStream = realmakeRandomStreamparSafe = true¶

proc randInt(low, high)¶

proc randInt(high)

proc randInt()

proc randReal(low, high)¶

proc randReal(high)

proc randReal()

proc getRandomAssociative(dom: domain, ref elt: dom.eltType): bool¶

class Centralized¶

var x¶

proc init(x)¶

proc init(type X)

proc getLocaleIdx(dom, idx)¶

proc getLocale(dom, idx)¶

proc getLocale(arr: [], idx)

proc createCyclic(dom: domain)¶

proc createCyclic(rng: range)

proc createCyclic(sz: integral, startIdx = 1)

proc createBlock(dom: domain)¶

proc createBlock(rng: range)

proc createBlock(sz: integral, startIdx = 1)

iter getLines(file: string): string¶

iter getLines(file: string, chunkSize = 1024, param tag: iterKind): string

proc any(it: _iteratorRecord)¶

proc all(it: _iteratorRecord)¶