Index

Documents: backends_guide.md, distributed_guide.md, index.md, io_guide.md, lattice_guide.md, simd_guide.md, tensor_guide.md.

Modules: globalarrays/gabase, globalarrays/gampi, globalarrays/gatypes, globalarrays/gawrap, globalarrays/globalarrays, io/io, io/lime, io/qio, io/scidac, io/tensorio, lattice, lattice/latticeconcept, lattice/simplecubiclattice, lattice/stencil, opencl/clbase, opencl/cldisp, opencl/clwrap, opencl/opencl, openmp/ompbase, openmp/omplocal, openmp/ompwrap, parallel, reliq, simd/simdlayout, tensor/globaltensor, tensor/localtensor, tensor/sitetensor, tensor/tensor, tensor/tensorview, utils/commandline, utils/complex, utils/private.

API symbols

`$`:

• qio: proc `$`(cs: QIOChecksum): string
• scidac: proc `$`(cs: SciDACChecksum): string
• stencil: proc `$`(d: Direction): string
• stencil: proc `$`(sd: SignedDirection): string
• stencil: proc `$`[D: static int](s: StencilPattern[D]): string
• stencil: proc `$`[D: static int](p: StencilPoint[D]): string
• simdlayout: proc `$`(layout: SimdLatticeLayout): string
• sitetensor: proc `$`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]): string
• sitetensor: proc `$`[T](data: RuntimeSiteData[T]): string
• sitetensor: proc `$`[L, T](proxy: TensorSiteProxy[L, T]): string

`*`:

• sitetensor: proc `*`[D: static[int]; R: static[int]; L, T](a, b: LocalSiteProxy[D, R, L, T]): LocalMulResult[ D, R, L, T]
• sitetensor: proc `*`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; scalar: T): LocalScalarMulResult[D, R, L, T]
• sitetensor: proc `*`[N: static[int]; K: static[int]; M: static[int]; T](a: Mat[N, K, T]; b: Mat[K, M, T]): Mat[N, M, T]
• sitetensor: proc `*`[N: static[int]; M: static[int]; T](m: Mat[N, M, T]; a: T): Mat[N, M, T]
• sitetensor: proc `*`[N: static[int]; M: static[int]; T](m: Mat[N, M, T]; v: Vec[M, T]): Vec[N, T]
• sitetensor: proc `*`[L, T](res: MatAddResult[L, T]; scalar: T): ScalarMulResult[L, T]
• sitetensor: proc `*`[L, T](res: MatMulResult[L, T]; scalar: T): ScalarMulResult[L, T]
• sitetensor: proc `*`[D: static[int]; R: static[int]; L, T](scalar: T; proxy: LocalSiteProxy[D, R, L, T]): LocalScalarMulResult[D, R, L, T]
• sitetensor: proc `*`[N: static[int]; M: static[int]; T](a: T; m: Mat[N, M, T]): Mat[N, M, T]
• sitetensor: proc `*`[L, T](scalar: T; res: MatAddResult[L, T]): ScalarMulResult[L, T]
• sitetensor: proc `*`[L, T](scalar: T; res: MatMulResult[L, T]): ScalarMulResult[L, T]
• sitetensor: proc `*`[L, T](scalar: T; proxy: TensorSiteProxy[L, T]): ScalarMulResult[L, T]
• sitetensor: proc `*`[N: static[int]; T](a: T; v: Vec[N, T]): Vec[N, T]
• sitetensor: proc `*`[L, T](proxy: TensorSiteProxy[L, T]; scalar: T): ScalarMulResult[L, T]
• sitetensor: proc `*`[L, T](a, b: TensorSiteProxy[L, T]): MatMulResult[L, T]
• sitetensor: proc `*`[N: static[int]; T](v: Vec[N, T]; a: T): Vec[N, T]

`+`:

• sitetensor: proc `+`[D: static[int]; R: static[int]; L, T](a, b: LocalSiteProxy[D, R, L, T]): LocalAddResult[ D, R, L, T]
• sitetensor: proc `+`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; scalar: T): LocalScalarAddResult[D, R, L, T]
• sitetensor: proc `+`[N: static[int]; M: static[int]; T](a, b: Mat[N, M, T]): Mat[N, M, T]
• sitetensor: proc `+`[L, T](a, b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a: MatAddResult[L, T]; b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a: MatAddResult[L, T]; b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a: MatMulResult[L, T]; b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a, b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a: MatMulResult[L, T]; b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[D: static[int]; R: static[int]; L, T](scalar: T; proxy: LocalSiteProxy[D, R, L, T]): LocalScalarAddResult[D, R, L, T]
• sitetensor: proc `+`[L, T](scalar: T; proxy: TensorSiteProxy[L, T]): ScalarAddResult[L, T]
• sitetensor: proc `+`[L, T](a: TensorSiteProxy[L, T]; b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](a: TensorSiteProxy[L, T]; b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[L, T](proxy: TensorSiteProxy[L, T]; scalar: T): ScalarAddResult[L, T]
• sitetensor: proc `+`[L, T](a, b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `+`[N: static[int]; T](a, b: Vec[N, T]): Vec[N, T]

`-`:

• sitetensor: proc `-`[D: static[int]; R: static[int]; L, T](a, b: LocalSiteProxy[D, R, L, T]): LocalAddResult[ D, R, L, T]
• sitetensor: proc `-`[N: static[int]; M: static[int]; T](a, b: Mat[N, M, T]): Mat[N, M, T]
• sitetensor: proc `-`[L, T](a, b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: MatAddResult[L, T]; b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: MatAddResult[L, T]; b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: MatMulResult[L, T]; b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a, b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: MatMulResult[L, T]; b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: TensorSiteProxy[L, T]; b: MatAddResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a: TensorSiteProxy[L, T]; b: MatMulResult[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[L, T](a, b: TensorSiteProxy[L, T]): MatAddResult[L, T]
• sitetensor: proc `-`[N: static[int]; T](a, b: Vec[N, T]): Vec[N, T]

`==`:

• stencil: proc `==`(a, b: Direction): bool

`=copy`:

• gatypes: proc `=copy`[D: static[int]; T](dest: var GlobalArray[D, T]; src: GlobalArray[D, T])
• tensorview: proc `=copy`(dest: var DeviceStorage; src: DeviceStorage)
• tensorview: proc `=copy`[L, T](dest: var TensorFieldView[L, T]; src: TensorFieldView[L, T])

`=destroy`:

• gatypes: proc `=destroy`[D: static[int]; T](ga: GlobalArray[D, T])
• tensorview: proc `=destroy`[L, T](view: var TensorFieldView[L, T])

`[]=`:

• clbase: proc `[]=`[T](buffer: GpuBuffer[T]; index: int; value: T)
• clbase: proc `[]=`(buffer: Pmem; index: int; value: float64)
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; site: int; value: LocalAddResult[D, R, L, T])
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; site: int; value: LocalMulResult[D, R, L, T])
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; site: int; value: LocalScalarAddResult[D, R, L, T])
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; site: int; value: LocalScalarMulResult[D, R, L, T])
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; site: int; value: LocalSiteProxy[D, R, L, T])
• localtensor: proc `[]=`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var LocalTensorField[D, R, L, T]; idx: int; value: T)
• sitetensor: proc `[]=`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i, j, k: int; value: T)
• sitetensor: proc `[]=`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i, j: int; value: T)
• sitetensor: proc `[]=`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i: int; value: T)
• sitetensor: proc `[]=`[N: static[int]; M: static[int]; T](m: var Mat[N, M, T]; i, j: int; val: T)
• sitetensor: proc `[]=`[L, T](proxy: TensorSiteProxy[L, T]; i, j, k: int; value: T)
• sitetensor: proc `[]=`[L, T](proxy: TensorSiteProxy[L, T]; i, j: int; value: T)
• sitetensor: proc `[]=`[L, T](proxy: TensorSiteProxy[L, T]; i: int; value: T)
• sitetensor: proc `[]=`[N: static[int]; T](v: var Vec[N, T]; i: int; val: T)
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: MatAddResult[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: MatMulResult[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: MatVecResult[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: ScalarAddResult[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: ScalarMulResult[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: T)
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: TensorSiteProxy[L, T])
• tensorview: proc `[]=`[L, T](view: TensorFieldView[L, T]; site: int; value: VecAddResult[L, T])

`[]`:

• clbase: proc `[]`[T](buffer: GpuBuffer[T]; index: int): T
• clbase: proc `[]`(buffer: Pmem; index: int): float64
• localtensor: proc `[]`[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: LocalTensorField[D, R, L, T]; idx: int): T
• sitetensor: proc `[]`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i: int): T
• sitetensor: proc `[]`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i, j: int): T
• sitetensor: proc `[]`[D: static[int]; R: static[int]; L, T](proxy: LocalSiteProxy[D, R, L, T]; i, j, k: int): T
• sitetensor: proc `[]`[N: static[int]; M: static[int]; T](m: Mat[N, M, T]; i, j: int): T
• sitetensor: proc `[]`[L, T](proxy: TensorSiteProxy[L, T]; i: int): TensorElementProxy[L, T]
• sitetensor: proc `[]`[L, T](proxy: TensorSiteProxy[L, T]; i, j: int): TensorElementProxy[L, T]
• sitetensor: proc `[]`[L, T](proxy: TensorSiteProxy[L, T]; i, j, k: int): TensorElementProxy[L, T]
• sitetensor: proc `[]`[N: static[int]; T](v: Vec[N, T]; i: int): T
• tensorview: proc `[]`[L, T](view: TensorFieldView[L, T]; site: int): TensorSiteProxy[L, T]
• tensorview: proc `[]`[L, T, D: static int](view: TensorFieldView[L, T]; shift: StencilShift[D]): TensorSiteProxy[ L, T]

accessGhosts:

• gatypes: proc accessGhosts[D: static[int]; T](ga: GlobalArray[D, T]): (ptr UncheckedArray[T], array[D, int], array[D, int])
• globaltensor: proc accessGhosts[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): ptr UncheckedArray[T]

accessLocal:

• gatypes: proc accessLocal[D: static[int]; T](ga: GlobalArray[D, T]): (ptr UncheckedArray[T], array[D, int])
• globaltensor: proc accessLocal[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): ptr UncheckedArray[T]

acos:

• clbase: proc acos(x: float32): float32

addPoint:

• stencil: proc addPoint[D: static int](s: var StencilPattern[D]; offset: array[D, int])
• stencil: proc addPoint[D: static int](s: var StencilPattern[D]; sign: int; dir: int)
• stencil: proc addPoint[D: static int](s: var StencilPattern[D]; sd: SignedDirection)

ADDRESS_CLAMP:

• clwrap: const ADDRESS_CLAMP

ADDRESS_CLAMP_TO_EDGE:

• clwrap: const ADDRESS_CLAMP_TO_EDGE

ADDRESS_MIRRORED_REPEAT:

• clwrap: const ADDRESS_MIRRORED_REPEAT

ADDRESS_NONE:

• clwrap: const ADDRESS_NONE

ADDRESS_REPEAT:

• clwrap: const ADDRESS_REPEAT

all:

• omplocal: macro all(forLoop: ForLoopStmt): untyped

allDirections:

• stencil: iterator allDirections(nDim: int): SignedDirection

alloc:

• gawrap: proc alloc(handle: cint)

allReduceFloat32:

• gampi: proc allReduceFloat32(sendbuf: ptr float32; recvbuf: ptr float32; count: cint): cint

allReduceFloat64:

• gampi: proc allReduceFloat64(sendbuf: ptr float64; recvbuf: ptr float64; count: cint): cint

allReduceInt32:

• gampi: proc allReduceInt32(sendbuf: ptr int32; recvbuf: ptr int32; count: cint): cint

allReduceInt64:

• gampi: proc allReduceInt64(sendbuf: ptr int64; recvbuf: ptr int64; count: cint): cint

aosoaDataPtr:

• tensorview: proc aosoaDataPtr[L, T](view: TensorFieldView[L, T]): ptr UncheckedArray[T]

aosoaIndex:

• simdlayout: proc aosoaIndex(outerIdx, innerIdx, elemIdx, elemsPerSite, nSitesInner: int): int

aosoaIndexFromLocal:

• simdlayout: proc aosoaIndexFromLocal(localIdx, elemIdx, elemsPerSite: int; layout: SimdLatticeLayout): int

apply:

• globaltensor: proc apply[D: static[int]; R: static[int]; L: Lattice[D]; T]( shifter: GlobalShifter[D, R, L, T]; src: TensorField[D, R, L, T]; dest: var TensorField[D, R, L, T])

applyStencilShift:

• globaltensor: proc applyStencilShift[D: static[int]; R: static[int]; L: Lattice[D]; T]( src: TensorField[D, R, L, T]; dest: var TensorField[D, R, L, T]; dim: int; direction: int)

args:

• clbase: macro args(kernel: Pkernel; args: varargs[untyped]): untyped

asin:

• clbase: proc asin(x: float32): float32

atan:

• clbase: proc atan(x: float32): float32

atan2:

• clbase: proc atan2(y, x: float32): float32

atomic_add:

• clbase: template atomic_add(p: ptr int32; val: int32): int32

atomic_add_impl:

• clbase: proc atomic_add_impl(p: ptr int32; val: int32): int32

atomic_and:

• clbase: template atomic_and(p: ptr int32; val: int32): int32

atomic_and_impl:

• clbase: proc atomic_and_impl(p: ptr int32; val: int32): int32

atomic_cmpxchg:

• clbase: template atomic_cmpxchg(p: ptr int32; cmp, val: int32): int32

atomic_cmpxchg_impl:

• clbase: proc atomic_cmpxchg_impl(p: ptr int32; cmp, val: int32): int32

atomic_dec:

• clbase: template atomic_dec(p: ptr int32): int32

atomic_dec_impl:

• clbase: proc atomic_dec_impl(p: ptr int32): int32

atomic_inc:

• clbase: template atomic_inc(p: ptr int32): int32

atomic_inc_impl:

• clbase: proc atomic_inc_impl(p: ptr int32): int32

atomic_max:

• clbase: template atomic_max(p: ptr int32; val: int32): int32

atomic_max_impl:

• clbase: proc atomic_max_impl(p: ptr int32; val: int32): int32

atomic_min:

• clbase: template atomic_min(p: ptr int32; val: int32): int32

atomic_min_impl:

• clbase: proc atomic_min_impl(p: ptr int32; val: int32): int32

atomic_or:

• clbase: template atomic_or(p: ptr int32; val: int32): int32

atomic_or_impl:

• clbase: proc atomic_or_impl(p: ptr int32; val: int32): int32

atomic_sub:

• clbase: template atomic_sub(p: ptr int32; val: int32): int32

atomic_sub_impl:

• clbase: proc atomic_sub_impl(p: ptr int32; val: int32): int32

atomic_xchg:

• clbase: template atomic_xchg(p: ptr int32; val: int32): int32

atomic_xchg_impl:

• clbase: proc atomic_xchg_impl(p: ptr int32; val: int32): int32

atomic_xor:

• clbase: template atomic_xor(p: ptr int32; val: int32): int32

atomic_xor_impl:

• clbase: proc atomic_xor_impl(p: ptr int32; val: int32): int32

BackendBuffer:

• tensorview: type BackendBuffer

BackendQueue:

• tensorview: type BackendQueue

backward:

• stencil: proc backward(d: Direction): SignedDirection

backwardStencil:

• stencil: proc backwardStencil[D: static int](): StencilPattern[D]
• stencil: proc backwardStencil[D: static int; L: Lattice[D]](lat: L): StencilPattern[D]

barrier:

• clbase: template barrier(flags: cint)

barrier_impl:

• clbase: proc barrier_impl(flags: cint)

BLOCKING:

• clwrap: const BLOCKING

boBigEndian:

• qio: ByteOrder.boBigEndian

boLittleEndian:

• qio: ByteOrder.boLittleEndian

boNative:

• qio: ByteOrder.boNative

buffer:

• clbase: proc buffer[A](context: Pcontext; size: int; flags: Tmem_flags = MEM_READ_WRITE): Pmem

BUFFER_CREATE_TYPE_REGION:

• clwrap: const BUFFER_CREATE_TYPE_REGION

bufferLike:

• clbase: proc bufferLike[A](context: Pcontext; xs: openArray[A]; flags: Tmem_flags = MEM_READ_WRITE): Pmem

buffers:

• tensorview: proc buffers[L, T](view: TensorFieldView[L, T]): seq[BackendBuffer]

BUILD_ERROR:

• clwrap: const BUILD_ERROR

buildErrors:

• clbase: proc buildErrors(program: Pprogram; devices: seq[Pdevice_id]): string

BUILD_IN_PROGRESS:

• clwrap: const BUILD_IN_PROGRESS

BUILD_NONE:

• clwrap: const BUILD_NONE

buildOn:

• clbase: proc buildOn(program: Pprogram; device: Pdevice_id)
• clbase: proc buildOn(program: Pprogram; devices: seq[Pdevice_id])

buildProgram:

• clwrap: proc buildProgram(program: Pprogram; num_devices: uint32; device_list: ptr Pdevice_id; options: cstring; pfn_notify: TProgramCb; user_data: pointer): TClResult

BUILD_SUCCESS:

• clwrap: const BUILD_SUCCESS

bwd:

• stencil: proc bwd(dir: int): PathStep
• stencil: proc bwd[D: static int](s: LatticeStencil[D]; site: int; dir: int): StencilShift[D]

ByteOrder:

• qio: enum ByteOrder

bytesRemaining:

• lime: proc bytesRemaining(reader: LimeReader): int64

calcDataSize:

• scidac: proc calcDataSize(fileInfo: SciDACFileInfo; recordInfo: SciDACRecordInfo): int64

cargc:

• commandline: proc cargc(): cint

cargv:

• commandline: proc cargv(argc: cint): cstringArray

C_DBL:

• gawrap: var C_DBL

ceil:

• clbase: proc ceil(x: float32): float32

C_FLOAT:

• gawrap: var C_FLOAT

check:

• clwrap: template check(a: TClResult)

C_INT:

• gawrap: var C_INT

CL_A:

• clwrap: const CL_A

clamp:

• clbase: template clamp(x, minVal, maxVal: float32): float32

clamp_impl:

• clbase: proc clamp_impl(x, minVal, maxVal: float32): float32

CL_ARGB:

• clwrap: const CL_ARGB

CL_BGRA:

• clwrap: const CL_BGRA

CL_FALSE:

• clwrap: const CL_FALSE

CL_FLOAT:

• clwrap: const CL_FLOAT

CL_HALF_FLOAT:

• clwrap: const CL_HALF_FLOAT

CLK_GLOBAL_MEM_FENCE:

• clbase: const CLK_GLOBAL_MEM_FENCE

CLK_LOCAL_MEM_FENCE:

• clbase: const CLK_LOCAL_MEM_FENCE

C_LONGLONG:

• gawrap: var C_LONGLONG

close:

• lime: proc close(reader: LimeReader)
• lime: proc close(writer: LimeWriter): LimeStatus
• qio: proc close[T](r: QIOFieldReader[T])
• qio: proc close[T](w: QIOFieldWriter[T]): LimeStatus
• scidac: proc close(r: ILDGReader)
• scidac: proc close(r: SciDACReader)
• scidac: proc close(w: SciDACWriter): LimeStatus
• tensorio: proc close(reader: TensorFieldReader)
• tensorio: proc close(writer: TensorFieldWriter): LimeStatus

clParallel:

• opencl: template clParallel(body: untyped): untyped

CL_R:

• clwrap: const CL_R

CL_RA:

• clwrap: const CL_RA

CL_RG:

• clwrap: const CL_RG

CL_RGB:

• clwrap: const CL_RGB

CL_RGBA:

• clwrap: const CL_RGBA

CL_RGBx:

• clwrap: const CL_RGBx

CL_RGx:

• clwrap: const CL_RGx

CL_Rx:

• clwrap: const CL_Rx

CL_SIGNED_INT16:

• clwrap: const CL_SIGNED_INT16

CL_SIGNED_INT32:

• clwrap: const CL_SIGNED_INT32

CL_SIGNED_INT8:

• clwrap: const CL_SIGNED_INT8

CL_SNORM_INT16:

• clwrap: const CL_SNORM_INT16

CL_SNORM_INT8:

• clwrap: const CL_SNORM_INT8

CL_TRUE:

• clwrap: const CL_TRUE

CL_UNORM_INT_101010:

• clwrap: const CL_UNORM_INT_101010

CL_UNORM_INT16:

• clwrap: const CL_UNORM_INT16

CL_UNORM_INT24:

• clwrap: const CL_UNORM_INT24

CL_UNORM_INT8:

• clwrap: const CL_UNORM_INT8

CL_UNORM_SHORT_555:

• clwrap: const CL_UNORM_SHORT_555

CL_UNORM_SHORT_565:

• clwrap: const CL_UNORM_SHORT_565

CL_UNSIGNED_INT16:

• clwrap: const CL_UNSIGNED_INT16

CL_UNSIGNED_INT32:

• clwrap: const CL_UNSIGNED_INT32

CL_UNSIGNED_INT8:

• clwrap: const CL_UNSIGNED_INT8

colors:

• tensorio: proc colors(reader: TensorFieldReader): int

combine:

• qio: proc combine(cs1, cs2: QIOChecksum): QIOChecksum

combineChecksums:

• scidac: proc combineChecksums(cs1, cs2: SciDACChecksum): SciDACChecksum

COMMAND_ACQUIRE_GL_OBJECTS:

• clwrap: const COMMAND_ACQUIRE_GL_OBJECTS

COMMAND_BARRIER:

• clwrap: const COMMAND_BARRIER

COMMAND_COPY_BUFFER:

• clwrap: const COMMAND_COPY_BUFFER

COMMAND_COPY_BUFFER_RECT:

• clwrap: const COMMAND_COPY_BUFFER_RECT

COMMAND_COPY_BUFFER_TO_IMAGE:

• clwrap: const COMMAND_COPY_BUFFER_TO_IMAGE

COMMAND_COPY_IMAGE:

• clwrap: const COMMAND_COPY_IMAGE

COMMAND_COPY_IMAGE_TO_BUFFER:

• clwrap: const COMMAND_COPY_IMAGE_TO_BUFFER

COMMAND_FILL_BUFFER:

• clwrap: const COMMAND_FILL_BUFFER

COMMAND_FILL_IMAGE:

• clwrap: const COMMAND_FILL_IMAGE

COMMAND_MAP_BUFFER:

• clwrap: const COMMAND_MAP_BUFFER

COMMAND_MAP_IMAGE:

• clwrap: const COMMAND_MAP_IMAGE

COMMAND_MARKER:

• clwrap: const COMMAND_MARKER

COMMAND_MIGRATE_MEM_OBJECTS:

• clwrap: const COMMAND_MIGRATE_MEM_OBJECTS

COMMAND_NATIVE_KERNEL:

• clwrap: const COMMAND_NATIVE_KERNEL

COMMAND_NDRANGE_KERNEL:

• clwrap: const COMMAND_NDRANGE_KERNEL

commandQueueFor:

• clbase: proc commandQueueFor(context: Pcontext; device: Pdevice_id): Pcommand_queue

COMMAND_READ_BUFFER:

• clwrap: const COMMAND_READ_BUFFER

COMMAND_READ_BUFFER_RECT:

• clwrap: const COMMAND_READ_BUFFER_RECT

COMMAND_READ_IMAGE:

• clwrap: const COMMAND_READ_IMAGE

COMMAND_RELEASE_GL_OBJECTS:

• clwrap: const COMMAND_RELEASE_GL_OBJECTS

COMMAND_TASK:

• clwrap: const COMMAND_TASK

COMMAND_UNMAP_MEM_OBJECT:

• clwrap: const COMMAND_UNMAP_MEM_OBJECT

COMMAND_USER:

• clwrap: const COMMAND_USER

COMMAND_WRITE_BUFFER:

• clwrap: const COMMAND_WRITE_BUFFER

COMMAND_WRITE_BUFFER_RECT:

• clwrap: const COMMAND_WRITE_BUFFER_RECT

COMMAND_WRITE_IMAGE:

• clwrap: const COMMAND_WRITE_IMAGE

compileProgram:

• clwrap: proc compileProgram(program: Pprogram; num_devices: uint32; device_list: ptr Pdevice_id; options: cstring; num_input_headers: uint32; input_headers: ptr Pprogram; header_include_names: cstringArray; pfn_notify: TProgramCb; user_data: pointer): TClResult

COMPLETE:

• clwrap: const COMPLETE

computeElementsPerSite:

• tensorview: proc computeElementsPerSite(shape: openArray[int]; isComplex: bool = false): int

computeLocalGeom:

• simdlayout: proc computeLocalGeom(globalGeom, mpiGrid: openArray[int]): seq[int]

computeProduct:

• simdlayout: proc computeProduct(geom: seq[int]): int

computeStrides:

• simdlayout: proc computeStrides(geom: seq[int]): seq[int]

computeTotalLatticeSites:

• tensorview: proc computeTotalLatticeSites(localGrid: openArray[int]): int

conformable:

• gatypes: proc conformable[D: static[int]; T](a, b: GlobalArray[D, T]): bool

constant:

• clbase: template constant()

CONTEXT_DEVICES:

• clwrap: const CONTEXT_DEVICES

CONTEXT_INTEROP_USER_SYNC:

• clwrap: const CONTEXT_INTEROP_USER_SYNC

CONTEXT_NUM_DEVICES:

• clwrap: const CONTEXT_NUM_DEVICES

CONTEXT_PLATFORM:

• clwrap: const CONTEXT_PLATFORM

CONTEXT_PROPERTIES:

• clwrap: const CONTEXT_PROPERTIES

CONTEXT_REFERENCE_COUNT:

• clwrap: const CONTEXT_REFERENCE_COUNT

coordsToLex:

• globaltensor: proc coordsToLex[D: static int](coords: array[D, int]; geom: array[D, int]): int

coordsToLexicographic:

• simdlayout: proc coordsToLexicographic(coords: seq[int]; strides: seq[int]): int

coordsToPaddedFlat:

• globaltensor: proc coordsToPaddedFlat[D: static int](coords: array[D, int]; paddedGeom: array[D, int]; ghostWidth: array[D, int]; innerBlockSize: int): int

cos:

• clbase: proc cos(x: float32): float32

cosh:

• clbase: proc cosh(x: float32): float32

crc32:

• scidac: proc crc32(data: openArray[byte]): uint32

createAndBuild:

• clbase: proc createAndBuild(context: Pcontext; body: string; device: Pdevice_id): Pprogram
• clbase: proc createAndBuild(context: Pcontext; body: string; devices: seq[Pdevice_id]): Pprogram

createAndBuildBinary:

• clbase: proc createAndBuildBinary(context: Pcontext; body: string; device: Pdevice_id): Pprogram

createBuffer:

• clwrap: proc createBuffer(context: Pcontext; flags: Tmem_flags; size: int; host_ptr: pointer; errcode_ret: ptr TClResult): Pmem

createCommandQueue:

• clwrap: proc createCommandQueue(context: Pcontext; device: Pdevice_id; properties: Tcommand_queue_properties; errcode_ret: ptr TClResult): Pcommand_queue

createContext:

• clbase: proc createContext(devices: seq[Pdevice_id]): Pcontext
• clwrap: proc createContext(properties: ptr Tcontext_properties; num_devices: uint32; devices: ptr Pdevice_id; pfn_notify: TCreateContextCb; user_data: pointer; errcode_ret: ptr TClResult): Pcontext

createContextFromType:

• clwrap: proc createContextFromType(properties: ptr Tcontext_properties; device_type: TDeviceType; pfn_notify: TCreateContextCb; user_data: pointer; errcode_ret: ptr TClResult): Pcontext

createHeader:

• lime: proc createHeader(mbFlag, meFlag: bool; limeType: string; dataLen: int64): LimeRecordHeader

createImage:

• clwrap: proc createImage(context: Pcontext; flags: Tmem_flags; image_format: ptr Timage_format; image_desc: ptr Timage_desc; host_ptr: pointer; errcode_ret: ptr TClResult): Pmem

createImage2D:

• clwrap: proc createImage2D(context: Pcontext; flags: Tmem_flags; image_format: ptr Timage_format; image_width: int; image_height: int; image_row_pitch: int; host_ptr: pointer; errcode_ret: ptr TClResult): Pmem

createImage3D:

• clwrap: proc createImage3D(context: Pcontext; flags: Tmem_flags; image_format: ptr Timage_format; image_width: int; image_height: int; image_depth: int; image_row_pitch: int; image_slice_pitch: int; host_ptr: pointer; errcode_ret: ptr TClResult): Pmem

createKernel:

• clbase: proc createKernel(program: Pprogram; name: string): Pkernel
• clwrap: proc createKernel(program: Pprogram; kernel_name: cstring; errcode_ret: ptr TClResult): Pkernel

createKernelsInProgram:

• clwrap: proc createKernelsInProgram(program: Pprogram; num_kernels: uint32; kernels: ptr Pkernel; num_kernels_ret: ptr uint32): TClResult

createProgram:

• clbase: proc createProgram(context: Pcontext; body: string): Pprogram

createProgramBinary:

• clbase: proc createProgramBinary(context: Pcontext; device: Pdevice_id; body: string): Pprogram

createProgramWithBinary:

• clwrap: proc createProgramWithBinary(context: Pcontext; num_devices: uint32; device_list: ptr Pdevice_id; lengths: ptr int; binaries: ptr ptr uint8; binary_status: ptr int32; errcode_ret: ptr TClResult): Pprogram

createProgramWithBuiltInKernels:

• clwrap: proc createProgramWithBuiltInKernels(context: Pcontext; num_devices: uint32; device_list: ptr Pdevice_id; kernel_names: cstring; errcode_ret: ptr TClResult): Pprogram

createProgramWithSource:

• clwrap: proc createProgramWithSource(context: Pcontext; count: uint32; strings: cstringArray; lengths: ptr int; errcode_ret: ptr TClResult): Pprogram

createSampler:

• clwrap: proc createSampler(context: Pcontext; normalized_coords: Tbool; addressing_mode: Taddressing_mode; filter_mode: Tfilter_mode; errcode_ret: ptr TClResult): Psampler

createSubBuffer:

• clwrap: proc createSubBuffer(buffer: Pmem; flags: Tmem_flags; buffer_create_type: Tbuffer_create_type; buffer_create_info: pointer; errcode_ret: ptr TClResult): Pmem

createSubDevices:

• clwrap: proc createSubDevices(in_device: Pdevice_id; properties: ptr Tdevice_partition_property; num_devices: uint32; out_devices: ptr Pdevice_id; num_devices_ret: ptr uint32): TClResult

createUserEvent:

• clwrap: proc createUserEvent(context: Pcontext; errcode_ret: ptr TClResult): Pevent

dataBytes:

• lime: proc dataBytes(reader: LimeReader): int64

datacount:

• tensorio: proc datacount(reader: TensorFieldReader): int

DebugKernels:

• cldisp: const DebugKernels

defaultRecordInfo:

• scidac: proc defaultRecordInfo(precision: SciDACPrecision; colors: int = 3; spins: int = 0; typesize: int = 18; datacount: int = 4): SciDACRecordInfo

defaultSimdGrid:

• tensorview: proc defaultSimdGrid[D: static[int]](localGrid: array[D, int]): seq[int]
• tensorview: proc defaultSimdGrid(localGrid: seq[int]): seq[int]

DEPTH:

• clwrap: const DEPTH

DEPTH_STENCIL:

• clwrap: const DEPTH_STENCIL

device:

• clbase: template device()

DEVICE_ADDRESS_BITS:

• clwrap: const DEVICE_ADDRESS_BITS

DEVICE_AFFINITY_DOMAIN_L1_CACHE:

• clwrap: const DEVICE_AFFINITY_DOMAIN_L1_CACHE

DEVICE_AFFINITY_DOMAIN_L2_CACHE:

• clwrap: const DEVICE_AFFINITY_DOMAIN_L2_CACHE

DEVICE_AFFINITY_DOMAIN_L3_CACHE:

• clwrap: const DEVICE_AFFINITY_DOMAIN_L3_CACHE

DEVICE_AFFINITY_DOMAIN_L4_CACHE:

• clwrap: const DEVICE_AFFINITY_DOMAIN_L4_CACHE

DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE:

• clwrap: const DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE

DEVICE_AFFINITY_DOMAIN_NUMA:

• clwrap: const DEVICE_AFFINITY_DOMAIN_NUMA

DEVICE_AVAILABLE:

• clwrap: const DEVICE_AVAILABLE

DEVICE_BUILT_IN_KERNELS:

• clwrap: const DEVICE_BUILT_IN_KERNELS

DEVICE_COMPILER_AVAILABLE:

• clwrap: const DEVICE_COMPILER_AVAILABLE

DEVICE_DOUBLE_FP_CONFIG:

• clwrap: const DEVICE_DOUBLE_FP_CONFIG

DEVICE_ENDIAN_LITTLE:

• clwrap: const DEVICE_ENDIAN_LITTLE

DEVICE_ERROR_CORRECTION_SUPPORT:

• clwrap: const DEVICE_ERROR_CORRECTION_SUPPORT

DEVICE_EXECUTION_CAPABILITIES:

• clwrap: const DEVICE_EXECUTION_CAPABILITIES

DEVICE_EXTENSIONS:

• clwrap: const DEVICE_EXTENSIONS

DEVICE_GLOBAL_MEM_CACHELINE_SIZE:

• clwrap: const DEVICE_GLOBAL_MEM_CACHELINE_SIZE

DEVICE_GLOBAL_MEM_CACHE_SIZE:

• clwrap: const DEVICE_GLOBAL_MEM_CACHE_SIZE

DEVICE_GLOBAL_MEM_CACHE_TYPE:

• clwrap: const DEVICE_GLOBAL_MEM_CACHE_TYPE

DEVICE_GLOBAL_MEM_SIZE:

• clwrap: const DEVICE_GLOBAL_MEM_SIZE

DEVICE_HOST_UNIFIED_MEMORY:

• clwrap: const DEVICE_HOST_UNIFIED_MEMORY

DEVICE_IMAGE2D_MAX_HEIGHT:

• clwrap: const DEVICE_IMAGE2D_MAX_HEIGHT

DEVICE_IMAGE2D_MAX_WIDTH:

• clwrap: const DEVICE_IMAGE2D_MAX_WIDTH

DEVICE_IMAGE3D_MAX_DEPTH:

• clwrap: const DEVICE_IMAGE3D_MAX_DEPTH

DEVICE_IMAGE3D_MAX_HEIGHT:

• clwrap: const DEVICE_IMAGE3D_MAX_HEIGHT

DEVICE_IMAGE3D_MAX_WIDTH:

• clwrap: const DEVICE_IMAGE3D_MAX_WIDTH

DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT:

• clwrap: const DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT

DEVICE_IMAGE_MAX_ARRAY_SIZE:

• clwrap: const DEVICE_IMAGE_MAX_ARRAY_SIZE

DEVICE_IMAGE_MAX_BUFFER_SIZE:

• clwrap: const DEVICE_IMAGE_MAX_BUFFER_SIZE

DEVICE_IMAGE_PITCH_ALIGNMENT:

• clwrap: const DEVICE_IMAGE_PITCH_ALIGNMENT

DEVICE_IMAGE_SUPPORT:

• clwrap: const DEVICE_IMAGE_SUPPORT

DEVICE_LINKER_AVAILABLE:

• clwrap: const DEVICE_LINKER_AVAILABLE

DEVICE_LOCAL_MEM_SIZE:

• clwrap: const DEVICE_LOCAL_MEM_SIZE

DEVICE_LOCAL_MEM_TYPE:

• clwrap: const DEVICE_LOCAL_MEM_TYPE

DEVICE_MAX_CLOCK_FREQUENCY:

• clwrap: const DEVICE_MAX_CLOCK_FREQUENCY

DEVICE_MAX_COMPUTE_UNITS:

• clwrap: const DEVICE_MAX_COMPUTE_UNITS

DEVICE_MAX_CONSTANT_ARGS:

• clwrap: const DEVICE_MAX_CONSTANT_ARGS

DEVICE_MAX_CONSTANT_BUFFER_SIZE:

• clwrap: const DEVICE_MAX_CONSTANT_BUFFER_SIZE

DEVICE_MAX_MEM_ALLOC_SIZE:

• clwrap: const DEVICE_MAX_MEM_ALLOC_SIZE

DEVICE_MAX_PARAMETER_SIZE:

• clwrap: const DEVICE_MAX_PARAMETER_SIZE

DEVICE_MAX_READ_IMAGE_ARGS:

• clwrap: const DEVICE_MAX_READ_IMAGE_ARGS

DEVICE_MAX_SAMPLERS:

• clwrap: const DEVICE_MAX_SAMPLERS

DEVICE_MAX_WORK_GROUP_SIZE:

• clwrap: const DEVICE_MAX_WORK_GROUP_SIZE

DEVICE_MAX_WORK_ITEM_DIMENSIONS:

• clwrap: const DEVICE_MAX_WORK_ITEM_DIMENSIONS

DEVICE_MAX_WORK_ITEM_SIZES:

• clwrap: const DEVICE_MAX_WORK_ITEM_SIZES

DEVICE_MAX_WRITE_IMAGE_ARGS:

• clwrap: const DEVICE_MAX_WRITE_IMAGE_ARGS

DEVICE_MEM_BASE_ADDR_ALIGN:

• clwrap: const DEVICE_MEM_BASE_ADDR_ALIGN

DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:

• clwrap: const DEVICE_MIN_DATA_TYPE_ALIGN_SIZE

DEVICE_NAME:

• clwrap: const DEVICE_NAME

DEVICE_NATIVE_VECTOR_WIDTH_CHAR:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_CHAR

DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE

DEVICE_NATIVE_VECTOR_WIDTH_FLOAT:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_FLOAT

DEVICE_NATIVE_VECTOR_WIDTH_HALF:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_HALF

DEVICE_NATIVE_VECTOR_WIDTH_INT:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_INT

DEVICE_NATIVE_VECTOR_WIDTH_LONG:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_LONG

DEVICE_NATIVE_VECTOR_WIDTH_SHORT:

• clwrap: const DEVICE_NATIVE_VECTOR_WIDTH_SHORT

DEVICE_OPENCL_C_VERSION:

• clwrap: const DEVICE_OPENCL_C_VERSION

DEVICE_PARENT_DEVICE:

• clwrap: const DEVICE_PARENT_DEVICE

DEVICE_PARTITION_AFFINITY_DOMAIN:

• clwrap: const DEVICE_PARTITION_AFFINITY_DOMAIN

DEVICE_PARTITION_BY_AFFINITY_DOMAIN:

• clwrap: const DEVICE_PARTITION_BY_AFFINITY_DOMAIN

DEVICE_PARTITION_BY_COUNTS:

• clwrap: const DEVICE_PARTITION_BY_COUNTS

DEVICE_PARTITION_BY_COUNTS_LIST_END:

• clwrap: const DEVICE_PARTITION_BY_COUNTS_LIST_END

DEVICE_PARTITION_EQUALLY:

• clwrap: const DEVICE_PARTITION_EQUALLY

DEVICE_PARTITION_MAX_SUB_DEVICES:

• clwrap: const DEVICE_PARTITION_MAX_SUB_DEVICES

DEVICE_PARTITION_PROPERTIES:

• clwrap: const DEVICE_PARTITION_PROPERTIES

DEVICE_PARTITION_TYPE:

• clwrap: const DEVICE_PARTITION_TYPE

DEVICE_PLATFORM:

• clwrap: const DEVICE_PLATFORM

DEVICE_PREFERRED_INTEROP_USER_SYNC:

• clwrap: const DEVICE_PREFERRED_INTEROP_USER_SYNC

DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_CHAR

DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE

DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT

DEVICE_PREFERRED_VECTOR_WIDTH_HALF:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_HALF

DEVICE_PREFERRED_VECTOR_WIDTH_INT:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_INT

DEVICE_PREFERRED_VECTOR_WIDTH_LONG:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_LONG

DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:

• clwrap: const DEVICE_PREFERRED_VECTOR_WIDTH_SHORT

DEVICE_PRINTF_BUFFER_SIZE:

• clwrap: const DEVICE_PRINTF_BUFFER_SIZE

DEVICE_PROFILE:

• clwrap: const DEVICE_PROFILE

DEVICE_PROFILING_TIMER_RESOLUTION:

• clwrap: const DEVICE_PROFILING_TIMER_RESOLUTION

DEVICE_QUEUE_PROPERTIES:

• clwrap: const DEVICE_QUEUE_PROPERTIES

DEVICE_REFERENCE_COUNT:

• clwrap: const DEVICE_REFERENCE_COUNT

DEVICE_SINGLE_FP_CONFIG:

• clwrap: const DEVICE_SINGLE_FP_CONFIG

DeviceStorage:

• tensorview: object DeviceStorage

DEVICE_TYPE:

• clwrap: const DEVICE_TYPE

DEVICE_TYPE_ACCELERATOR:

• clwrap: const DEVICE_TYPE_ACCELERATOR

DEVICE_TYPE_ALL:

• clwrap: const DEVICE_TYPE_ALL

DEVICE_TYPE_CPU:

• clwrap: const DEVICE_TYPE_CPU

DEVICE_TYPE_CUSTOM:

• clwrap: const DEVICE_TYPE_CUSTOM

DEVICE_TYPE_DEFAULT:

• clwrap: const DEVICE_TYPE_DEFAULT

DEVICE_TYPE_GPU:

• clwrap: const DEVICE_TYPE_GPU

DEVICE_VENDOR:

• clwrap: const DEVICE_VENDOR

DEVICE_VENDOR_ID:

• clwrap: const DEVICE_VENDOR_ID

DEVICE_VERSION:

• clwrap: const DEVICE_VERSION

Dim:

• clbase: type Dim

dims:

• qio: proc dims[T](r: QIOFieldReader[T]): seq[int]
• tensorio: proc dims(reader: TensorFieldReader): seq[int]

Direction:

• stencil: type Direction

directions:

• stencil: iterator directions(nDim: int): Direction

discreteLaplacian:

• globaltensor: proc discreteLaplacian[D: static[int]; R: static[int]; L: Lattice[D]; T]( src: TensorField[D, R, L, T]; dest: var TensorField[D, R, L, T]; scratch: var TensorField[D, R, L, T])

dot:

• sitetensor: proc dot[N: static[int]; T](a, b: Vec[N, T]): T

DRIVER_VERSION:

• clwrap: const DRIVER_VERSION

dumpContents:

• lime: proc dumpContents(filename: string)

each:

• cldisp: macro each(x: ForLoopStmt): untyped

eachImpl:

• cldisp: macro eachImpl(loopVar: untyped; lo: typed; hi: typed; body: typed): untyped

elementsPerSite:

• tensorview: proc elementsPerSite[L, T](view: TensorFieldView[L, T]): int

ElementType:

• cldisp: enum ElementType

elementType:

• sitetensor: template elementType[N: static[int]; M: static[int]; T](m: typedesc[Mat[N, M, T]]): typedesc
• sitetensor: template elementType[N: static[int]; T](v: typedesc[Vec[N, T]]): typedesc

enqueueBarrier:

• clwrap: proc enqueueBarrier(command_queue: Pcommand_queue): TClResult

enqueueBarrierWithWaitList:

• clwrap: proc enqueueBarrierWithWaitList(command_queue: Pcommand_queue; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueCopyBuffer:

• clwrap: proc enqueueCopyBuffer(command_queue: Pcommand_queue; src_buffer: Pmem; dst_buffer: Pmem; src_offset: int; dst_offset: int; size: int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueCopyBufferRect:

• clwrap: proc enqueueCopyBufferRect(command_queue: Pcommand_queue; src_buffer: Pmem; dst_buffer: Pmem; src_origin: ptr int; dst_origin: ptr int; region: ptr int; src_row_pitch: int; src_slice_pitch: int; dst_row_pitch: int; dst_slice_pitch: int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueCopyBufferToImage:

• clwrap: proc enqueueCopyBufferToImage(command_queue: Pcommand_queue; src_buffer: Pmem; dst_image: Pmem; src_offset: int; dst_origin: array[3, ptr int]; region: array[3, ptr int]; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueCopyImage:

• clwrap: proc enqueueCopyImage(command_queue: Pcommand_queue; src_image: Pmem; dst_image: Pmem; src_origin: array[3, ptr int]; dst_origin: array[3, ptr int]; region: array[3, ptr int]; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueCopyImageToBuffer:

• clwrap: proc enqueueCopyImageToBuffer(command_queue: Pcommand_queue; src_image: Pmem; dst_buffer: Pmem; src_origin: array[3, ptr int]; region: array[3, ptr int]; dst_offset: int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueFillBuffer:

• clwrap: proc enqueueFillBuffer(command_queue: Pcommand_queue; buffer: Pmem; pattern: pointer; pattern_size: int; offset: int; size: int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueFillImage:

• clwrap: proc enqueueFillImage(command_queue: Pcommand_queue; image: Pmem; fill_color: pointer; origin: array[3, ptr int]; region: array[3, ptr int]; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueMapBuffer:

• clwrap: proc enqueueMapBuffer(command_queue: Pcommand_queue; buffer: Pmem; blocking_map: Tbool; map_flags: Tmap_flags; offset: int; size: int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent; errcode_ret: ptr TClResult): pointer

enqueueMapImage:

• clwrap: proc enqueueMapImage(command_queue: Pcommand_queue; image: Pmem; blocking_map: Tbool; map_flags: Tmap_flags; origin: array[3, ptr int]; region: array[3, ptr int]; image_row_pitch: ptr int; image_slice_pitch: ptr int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent; errcode_ret: ptr TClResult): pointer

enqueueMarker:

• clwrap: proc enqueueMarker(command_queue: Pcommand_queue; event: ptr Pevent): TClResult

enqueueMarkerWithWaitList:

• clwrap: proc enqueueMarkerWithWaitList(command_queue: Pcommand_queue; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueMigrateMemObjects:

• clwrap: proc enqueueMigrateMemObjects(command_queue: Pcommand_queue; num_mem_objects: uint32; mem_objects: ptr Pmem; flags: Tmem_migration_flags; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueNativeKernel:

• clwrap: proc enqueueNativeKernel(command_queue: Pcommand_queue; user_func: TUserCb; args: pointer; cb_args: int; num_mem_objects: uint32; mem_list: ptr Pmem; args_mem_loc: ptr pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueNDRangeKernel:

• clwrap: proc enqueueNDRangeKernel(command_queue: Pcommand_queue; kernel: Pkernel; work_dim: uint32; global_work_offset: ptr int; global_work_size: ptr int; local_work_size: ptr int; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueReadBuffer:

• clwrap: proc enqueueReadBuffer(command_queue: Pcommand_queue; buffer: Pmem; blocking_read: Tbool; offset: int; size: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueReadBufferRect:

• clwrap: proc enqueueReadBufferRect(command_queue: Pcommand_queue; buffer: Pmem; blocking_read: Tbool; buffer_offset: ptr int; host_offset: ptr int; region: ptr int; buffer_row_pitch: int; buffer_slice_pitch: int; host_row_pitch: int; host_slice_pitch: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueReadImage:

• clwrap: proc enqueueReadImage(command_queue: Pcommand_queue; image: Pmem; blocking_read: Tbool; origin: array[3, ptr int]; region: array[3, ptr int]; row_pitch: int; slice_pitch: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueTask:

• clwrap: proc enqueueTask(command_queue: Pcommand_queue; kernel: Pkernel; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueUnmapMemObject:

• clwrap: proc enqueueUnmapMemObject(command_queue: Pcommand_queue; memobj: Pmem; mapped_ptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueWaitForEvents:

• clwrap: proc enqueueWaitForEvents(command_queue: Pcommand_queue; num_events: uint32; event_list: ptr Pevent): TClResult

enqueueWriteBuffer:

• clwrap: proc enqueueWriteBuffer(command_queue: Pcommand_queue; buffer: Pmem; blocking_write: Tbool; offset: int; size: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueWriteBufferRect:

• clwrap: proc enqueueWriteBufferRect(command_queue: Pcommand_queue; buffer: Pmem; blocking_write: Tbool; buffer_offset: ptr int; host_offset: ptr int; region: ptr int; buffer_row_pitch: int; buffer_slice_pitch: int; host_row_pitch: int; host_slice_pitch: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

enqueueWriteImage:

• clwrap: proc enqueueWriteImage(command_queue: Pcommand_queue; image: Pmem; blocking_write: Tbool; origin: array[3, ptr int]; region: array[3, ptr int]; input_row_pitch: int; input_slice_pitch: int; theptr: pointer; num_events_in_wait_list: uint32; event_wait_list: ptr Pevent; event: ptr Pevent): TClResult

EOpenCL:

• clwrap: object EOpenCL

etFloat32:

• cldisp: ElementType.etFloat32

etFloat64:

• cldisp: ElementType.etFloat64

etInt32:

• cldisp: ElementType.etInt32

etInt64:

• cldisp: ElementType.etInt64

evenOddIndex:

• qio: proc evenOddIndex(coords: openArray[int]; dims: openArray[int]): int

EVENT_COMMAND_EXECUTION_STATUS:

• clwrap: const EVENT_COMMAND_EXECUTION_STATUS

EVENT_COMMAND_QUEUE:

• clwrap: const EVENT_COMMAND_QUEUE

EVENT_COMMAND_TYPE:

• clwrap: const EVENT_COMMAND_TYPE

EVENT_CONTEXT:

• clwrap: const EVENT_CONTEXT

EVENT_REFERENCE_COUNT:

• clwrap: const EVENT_REFERENCE_COUNT

EXEC_KERNEL:

• clwrap: const EXEC_KERNEL

EXEC_NATIVE_KERNEL:

• clwrap: const EXEC_NATIVE_KERNEL

exp:

• clbase: proc exp(x: float32): float32

exp2:

• clbase: proc exp2(x: float32): float32

fabs:

• clbase: proc fabs(x: float32): float32

FILTER_LINEAR:

• clwrap: const FILTER_LINEAR

FILTER_NEAREST:

• clwrap: const FILTER_NEAREST

finalizeCL:

• clbase: template finalizeCL(): untyped

finalizeGA:

• gabase: proc finalizeGA()

finalizeMPI:

• gampi: proc finalizeMPI(): cint

finish:

• clwrap: proc finish(command_queue: Pcommand_queue): TClResult

firstPlatform:

• clbase: proc firstPlatform(): Pplatform_id

floor:

• clbase: proc floor(x: float32): float32

flush:

• clwrap: proc flush(command_queue: Pcommand_queue): TClResult

fma:

• clbase: proc fma(a, b, c: float32): float32

fmax:

• clbase: proc fmax(x, y: float32): float32

fmin:

• clbase: proc fmin(x, y: float32): float32

fmod:

• clbase: proc fmod(x, y: float32): float32

forEachNeighbor:

• stencil: template forEachNeighbor[D: static int](s: LatticeStencil[D]; site: int; pointVar, nbrVar: untyped; body: untyped)

formatSiteData:

• tensorview: proc formatSiteData[L, T](view: TensorFieldView[L, T]; site: int): string

forward:

• stencil: proc forward(d: Direction): SignedDirection

forwardStencil:

• stencil: proc forwardStencil[D: static int](): StencilPattern[D]
• stencil: proc forwardStencil[D: static int; L: Lattice[D]](lat: L): StencilPattern[D]

FP_CORRECTLY_ROUNDED_DIVIDE_SQRT:

• clwrap: const FP_CORRECTLY_ROUNDED_DIVIDE_SQRT

FP_DENORM:

• clwrap: const FP_DENORM

FP_FMA:

• clwrap: const FP_FMA

FP_INF_NAN:

• clwrap: const FP_INF_NAN

FP_ROUND_TO_INF:

• clwrap: const FP_ROUND_TO_INF

FP_ROUND_TO_NEAREST:

• clwrap: const FP_ROUND_TO_NEAREST

FP_ROUND_TO_ZERO:

• clwrap: const FP_ROUND_TO_ZERO

FP_SOFT_FLOAT:

• clwrap: const FP_SOFT_FLOAT

fwd:

• stencil: proc fwd(dir: int): PathStep
• stencil: proc fwd[D: static int](s: LatticeStencil[D]; site: int; dir: int): StencilShift[D]

GA_Allocate:

• gawrap: proc GA_Allocate(g_a: cint): cint

GA_Brdcst:

• gawrap: proc GA_Brdcst(buf: pointer; n: cint; root: cint)

GA_Copy:

• gawrap: proc GA_Copy(g_a: cint; g_b: cint)

GA_Create_handle:

• gawrap: proc GA_Create_handle(): cint

GA_Destroy:

• gawrap: proc GA_Destroy(g_a: cint)

GA_Dgop:

• gawrap: proc GA_Dgop(x: ptr float64; n: cint; op: cstring)

GA_Fence:

• gawrap: proc GA_Fence()

GA_Fgop:

• gawrap: proc GA_Fgop(x: ptr float32; n: cint; op: cstring)

GA_Igop:

• gawrap: proc GA_Igop(x: ptr int32; n: cint; op: cstring)

GA_Init_fence:

• gawrap: proc GA_Init_fence()

GA_Lgop:

• gawrap: proc GA_Lgop(x: ptr int64; n: cint; op: cstring)

GA_Nnodes:

• gawrap: proc GA_Nnodes(): cint

GA_Nodeid:

• gawrap: proc GA_Nodeid(): cint

gaParallel:

• globalarrays: template gaParallel(body: untyped): untyped

GA_Set_chunk:

• gawrap: proc GA_Set_chunk(g_a: cint; chunk_dims: ptr cint)

GA_Set_data:

• gawrap: proc GA_Set_data(g_a: cint; array_ndim: cint; array_dims: ptr cint; data_type: cint)

GA_Set_ghosts:

• gawrap: proc GA_Set_ghosts(g_a: cint; widths: ptr cint)

GA_Set_name:

• gawrap: proc GA_Set_name(g_a: cint; name: ptr cchar)

GA_Sync:

• gawrap: proc GA_Sync()

GaugeField:

• qio: object GaugeField

GA_Update_ghost_dir:

• gawrap: proc GA_Update_ghost_dir(g_a: cint; dir: cint; side: cint; update_corners: cint)

GA_Update_ghosts:

• gawrap: proc GA_Update_ghosts(g_a: cint)

generateChecksumXml:

• scidac: proc generateChecksumXml(cs: SciDACChecksum): string

generateCoordTable:

• simdlayout: proc generateCoordTable(layout: SimdLatticeLayout): seq[seq[int]]

generateFileXml:

• scidac: proc generateFileXml(info: SciDACFileInfo): string

generateILDGFormatXml:

• scidac: proc generateILDGFormatXml(info: ILDGFormatInfo): string

generateRecordXml:

• scidac: proc generateRecordXml(info: SciDACRecordInfo): string

generateUserXml:

• scidac: proc generateUserXml(info: SciDACUserInfo): string

getBounds:

• gatypes: proc getBounds[D: static[int]; T](ga: GlobalArray[D, T]): (array[D, int], array[D, int])

getCommandQueueInfo:

• clwrap: proc getCommandQueueInfo(command_queue: Pcommand_queue; param_name: Tcommand_queue_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getContextInfo:

• clwrap: proc getContextInfo(context: Pcontext; param_name: Tcontext_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getDeviceIDs:

• clwrap: proc getDeviceIDs(platform: Pplatform_id; device_type: TDeviceType; num_entries: uint32; devices: ptr Pdevice_id; num_devices: ptr uint32): TClResult

getDeviceInfo:

• clwrap: proc getDeviceInfo(device: Pdevice_id; param_name: Tdevice_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getDevices:

• clbase: proc getDevices(platform: Pplatform_id): seq[Pdevice_id]

getEntry:

• stencil: proc getEntry[D: static int](sv: StencilView[D]; site, point: int): StencilEntry

getEventInfo:

• clwrap: proc getEventInfo(event: Pevent; param_name: Tevent_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getEventProfilingInfo:

• clwrap: proc getEventProfilingInfo(event: Pevent; param_name: Tprofiling_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getExtensionFunctionAddress:

• clwrap: proc getExtensionFunctionAddress(func_name: cstring): pointer

getExtensionFunctionAddressForPlatform:

• clwrap: proc getExtensionFunctionAddressForPlatform(platform: Pplatform_id; func_name: cstring): pointer

getGhostGrid:

• gatypes: proc getGhostGrid[D: static[int]; T](ga: GlobalArray[D, T]): array[D, int]

getGlobalGrid:

• gatypes: proc getGlobalGrid[D: static[int]; T](ga: GlobalArray[D, T]): array[D, int]

get_global_id:

• clbase: template get_global_id(dim: Dim): Dim

get_global_offset:

• clbase: template get_global_offset(dim: Dim): Dim

get_global_size:

• clbase: template get_global_size(dim: Dim): Dim

get_group_id:

• clbase: template get_group_id(dim: Dim): Dim

getHandle:

• gatypes: proc getHandle[D: static[int]; T](ga: GlobalArray[D, T]): cint

getImageInfo:

• clwrap: proc getImageInfo(image: Pmem; param_name: Timage_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getKernelArgInfo:

• clwrap: proc getKernelArgInfo(kernel: Pkernel; arg_indx: uint32; param_name: Tkernel_arg_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getKernelInfo:

• clwrap: proc getKernelInfo(kernel: Pkernel; param_name: Tkernel_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getKernelWorkGroupInfo:

• clwrap: proc getKernelWorkGroupInfo(kernel: Pkernel; device: Pdevice_id; param_name: Tkernel_work_group_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getLocalGrid:

• gatypes: proc getLocalGrid[D: static[int]; T](ga: GlobalArray[D, T]): array[D, int]

get_local_id:

• clbase: template get_local_id(dim: Dim): Dim

get_local_size:

• clbase: template get_local_size(dim: Dim): Dim

getMemObjectInfo:

• clwrap: proc getMemObjectInfo(memobj: Pmem; param_name: Tmem_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getMPIGrid:

• gatypes: proc getMPIGrid[D: static[int]; T](ga: GlobalArray[D, T]): array[D, int]

get_num_groups:

• clbase: template get_num_groups(dim: Dim): Dim

getNumThreads:

• ompbase: proc getNumThreads(): int

getOffsetBuffer:

• stencil: proc getOffsetBuffer[D: static int](s: LatticeStencil[D]): ptr int32

getPlatformByName:

• clbase: proc getPlatformByName(platformName: string): Pplatform_id

getPlatformIDs:

• clwrap: proc getPlatformIDs(num_entries: uint32; platforms: ptr Pplatform_id; num_platforms: ptr uint32): TClResult

getPlatformInfo:

• clwrap: proc getPlatformInfo(platform: Pplatform_id; param_name: Tplatform_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getPosition:

• lime: proc getPosition(reader: LimeReader): int64

getProgramBuildInfo:

• clwrap: proc getProgramBuildInfo(program: Pprogram; device: Pdevice_id; param_name: Tprogram_build_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getProgramInfo:

• clwrap: proc getProgramInfo(program: Pprogram; param_name: Tprogram_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getSamplerInfo:

• clwrap: proc getSamplerInfo(sampler: Psampler; param_name: Tsampler_info; param_value_size: int; param_value: pointer; param_value_size_ret: ptr int): TClResult

getSite:

• localtensor: proc getSite[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: LocalTensorField[D, R, L, T]; site: int): LocalSiteProxy[D, R, L, T]

getSupportedImageFormats:

• clwrap: proc getSupportedImageFormats(context: Pcontext; flags: Tmem_flags; image_type: Tmem_object_type; num_entries: uint32; image_formats: ptr Timage_format; num_image_formats: ptr uint32): TClResult

getThreadId:

• ompbase: proc getThreadId(): int

get_work_dim:

• clbase: template get_work_dim(): Dim

ghostWidth:

• globaltensor: proc ghostWidth[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): array[D, int]

global:

• clbase: template global()

GLOBAL:

• clwrap: const GLOBAL

GlobalArray:

• gatypes: object GlobalArray

GlobalArrays:

• gabase: template GlobalArrays(body: untyped): untyped

globalLexCoords:

• tensorio: proc globalLexCoords[D: static[int]](index: int; dims: array[D, int]): array[D, int]

globalLexIndex:

• tensorio: proc globalLexIndex[D: static[int]](coords: array[D, int]; dims: array[D, int]): int

globalMemory:

• clbase: proc globalMemory(id: Pdevice_id): uint64

GlobalShifter:

• globaltensor: object GlobalShifter

GpuBuffer:

• clbase: object GpuBuffer

gpuBuffer:

• clbase: proc gpuBuffer[T](context: Pcontext; size: int; flags: Tmem_flags = MEM_READ_WRITE): GpuBuffer[ T]

gpuBufferLike:

• clbase: proc gpuBufferLike[T](context: Pcontext; xs: openArray[T]; flags: Tmem_flags = MEM_READ_WRITE): GpuBuffer[T]

hasEchoStatement:

• omplocal: proc hasEchoStatement(node: NimNode): bool

hasGhosts:

• globaltensor: proc hasGhosts[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): bool

hash:

• stencil: proc hash(d: Direction): int

hasSimdLayout:

• tensorview: proc hasSimdLayout[L, T](view: TensorFieldView[L, T]): bool

header:

• lime: proc header(reader: LimeReader): LimeRecordHeader

HostStorage:

• localtensor: type HostStorage

identity:

• sitetensor: proc identity[N: static[int]; T](): Mat[N, N, T]

idx:

• stencil: proc idx(sh: StencilShift): int

ILDGBinaryData:

• scidac: const ILDGBinaryData

ILDGDataLFN:

• scidac: const ILDGDataLFN

ILDGFormat:

• scidac: const ILDGFormat

ILDGFormatInfo:

• scidac: object ILDGFormatInfo

ILDGReader:

• scidac: type ILDGReader

IMAGE_ARRAY_SIZE:

• clwrap: const IMAGE_ARRAY_SIZE

IMAGE_BUFFER:

• clwrap: const IMAGE_BUFFER

IMAGE_DEPTH:

• clwrap: const IMAGE_DEPTH

IMAGE_ELEMENT_SIZE:

• clwrap: const IMAGE_ELEMENT_SIZE

IMAGE_FORMAT:

• clwrap: const IMAGE_FORMAT

IMAGE_HEIGHT:

• clwrap: const IMAGE_HEIGHT

IMAGE_NUM_MIP_LEVELS:

• clwrap: const IMAGE_NUM_MIP_LEVELS

IMAGE_NUM_SAMPLES:

• clwrap: const IMAGE_NUM_SAMPLES

IMAGE_ROW_PITCH:

• clwrap: const IMAGE_ROW_PITCH

IMAGE_SLICE_PITCH:

• clwrap: const IMAGE_SLICE_PITCH

IMAGE_WIDTH:

• clwrap: const IMAGE_WIDTH

initChecksum:

• qio: proc initChecksum(): QIOChecksum

initCL:

• clbase: template initCL(): untyped

initGA:

• gabase: proc initGA()
• gabase: proc initGA(argc: ptr cint; argv: ptr cstringArray)

initMPI:

• gampi: proc initMPI(argc: ptr cint; argv: ptr cstringArray): cint

initOpenMP:

• ompbase: proc initOpenMP()

initSciDACChecksum:

• scidac: proc initSciDACChecksum(): SciDACChecksum

innerBlockSize:

• globaltensor: proc innerBlockSize(R: static int; shape: openArray[int]; isComplex: bool): int

innerPaddedBlockSize:

• globaltensor: proc innerPaddedBlockSize(R: static int; ghostWidth: int): int

innerPaddedOffset:

• globaltensor: proc innerPaddedOffset(R: static int; ghostWidth: int): int

INTENSITY:

• clwrap: const INTENSITY

IOKind:

• tensorview: enum IOKind

iokRead:

• tensorview: IOKind.iokRead

iokReadWrite:

• tensorview: IOKind.iokReadWrite

iokWrite:

• tensorview: IOKind.iokWrite

isComplex:

• complex: template isComplex(T: typedesc): bool

isComplex32:

• complex: template isComplex32(T: typedesc): bool

isComplex64:

• complex: template isComplex64(T: typedesc): bool

isGhostNeighbor:

• stencil: proc isGhostNeighbor[D: static int](s: LatticeStencil[D]; site, point: int): bool

isInitialized:

• gatypes: proc isInitialized[D: static[int]; T](ga: GlobalArray[D, T]): bool

isMat:

• sitetensor: template isMat(T: typedesc): bool

isReal32:

• complex: template isReal32(T: typedesc): bool

isReal64:

• complex: template isReal64(T: typedesc): bool

isSiteTensor:

• sitetensor: template isSiteTensor(T: typedesc): bool

isVec:

• sitetensor: template isVec(T: typedesc): bool

kernel:

• clbase: template kernel()

KERNEL_ARG_ACCESS_NONE:

• clwrap: const KERNEL_ARG_ACCESS_NONE

KERNEL_ARG_ACCESS_QUALIFIER:

• clwrap: const KERNEL_ARG_ACCESS_QUALIFIER

KERNEL_ARG_ACCESS_READ_ONLY:

• clwrap: const KERNEL_ARG_ACCESS_READ_ONLY

KERNEL_ARG_ACCESS_READ_WRITE:

• clwrap: const KERNEL_ARG_ACCESS_READ_WRITE

KERNEL_ARG_ACCESS_WRITE_ONLY:

• clwrap: const KERNEL_ARG_ACCESS_WRITE_ONLY

KERNEL_ARG_ADDRESS_CONSTANT:

• clwrap: const KERNEL_ARG_ADDRESS_CONSTANT

KERNEL_ARG_ADDRESS_GLOBAL:

• clwrap: const KERNEL_ARG_ADDRESS_GLOBAL

KERNEL_ARG_ADDRESS_LOCAL:

• clwrap: const KERNEL_ARG_ADDRESS_LOCAL

KERNEL_ARG_ADDRESS_PRIVATE:

• clwrap: const KERNEL_ARG_ADDRESS_PRIVATE

KERNEL_ARG_ADDRESS_QUALIFIER:

• clwrap: const KERNEL_ARG_ADDRESS_QUALIFIER

KERNEL_ARG_NAME:

• clwrap: const KERNEL_ARG_NAME

KERNEL_ARG_TYPE_CONST:

• clwrap: const KERNEL_ARG_TYPE_CONST

KERNEL_ARG_TYPE_NAME:

• clwrap: const KERNEL_ARG_TYPE_NAME

KERNEL_ARG_TYPE_NONE:

• clwrap: const KERNEL_ARG_TYPE_NONE

KERNEL_ARG_TYPE_QUALIFIER:

• clwrap: const KERNEL_ARG_TYPE_QUALIFIER

KERNEL_ARG_TYPE_RESTRICT:

• clwrap: const KERNEL_ARG_TYPE_RESTRICT

KERNEL_ARG_TYPE_VOLATILE:

• clwrap: const KERNEL_ARG_TYPE_VOLATILE

KERNEL_ATTRIBUTES:

• clwrap: const KERNEL_ATTRIBUTES

KERNEL_COMPILE_WORK_GROUP_SIZE:

• clwrap: const KERNEL_COMPILE_WORK_GROUP_SIZE

KERNEL_CONTEXT:

• clwrap: const KERNEL_CONTEXT

KERNEL_FUNCTION_NAME:

• clwrap: const KERNEL_FUNCTION_NAME

KERNEL_GLOBAL_WORK_SIZE:

• clwrap: const KERNEL_GLOBAL_WORK_SIZE

KERNEL_LOCAL_MEM_SIZE:

• clwrap: const KERNEL_LOCAL_MEM_SIZE

KERNEL_NUM_ARGS:

• clwrap: const KERNEL_NUM_ARGS

KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:

• clwrap: const KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE

KERNEL_PRIVATE_MEM_SIZE:

• clwrap: const KERNEL_PRIVATE_MEM_SIZE

KERNEL_PROGRAM:

• clwrap: const KERNEL_PROGRAM

KERNEL_REFERENCE_COUNT:

• clwrap: const KERNEL_REFERENCE_COUNT

KERNEL_WORK_GROUP_SIZE:

• clwrap: const KERNEL_WORK_GROUP_SIZE

laplacianStencil:

• stencil: proc laplacianStencil[D: static int](): StencilPattern[D]
• stencil: proc laplacianStencil[D: static int; L: Lattice[D]](lat: L): StencilPattern[D]

Lattice:

• latticeconcept: type Lattice

LatticeStencil:

• stencil: object LatticeStencil

lexCoords:

• qio: proc lexCoords(index: int; dims: openArray[int]): seq[int]

lexicographicToCoords:

• simdlayout: proc lexicographicToCoords(idx: int; strides: seq[int]; geom: seq[int]): seq[int]

lexIndex:

• qio: proc lexIndex(coords: openArray[int]; dims: openArray[int]): int

lexToCoords:

• globaltensor: proc lexToCoords[D: static int](idx: int; geom: array[D, int]): array[D, int]

LimeHeaderSize:

• lime: const LimeHeaderSize

LimeMagicNumber:

• lime: const LimeMagicNumber

LimeReader:

• lime: type LimeReader

LimeRecordHeader:

• lime: object LimeRecordHeader

LimeStatus:

• lime: enum LimeStatus

limeType:

• lime: proc limeType(reader: LimeReader): string

LimeTypeMaxLen:

• lime: const LimeTypeMaxLen

LimeVersion:

• lime: const LimeVersion

LimeWriter:

• lime: type LimeWriter

linkProgram:

• clwrap: proc linkProgram(context: Pcontext; num_devices: uint32; device_list: ptr Pdevice_id; options: cstring; num_input_programs: uint32; input_programs: ptr Pprogram; pfn_notify: TProgramCb; user_data: pointer; errcode_ret: ptr TClResult): Pprogram

loadBinaryData:

• tensorio: proc loadBinaryData(reader: TensorFieldReader; validate: bool = true)

local:

• clbase: template local()

LOCAL:

• clwrap: const LOCAL

LocalAddResult:

• sitetensor: object LocalAddResult

LocalBuffer:

• clbase: type LocalBuffer

localGrid:

• globaltensor: proc localGrid[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): array[D, int]

localIdx:

• globaltensor: proc localIdx[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; coords: array[D, int]): int

localIndices:

• gawrap: proc localIndices[D: static[int]](handle: cint; lo, hi: var array[D, cint])

localLexIdx:

• globaltensor: proc localLexIdx[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; site: int): int

localMemory:

• clbase: proc localMemory(id: Pdevice_id): uint64

LocalMulResult:

• sitetensor: object LocalMulResult

LocalScalarAddResult:

• sitetensor: object LocalScalarAddResult

LocalScalarMulResult:

• sitetensor: object LocalScalarMulResult

localSiteOffset:

• globaltensor: proc localSiteOffset[D: static int](coords: array[D, int]; paddedGeom: array[D, int]; innerBlockSize: int): int

LocalSiteProxy:

• sitetensor: object LocalSiteProxy

LocalTensorField:

• localtensor: object LocalTensorField

localToOuterInner:

• simdlayout: proc localToOuterInner(localIdx: int; layout: SimdLatticeLayout): tuple[ outer, inner: int]

localToPadded:

• stencil: proc localToPadded[D: static int](localSite: int; localGeom: array[D, int]; ghostWidth: array[D, int]): int
• stencil: proc localToPadded[D: static int](s: LatticeStencil[D]; localSite: int): int

log:

• clbase: proc log(x: float32): float32

log10:

• clbase: proc log10(x: float32): float32

log2:

• clbase: proc log2(x: float32): float32

lsEndOfFile:

• lime: LimeStatus.lsEndOfFile

lsEndOfRecord:

• lime: LimeStatus.lsEndOfRecord

lsErrClose:

• lime: LimeStatus.lsErrClose

lsErrHeaderNext:

• lime: LimeStatus.lsErrHeaderNext

lsErrMagic:

• lime: LimeStatus.lsErrMagic

lsErrMbMe:

• lime: LimeStatus.lsErrMbMe

lsErrParam:

• lime: LimeStatus.lsErrParam

lsErrRead:

• lime: LimeStatus.lsErrRead

lsErrSeek:

• lime: LimeStatus.lsErrSeek

lsErrVersion:

• lime: LimeStatus.lsErrVersion

lsErrWrite:

• lime: LimeStatus.lsErrWrite

lsSuccess:

• lime: LimeStatus.lsSuccess

LUMINANCE:

• clwrap: const LUMINANCE

MAP_READ:

• clwrap: const MAP_READ

mapTo:

• private: proc mapTo[D: static[int]; T, U](arr: array[D, T]; targetType: typedesc[U]): array[D, U]

MAP_WRITE:

• clwrap: const MAP_WRITE

MAP_WRITE_INVALIDATE_REGION:

• clwrap: const MAP_WRITE_INVALIDATE_REGION

Mat:

• sitetensor: object Mat

Mat2:

• sitetensor: type Mat2

Mat2d:

• sitetensor: type Mat2d

Mat2f:

• sitetensor: type Mat2f

Mat3:

• sitetensor: type Mat3

Mat3d:

• sitetensor: type Mat3d

Mat3f:

• sitetensor: type Mat3f

Mat4:

• sitetensor: type Mat4

Mat4d:

• sitetensor: type Mat4d

Mat4f:

• sitetensor: type Mat4f

matadd:

• tensorview: proc matadd[L, T](a, b: TensorFieldView[L, T]; site: int): MatAddResult[L, T]

MatAddResult:

• sitetensor: object MatAddResult

matCols:

• sitetensor: template matCols[N: static[int]; M: static[int]; T](m: typedesc[Mat[N, M, T]]): int

matmul:

• tensorview: proc matmul[L, T](a, b: TensorFieldView[L, T]; site: int): MatMulResult[L, T]

MatMulResult:

• sitetensor: object MatMulResult

matRows:

• sitetensor: template matRows[N: static[int]; M: static[int]; T](m: typedesc[Mat[N, M, T]]): int

matvec:

• tensorview: proc matvec[L, T](mat, vec: TensorFieldView[L, T]; site: int): MatVecResult[L, T]

MatVecResult:

• sitetensor: object MatVecResult

maxWorkGroups:

• clbase: proc maxWorkGroups(id: Pdevice_id): int

maxWorkItems:

• clbase: proc maxWorkItems(id: Pdevice_id): seq[int]

mbFlag:

• lime: proc mbFlag(reader: LimeReader): bool

meFlag:

• lime: proc meFlag(reader: LimeReader): bool

MEM_ALLOC_HOST_PTR:

• clwrap: const MEM_ALLOC_HOST_PTR

MEM_ASSOCIATED_MEMOBJECT:

• clwrap: const MEM_ASSOCIATED_MEMOBJECT

MEM_CONTEXT:

• clwrap: const MEM_CONTEXT

MEM_COPY_HOST_PTR:

• clwrap: const MEM_COPY_HOST_PTR

mem_fence:

• clbase: template mem_fence(flags: cint)

mem_fence_impl:

• clbase: proc mem_fence_impl(flags: cint)

MEM_FLAGS:

• clwrap: const MEM_FLAGS

MEM_HOST_NO_ACCESS:

• clwrap: const MEM_HOST_NO_ACCESS

MEM_HOST_PTR:

• clwrap: const MEM_HOST_PTR

MEM_HOST_READ_ONLY:

• clwrap: const MEM_HOST_READ_ONLY

MEM_HOST_WRITE_ONLY:

• clwrap: const MEM_HOST_WRITE_ONLY

MEM_MAP_COUNT:

• clwrap: const MEM_MAP_COUNT

MEM_OBJECT_BUFFER:

• clwrap: const MEM_OBJECT_BUFFER

MEM_OBJECT_IMAGE1D:

• clwrap: const MEM_OBJECT_IMAGE1D

MEM_OBJECT_IMAGE1D_ARRAY:

• clwrap: const MEM_OBJECT_IMAGE1D_ARRAY

MEM_OBJECT_IMAGE1D_BUFFER:

• clwrap: const MEM_OBJECT_IMAGE1D_BUFFER

MEM_OBJECT_IMAGE2D:

• clwrap: const MEM_OBJECT_IMAGE2D

MEM_OBJECT_IMAGE2D_ARRAY:

• clwrap: const MEM_OBJECT_IMAGE2D_ARRAY

MEM_OBJECT_IMAGE3D:

• clwrap: const MEM_OBJECT_IMAGE3D

MEM_OFFSET:

• clwrap: const MEM_OFFSET

MEM_READ_ONLY:

• clwrap: const MEM_READ_ONLY

MEM_READ_WRITE:

• clwrap: const MEM_READ_WRITE

MEM_REFERENCE_COUNT:

• clwrap: const MEM_REFERENCE_COUNT

MEM_SIZE:

• clwrap: const MEM_SIZE

MEM_TYPE:

• clwrap: const MEM_TYPE

MEM_USE_HOST_PTR:

• clwrap: const MEM_USE_HOST_PTR

MEM_WRITE_ONLY:

• clwrap: const MEM_WRITE_ONLY

messages:

• scidac: iterator messages(r: SciDACReader): tuple[recordInfo: SciDACRecordInfo, userXml: string, checksum: SciDACChecksum]

MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED:

• clwrap: const MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED

MIGRATE_MEM_OBJECT_HOST:

• clwrap: const MIGRATE_MEM_OBJECT_HOST

MPI_Allreduce:

• gampi: proc MPI_Allreduce(sendbuf: pointer; recvbuf: pointer; count: cint; datatype: cint; op: cint; comm: cint): cint

MPI_COMM_WORLD:

• gampi: var MPI_COMM_WORLD

MPI_DOUBLE:

• gampi: var MPI_DOUBLE

MPI_FLOAT:

• gampi: var MPI_FLOAT

MPI_INT:

• gampi: var MPI_INT

MPI_LONG_LONG:

• gampi: var MPI_LONG_LONG

MPI_SUM:

• gampi: var MPI_SUM

multipleDeviceDefaults:

• clbase: proc multipleDeviceDefaults(): tuple[devices: seq[Pdevice_id], context: Pcontext, queues: seq[Pcommand_queue]]

name:

• clbase: proc name(id: Pdevice_id): string
• clbase: proc name(id: Pplatform_id): string

native_cos:

• clbase: template native_cos(x: float32): float32

native_cos_impl:

• clbase: proc native_cos_impl(x: float32): float32

native_exp:

• clbase: template native_exp(x: float32): float32

native_exp2:

• clbase: template native_exp2(x: float32): float32

native_exp2_impl:

• clbase: proc native_exp2_impl(x: float32): float32

native_exp_impl:

• clbase: proc native_exp_impl(x: float32): float32

native_log:

• clbase: template native_log(x: float32): float32

native_log10:

• clbase: template native_log10(x: float32): float32

native_log10_impl:

• clbase: proc native_log10_impl(x: float32): float32

native_log2:

• clbase: template native_log2(x: float32): float32

native_log2_impl:

• clbase: proc native_log2_impl(x: float32): float32

native_log_impl:

• clbase: proc native_log_impl(x: float32): float32

native_powr:

• clbase: template native_powr(x, y: float32): float32

native_powr_impl:

• clbase: proc native_powr_impl(x, y: float32): float32

native_recip:

• clbase: template native_recip(x: float32): float32

native_recip_impl:

• clbase: proc native_recip_impl(x: float32): float32

native_rsqrt:

• clbase: template native_rsqrt(x: float32): float32

native_rsqrt_impl:

• clbase: proc native_rsqrt_impl(x: float32): float32

native_sin:

• clbase: template native_sin(x: float32): float32

native_sin_impl:

• clbase: proc native_sin_impl(x: float32): float32

native_sqrt:

• clbase: template native_sqrt(x: float32): float32

native_sqrt_impl:

• clbase: proc native_sqrt_impl(x: float32): float32

native_tan:

• clbase: template native_tan(x: float32): float32

native_tan_impl:

• clbase: proc native_tan_impl(x: float32): float32

nearestNeighborStencil:

• stencil: proc nearestNeighborStencil[D: static int](): StencilPattern[D]
• stencil: proc nearestNeighborStencil[D: static int; L: Lattice[D]](lat: L): StencilPattern[D]

needsSwap:

• qio: proc needsSwap(target: ByteOrder): bool

neighbor:

• stencil: proc neighbor[D: static int](s: LatticeStencil[D]; site, point: int): int

neighborOffset:

• stencil: proc neighborOffset[D: static int](sv: StencilView[D]; site, point: int): int

neighbors:

• stencil: iterator neighbors[D: static int](s: LatticeStencil[D]; site: int): int

neighborSimd:

• stencil: proc neighborSimd[D: static int](s: LatticeStencil[D]; outer, lane, point: int): tuple[ outer, lane: int]

newFileInfo:

• scidac: proc newFileInfo(dims: openArray[int]; volfmt: int = 0): SciDACFileInfo

newGlobalArray:

• gatypes: proc newGlobalArray[D: static[int]](globalGrid: array[D, SomeInteger]; mpiGrid: array[D, SomeInteger]; ghostGrid: array[D, SomeInteger]; T: typedesc): GlobalArray[ D, T]

newGlobalBackwardShifters:

• globaltensor: proc newGlobalBackwardShifters[D: static[int]; R: static[int]; L: Lattice[D]; T]( field: TensorField[D, R, L, T]; len: int = 1): array[D, GlobalShifter[D, R, L, T]]

newGlobalShifter:

• globaltensor: proc newGlobalShifter[D: static[int]; R: static[int]; L: Lattice[D]; T]( field: TensorField[D, R, L, T]; dim: int; len: int = 1): GlobalShifter[D, R, L, T]

newGlobalShifters:

• globaltensor: proc newGlobalShifters[D: static[int]; R: static[int]; L: Lattice[D]; T]( field: TensorField[D, R, L, T]; len: int = 1): array[D, GlobalShifter[D, R, L, T]]

newHandle:

• gawrap: proc newHandle(): cint

newILDGReader:

• scidac: proc newILDGReader(filename: string): ILDGReader

newLatticeStencil:

• stencil: proc newLatticeStencil[D: static int; L: Lattice[D]](lat: L): LatticeStencil[D]
• stencil: proc newLatticeStencil[D: static int](pattern: StencilPattern[D]; localGeom: array[D, int]): LatticeStencil[D]
• stencil: proc newLatticeStencil[D: static int](pattern: StencilPattern[D]; localGeom: array[D, int]; ghostWidth: array[D, int]): LatticeStencil[D]
• stencil: proc newLatticeStencil[D: static int](pattern: StencilPattern[D]; localGeom: array[D, int]; ghostWidth: array[D, int]; simdGrid: array[D, int]): LatticeStencil[D]
• stencil: proc newLatticeStencil[D: static int; L: Lattice[D]](pattern: StencilPattern[D]; lat: L): LatticeStencil[D]
• globaltensor: proc newLatticeStencil[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; pattern: StencilPattern[D]): LatticeStencil[ D]

newLimeReader:

• lime: proc newLimeReader(stream: Stream): LimeReader
• lime: proc newLimeReader(filename: string): LimeReader

newLimeWriter:

• lime: proc newLimeWriter(stream: Stream): LimeWriter
• lime: proc newLimeWriter(filename: string): LimeWriter

newLocalTensorField:

• localtensor: proc newLocalTensorField[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; padded: bool = false): LocalTensorField[D, R, L, T]

newQIOFieldReader:

• qio: proc newQIOFieldReader[T](filename: string): QIOFieldReader[T]

newQIOFieldWriter:

• qio: proc newQIOFieldWriter[T](filename: string; dims: openArray[int]): QIOFieldWriter[T]

newSciDACReader:

• scidac: proc newSciDACReader(filename: string): SciDACReader

newSciDACWriter:

• scidac: proc newSciDACWriter(filename: string; fileInfo: SciDACFileInfo): SciDACWriter

newSimdLatticeLayout:

• simdlayout: proc newSimdLatticeLayout(localGeom: openArray[int]; simdWidth: int): SimdLatticeLayout
• simdlayout: proc newSimdLatticeLayout(localGeom: openArray[int]; simdGrid: openArray[int]): SimdLatticeLayout

newSimpleCubicLattice:

• simplecubiclattice: proc newSimpleCubicLattice[D: static[int]](globalGrid: array[D, int]; mpiGrid: array[ D, int] = defaultMPIGrid[D](); ghostGrid: array[D, int] = defaultGhostGrid[D]()): SimpleCubicLattice[ D]

newStencil:

• stencil: proc newStencil[D: static int](name: string = ""): Stencil[D]

newStencilPattern:

• stencil: proc newStencilPattern[D: static int](name: string = ""): StencilPattern[D]

newStencilPoint:

• stencil: proc newStencilPoint[D: static int](offset: array[D, int]; id: int = 0): StencilPoint[ D]
• stencil: proc newStencilPoint[D: static int](sd: SignedDirection): StencilPoint[D]

newStencilView:

• stencil: proc newStencilView[D: static int](stencil: StencilPattern[D]; localGeom: array[D, int]): StencilView[D]

newTensorField:

• globaltensor: proc newTensorField[D: static[int]; R: static[int]; L: Lattice[D]](lattice: L; shape: array[R, int]; T: typedesc): TensorField[D, R, L, T]

newTensorFieldReader:

• tensorio: proc newTensorFieldReader(filename: string): TensorFieldReader

newTensorFieldView:

• tensorview: template newTensorFieldView[D: static[int]; R: static[int]; L, T]( tensor: LocalTensorField[D, R, L, T]; io: IOKind): TensorFieldView[L, T]
• tensorview: template newTensorFieldView[D: static[int]; R: static[int]; L, T]( tensor: TensorField[D, R, L, T]; io: IOKind): TensorFieldView[L, T]

newTensorFieldWriter:

• tensorio: proc newTensorFieldWriter[D: static[int]](filename: string; dims: array[D, int]): TensorFieldWriter

nextRecord:

• lime: proc nextRecord(reader: LimeReader): LimeStatus

NGA_Access:

• gawrap: proc NGA_Access(g_a: cint; lo: ptr cint; hi: ptr cint; p: ptr pointer; ld: ptr cint)

NGA_Access_ghosts:

• gawrap: proc NGA_Access_ghosts(g_a: cint; dims: ptr cint; p: ptr pointer; ld: ptr cint)

NGA_Distribution:

• gawrap: proc NGA_Distribution(g_a: cint; pid: cint; lo: ptr cint; hi: ptr cint)

NGA_Get:

• gawrap: proc NGA_Get(g_a: cint; lo: ptr cint; hi: ptr cint; buf: pointer; ld: ptr cint)

NGA_Periodic_get:

• gawrap: proc NGA_Periodic_get(g_a: cint; lo: ptr cint; hi: ptr cint; buf: pointer; ld: ptr cint)

NGA_Periodic_put:

• gawrap: proc NGA_Periodic_put(g_a: cint; lo: ptr cint; hi: ptr cint; buf: pointer; ld: ptr cint)

NGA_Put:

• gawrap: proc NGA_Put(g_a: cint; lo: ptr cint; hi: ptr cint; buf: pointer; ld: ptr cint)

NGA_Release:

• gawrap: proc NGA_Release(g_a: cint; lo: ptr cint; hi: ptr cint)

nLanes:

• stencil: proc nLanes[D: static int](s: LatticeStencil[D]): int

NON_BLOCKING:

• clwrap: const NON_BLOCKING

NONE:

• clwrap: const NONE

nOuter:

• stencil: proc nOuter[D: static int](s: LatticeStencil[D]): int

nPoints:

• stencil: proc nPoints[D: static int](s: StencilPattern[D]): int

nSites:

• stencil: proc nSites[D: static int](s: LatticeStencil[D]): int

nSitesInner:

• tensorview: proc nSitesInner[L, T](view: TensorFieldView[L, T]): int

nSitesOuter:

• tensorview: proc nSitesOuter[L, T](view: TensorFieldView[L, T]): int

numElements:

• localtensor: proc numElements[D: static[int]; R: static[int]; L: Lattice[D]; T]( view: LocalTensorField[D, R, L, T]): int
• sitetensor: template numElements[N: static[int]; M: static[int]; T](m: typedesc[Mat[N, M, T]]): int
• sitetensor: template numElements[N: static[int]; T](v: typedesc[Vec[N, T]]): int

numGlobalSites:

• localtensor: proc numGlobalSites[D: static[int]; R: static[int]; L: Lattice[D]; T]( view: LocalTensorField[D, R, L, T]): int
• tensorview: proc numGlobalSites[L, T](view: TensorFieldView[L, T]): int

numSites:

• gatypes: proc numSites[D: static[int]; T](ga: GlobalArray[D, T]): int
• localtensor: proc numSites[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: LocalTensorField[D, R, L, T]): int
• tensorview: proc numSites[L, T](view: TensorFieldView[L, T]): int

numVectorGroups:

• tensorview: proc numVectorGroups(numSites: int): int

oclName:

• clbase: template oclName(s: string): untyped

offsetBufferSize:

• stencil: proc offsetBufferSize[D: static int](s: LatticeStencil[D]): int

OmpChunkCallback:

• ompwrap: type OmpChunkCallback

omp_get_max_threads:

• ompbase: proc omp_get_max_threads(): cint

ompGetNumThreads:

• ompwrap: proc ompGetNumThreads(): cint

omp_get_thread_num:

• ompbase: proc omp_get_thread_num(): cint

OmpLoopCallback:

• ompwrap: type OmpLoopCallback

ompParallel:

• ompbase: template ompParallel(body: untyped)

ompParallelFor:

• ompwrap: proc ompParallelFor(start, end: int64; callback: OmpLoopCallback; context: pointer)

ompParallelForChunked:

• ompwrap: proc ompParallelForChunked(start, end: int64; callback: OmpChunkCallback; context: pointer)

ompSetNumThreads:

• ompwrap: proc ompSetNumThreads(numThreads: cint)

openclDefaults:

• clbase: proc openclDefaults(): tuple[devices: seq[Pdevice_id], context: Pcontext]

outerInnerToLocal:

• simdlayout: proc outerInnerToLocal(outerIdx, innerIdx: int; layout: SimdLatticeLayout): int

paddedGrid:

• globaltensor: proc paddedGrid[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]): array[D, int]

paddedToLocal:

• stencil: proc paddedToLocal[D: static int](paddedSite: int; localGeom: array[D, int]; ghostWidth: array[D, int]): int
• stencil: proc paddedToLocal[D: static int](s: LatticeStencil[D]; paddedSite: int): int

parallel:

• parallel: template parallel(body: untyped): untyped

parseChecksumXml:

• scidac: proc parseChecksumXml(xml: string): SciDACChecksum

parseFileXml:

• scidac: proc parseFileXml(xml: string): SciDACFileInfo

parseILDGFormatXml:

• scidac: proc parseILDGFormatXml(xml: string): ILDGFormatInfo

parseRecordXml:

• scidac: proc parseRecordXml(xml: string): SciDACRecordInfo

PathStep:

• stencil: object PathStep

pathToStencil:

• stencil: proc pathToStencil[D: static int](path: openArray[PathStep]): StencilPattern[D]

Pcommand_queue:

• clwrap: type Pcommand_queue

Pcontext:

• clwrap: type Pcontext

Pdevice_id:

• clwrap: type Pdevice_id

Pevent:

• clwrap: type Pevent

Pkernel:

• clwrap: type Pkernel

plaquettePath:

• stencil: proc plaquettePath(mu, nu: int): seq[PathStep]

PLATFORM_EXTENSIONS:

• clwrap: const PLATFORM_EXTENSIONS

PLATFORM_NAME:

• clwrap: const PLATFORM_NAME

PLATFORM_PROFILE:

• clwrap: const PLATFORM_PROFILE

PLATFORM_VENDOR:

• clwrap: const PLATFORM_VENDOR

PLATFORM_VERSION:

• clwrap: const PLATFORM_VERSION

Pmem:

• clwrap: type Pmem

points:

• stencil: iterator points[D: static int](s: LatticeStencil[D]): int

pow:

• clbase: proc pow(x, y: float32): float32

Pplatform_id:

• clwrap: type Pplatform_id

Pprogram:

• clwrap: type Pprogram

precision:

• tensorio: proc precision(reader: TensorFieldReader): SciDACPrecision

printFileInfo:

• tensorio: proc printFileInfo(reader: TensorFieldReader)

printRecordInfo:

• tensorio: proc printRecordInfo(reader: TensorFieldReader)

product:

• private: proc product[D: static[int]](arr: array[D, int]): int

PROGRAM_BINARIES:

• clwrap: const PROGRAM_BINARIES

PROGRAM_BINARY_SIZES:

• clwrap: const PROGRAM_BINARY_SIZES

PROGRAM_BINARY_TYPE:

• clwrap: const PROGRAM_BINARY_TYPE

PROGRAM_BINARY_TYPE_COMPILED_OBJECT:

• clwrap: const PROGRAM_BINARY_TYPE_COMPILED_OBJECT

PROGRAM_BINARY_TYPE_EXECUTABLE:

• clwrap: const PROGRAM_BINARY_TYPE_EXECUTABLE

PROGRAM_BINARY_TYPE_LIBRARY:

• clwrap: const PROGRAM_BINARY_TYPE_LIBRARY

PROGRAM_BINARY_TYPE_NONE:

• clwrap: const PROGRAM_BINARY_TYPE_NONE

PROGRAM_BUILD_LOG:

• clwrap: const PROGRAM_BUILD_LOG

PROGRAM_BUILD_OPTIONS:

• clwrap: const PROGRAM_BUILD_OPTIONS

PROGRAM_BUILD_STATUS:

• clwrap: const PROGRAM_BUILD_STATUS

PROGRAM_CONTEXT:

• clwrap: const PROGRAM_CONTEXT

PROGRAM_DEVICES:

• clwrap: const PROGRAM_DEVICES

PROGRAM_KERNEL_NAMES:

• clwrap: const PROGRAM_KERNEL_NAMES

PROGRAM_NUM_DEVICES:

• clwrap: const PROGRAM_NUM_DEVICES

PROGRAM_NUM_KERNELS:

• clwrap: const PROGRAM_NUM_KERNELS

PROGRAM_REFERENCE_COUNT:

• clwrap: const PROGRAM_REFERENCE_COUNT

PROGRAM_SOURCE:

• clwrap: const PROGRAM_SOURCE

PropagatorField:

• qio: object PropagatorField

Psampler:

• clwrap: type Psampler

QIOChecksum:

• qio: object QIOChecksum

QIOFieldReader:

• qio: type QIOFieldReader

QIOFieldWriter:

• qio: type QIOFieldWriter

QUEUE_CONTEXT:

• clwrap: const QUEUE_CONTEXT

QUEUED:

• clwrap: const QUEUED

QUEUE_DEVICE:

• clwrap: const QUEUE_DEVICE

QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE:

• clwrap: const QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE

QUEUE_PROFILING_ENABLE:

• clwrap: const QUEUE_PROFILING_ENABLE

QUEUE_PROPERTIES:

• clwrap: const QUEUE_PROPERTIES

QUEUE_REFERENCE_COUNT:

• clwrap: const QUEUE_REFERENCE_COUNT

raiseEOpenCL:

• clwrap: proc raiseEOpenCL(x: TClResult)

read:

• clbase: proc read(queue: Pcommand_queue; dest: pointer; src: Pmem; size: int)
• clbase: proc read[A](queue: Pcommand_queue; dest: var seq[A]; src: Pmem)
• clbase: proc read[T](queue: Pcommand_queue; dest: var seq[T]; src: GpuBuffer[T])

readAllData:

• lime: proc readAllData(reader: LimeReader): seq[byte]

readBinaryData:

• scidac: proc readBinaryData(r: SciDACReader): seq[byte]

readBinaryDataTyped:

• scidac: proc readBinaryDataTyped[T](r: SciDACReader): seq[T]

readData:

• lime: proc readData(reader: LimeReader; dest: pointer; nbytes: int): (int, LimeStatus)

readField:

• qio: proc readField[T](r: QIOFieldReader[T]; targetOrder: ByteOrder = boBigEndian): seq[T]

readFileInfo:

• scidac: proc readFileInfo(r: SciDACReader): SciDACFileInfo

readFormat:

• scidac: proc readFormat(r: ILDGReader): ILDGFormatInfo

readGaugeField:

• qio: proc readGaugeField(filename: string): GaugeField[float64]
• scidac: proc readGaugeField(r: ILDGReader): seq[byte]
• tensorio: proc readGaugeField[D: static[int]; L: Lattice[D]]( gaugeField: var array[4, TensorField[D, 2, L, Complex64]]; filename: string; swapBytes: bool = true)

readGaugeFieldToTensor:

• tensorio: proc readGaugeFieldToTensor[D: static[int]; L: Lattice[D]]( tensor: var TensorField[D, 3, L, Complex64]; filename: string)

read_mem_fence:

• clbase: template read_mem_fence(flags: cint)

read_mem_fence_impl:

• clbase: proc read_mem_fence_impl(flags: cint)

READ_ONLY_CACHE:

• clwrap: const READ_ONLY_CACHE

readPropagatorToTensor:

• tensorio: proc readPropagatorToTensor[D: static[int]; L: Lattice[D]]( tensor: var TensorField[D, 4, L, Complex64]; filename: string)

readSiteData:

• tensorview: proc readSiteData[L, T](view: TensorFieldView[L, T]; site: int): RuntimeSiteData[T]

readString:

• lime: proc readString(reader: LimeReader): string

readTensorField:

• tensorio: proc readTensorField[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: var TensorField[D, R, L, T]; filename: string; swapBytes: bool = true)

READ_WRITE_CACHE:

• clwrap: const READ_WRITE_CACHE

records:

• lime: iterator records(reader: LimeReader): LimeRecordHeader

rectanglePath:

• stencil: proc rectanglePath(mu, nu: int; a, b: int): seq[PathStep]

release:

• clbase: template release[T](buffer: GpuBuffer[T])
• clbase: template release(queue: Pcommand_queue)
• clbase: template release(context: Pcontext)
• clbase: template release(kernel: Pkernel)
• clbase: template release(buffer: Pmem)
• clbase: template release(program: Pprogram)

releaseCommandQueue:

• clwrap: proc releaseCommandQueue(command_queue: Pcommand_queue): TClResult

releaseContext:

• clwrap: proc releaseContext(context: Pcontext): TClResult

releaseDevice:

• clwrap: proc releaseDevice(device: Pdevice_id): TClResult

releaseEvent:

• clwrap: proc releaseEvent(event: Pevent): TClResult

releaseKernel:

• clwrap: proc releaseKernel(kernel: Pkernel): TClResult

releaseLocal:

• gatypes: proc releaseLocal[D: static[int]; T](ga: GlobalArray[D, T])
• globaltensor: proc releaseLocal[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T])

releaseMemObject:

• clwrap: proc releaseMemObject(memobj: Pmem): TClResult

releaseProgram:

• clwrap: proc releaseProgram(program: Pprogram): TClResult

releaseSampler:

• clwrap: proc releaseSampler(sampler: Psampler): TClResult

retainCommandQueue:

• clwrap: proc retainCommandQueue(command_queue: Pcommand_queue): TClResult

retainContext:

• clwrap: proc retainContext(context: Pcontext): TClResult

retainDevice:

• clwrap: proc retainDevice(device: Pdevice_id): TClResult

retainEvent:

• clwrap: proc retainEvent(event: Pevent): TClResult

retainKernel:

• clwrap: proc retainKernel(kernel: Pkernel): TClResult

retainMemObject:

• clwrap: proc retainMemObject(memobj: Pmem): TClResult

retainProgram:

• clwrap: proc retainProgram(program: Pprogram): TClResult

retainSampler:

• clwrap: proc retainSampler(sampler: Psampler): TClResult

round:

• clbase: proc round(x: float32): float32

rsqrt:

• clbase: template rsqrt(x: float32): float32

rsqrt_impl:

• clbase: proc rsqrt_impl(x: float32): float32

run:

• clbase: proc run(queue: Pcommand_queue; kernel: Pkernel; totalWork: int)
• clbase: proc run(queue: Pcommand_queue; kernel: Pkernel; totalWork, localWork: int)

run2d:

• clbase: proc run2d(queue: Pcommand_queue; kernel: Pkernel; totalWork: (int, int))
• clbase: proc run2d(queue: Pcommand_queue; kernel: Pkernel; totalWork, localWork: (int, int))

run3d:

• clbase: proc run3d(queue: Pcommand_queue; kernel: Pkernel; totalWork: (int, int, int))
• clbase: proc run3d(queue: Pcommand_queue; kernel: Pkernel; totalWork, localWork: (int, int, int))

RUNNING:

• clwrap: const RUNNING

RuntimeSiteData:

• sitetensor: object RuntimeSiteData

SAMPLER_ADDRESSING_MODE:

• clwrap: const SAMPLER_ADDRESSING_MODE

SAMPLER_CONTEXT:

• clwrap: const SAMPLER_CONTEXT

SAMPLER_FILTER_MODE:

• clwrap: const SAMPLER_FILTER_MODE

SAMPLER_NORMALIZED_COORDS:

• clwrap: const SAMPLER_NORMALIZED_COORDS

SAMPLER_REFERENCE_COUNT:

• clwrap: const SAMPLER_REFERENCE_COUNT

sbOpenCL:

• stencil: StencilBackend.sbOpenCL

sbScalar:

• stencil: StencilBackend.sbScalar

sbSimd:

• stencil: StencilBackend.sbSimd

sbSycl:

• stencil: StencilBackend.sbSycl

ScalarAddResult:

• sitetensor: object ScalarAddResult

ScalarMulResult:

• sitetensor: object ScalarMulResult

SciDACBinaryData:

• scidac: const SciDACBinaryData

SciDACChecksum:

• scidac: object SciDACChecksum

SciDACChecksumRecord:

• scidac: const SciDACChecksumRecord

SciDACFileInfo:

• scidac: object SciDACFileInfo

SciDACFileXml:

• scidac: const SciDACFileXml

SciDACPrecision:

• scidac: enum SciDACPrecision

SciDACPrivateFileXml:

• scidac: const SciDACPrivateFileXml

SciDACPrivateRecordXml:

• scidac: const SciDACPrivateRecordXml

SciDACReader:

• scidac: type SciDACReader

SciDACRecordInfo:

• scidac: object SciDACRecordInfo

SciDACRecordXml:

• scidac: const SciDACRecordXml

SciDACTypeSize:

• scidac: enum SciDACTypeSize

SciDACUserInfo:

• scidac: object SciDACUserInfo

SciDACWriter:

• scidac: type SciDACWriter

seek:

• lime: proc seek(reader: LimeReader; offset: int64; whence: int = 0): LimeStatus

setArg:

• clbase: template setArg[A](kernel: Pkernel; item: var A; index: int)
• clbase: template setArg(kernel: Pkernel; item: anyInt; index: int)
• clbase: template setArg[T](kernel: Pkernel; item: GpuBuffer[T]; index: int)
• clbase: template setArg[A](kernel: Pkernel; item: LocalBuffer[A]; index: int)
• clbase: template setArg(kernel: Pkernel; item: Pmem; index: int)

setChunk:

• gawrap: proc setChunk[D: static[int]](handle: cint; chunks: array[D, cint])

setData:

• gawrap: proc setData[D: static[int]](handle: cint; dims: array[D, cint]; T: typedesc)

setEventCallback:

• clwrap: proc setEventCallback(event: Pevent; command_exec_callback_type: int32; pfn_notify: TEventCb; user_data: pointer): TClResult

setGhosts:

• gawrap: proc setGhosts[D: static[int]](handle: cint; widths: array[D, cint])

setKernelArg:

• clwrap: proc setKernelArg(kernel: Pkernel; arg_index: uint32; arg_size: int; arg_value: pointer): TClResult

setMemObjectDestructorCallback:

• clwrap: proc setMemObjectDestructorCallback(memobj: Pmem; pfn_notify: TMemObjectDestructorCb; user_data: pointer): TClResult

setName:

• gawrap: proc setName(handle: cint; name: cstring)

setPosition:

• lime: proc setPosition(reader: LimeReader; offset: int64): LimeStatus

setUserEventStatus:

• clwrap: proc setUserEventStatus(event: Pevent; execution_status: int32): TClResult

shift:

• stencil: proc shift[D: static int](s: LatticeStencil[D]; site: int; sign: int; dir: int): StencilShift[ D]
• stencil: proc shift[D: static int](s: LatticeStencil[D]; site: int; sd: SignedDirection): StencilShift[ D]

SignedDirection:

• stencil: object SignedDirection

simdLanes:

• simdlayout: proc simdLanes(layout: SimdLatticeLayout): int

SimdLatticeLayout:

• simdlayout: object SimdLatticeLayout

simdLayout:

• tensorview: proc simdLayout[L, T](view: TensorFieldView[L, T]): SimdLatticeLayout

SimpleCubicLattice:

• simplecubiclattice: object SimpleCubicLattice

sin:

• clbase: proc sin(x: float32): float32

singleDeviceDefaults:

• clbase: proc singleDeviceDefaults(): tuple[device: Pdevice_id, context: Pcontext, queue: Pcommand_queue]

sinh:

• clbase: proc sinh(x: float32): float32

sites:

• stencil: iterator sites[D: static int](s: LatticeStencil[D]): int

sitesPerDevice:

• tensorview: proc sitesPerDevice[L, T](view: TensorFieldView[L, T]): seq[int]

spDouble:

• scidac: SciDACPrecision.spDouble

spins:

• tensorio: proc spins(reader: TensorFieldReader): int

splitLatticeSites:

• tensorview: proc splitLatticeSites(totalSites: int; numDevices: int): seq[int]

spSingle:

• scidac: SciDACPrecision.spSingle

sqrt:

• clbase: proc sqrt(x: float32): float32

stColorMatrix:

• scidac: SciDACTypeSize.stColorMatrix

stColorVector:

• scidac: SciDACTypeSize.stColorVector

stComplex:

• scidac: SciDACTypeSize.stComplex

stDiracSpinor:

• scidac: SciDACTypeSize.stDiracSpinor

Stencil:

• stencil: type Stencil

StencilBackend:

• stencil: enum StencilBackend

StencilEntry:

• stencil: object StencilEntry

StencilPattern:

• stencil: object StencilPattern

StencilPoint:

• stencil: object StencilPoint

StencilShift:

• stencil: object StencilShift

StencilView:

• stencil: object StencilView

step:

• stencil: proc step(dir: int; forward: bool = true): PathStep

storageType:

• sitetensor: template storageType(T: typedesc): typedesc

stPropagator:

• scidac: SciDACTypeSize.stPropagator

stReal:

• scidac: SciDACTypeSize.stReal

SUBMITTED:

• clwrap: const SUBMITTED

swapBytes32:

• qio: proc swapBytes32(data: var openArray[byte])

swapBytes64:

• qio: proc swapBytes64(data: var openArray[byte])

swapBytesFloat32:

• qio: proc swapBytesFloat32(data: var openArray[float32])

swapBytesFloat64:

• qio: proc swapBytesFloat64(data: var openArray[float64])

T:

• stencil: template T(): Direction

Taddressing_mode:

• clwrap: type Taddressing_mode

tan:

• clbase: proc tan(x: float32): float32

tanh:

• clbase: proc tanh(x: float32): float32

Tbitfield:

• clwrap: type Tbitfield

Tbool:

• clwrap: type Tbool

Tbuffer_create_type:

• clwrap: type Tbuffer_create_type

Tbuffer_region:

• clwrap: object Tbuffer_region

Tbuild_status:

• clwrap: type Tbuild_status

Tchannel_order:

• clwrap: type Tchannel_order

Tchannel_type:

• clwrap: type Tchannel_type

TClResult:

• clwrap: enum TClResult

Tcommand_queue_info:

• clwrap: type Tcommand_queue_info

Tcommand_queue_properties:

• clwrap: type Tcommand_queue_properties

Tcommand_type:

• clwrap: type Tcommand_type

Tcontext_info:

• clwrap: type Tcontext_info

Tcontext_properties:

• clwrap: type Tcontext_properties

TCreateContextCb:

• clwrap: type TCreateContextCb

Tdevice_affinity_domain:

• clwrap: type Tdevice_affinity_domain

Tdevice_exec_capabilities:

• clwrap: type Tdevice_exec_capabilities

Tdevice_fp_config:

• clwrap: type Tdevice_fp_config

Tdevice_info:

• clwrap: type Tdevice_info

Tdevice_local_mem_type:

• clwrap: type Tdevice_local_mem_type

Tdevice_mem_cache_type:

• clwrap: type Tdevice_mem_cache_type

Tdevice_partition_property:

• clwrap: type Tdevice_partition_property

TDeviceType:

• clwrap: type TDeviceType

TensorElementProxy:

• sitetensor: object TensorElementProxy

tensorElementsPerSite:

• localtensor: proc tensorElementsPerSite[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: LocalTensorField[D, R, L, T]): int

TensorField:

• globaltensor: object TensorField

TensorFieldReader:

• tensorio: type TensorFieldReader

TensorFieldView:

• tensorview: object TensorFieldView

TensorFieldWriter:

• tensorio: type TensorFieldWriter

TensorSiteProxy:

• sitetensor: object TensorSiteProxy

TEventCb:

• clwrap: type TEventCb

Tevent_info:

• clwrap: type Tevent_info

Tfilter_mode:

• clwrap: type Tfilter_mode

Timage_desc:

• clwrap: object Timage_desc

Timage_format:

• clwrap: object Timage_format

Timage_info:

• clwrap: type Timage_info

Tkernel_arg_access_qualifier:

• clwrap: type Tkernel_arg_access_qualifier

Tkernel_arg_address_qualifier:

• clwrap: type Tkernel_arg_address_qualifier

Tkernel_arg_info:

• clwrap: type Tkernel_arg_info

Tkernel_arg_type_qualifier:

• clwrap: type Tkernel_arg_type_qualifier

Tkernel_info:

• clwrap: type Tkernel_info

Tkernel_work_group_info:

• clwrap: type Tkernel_work_group_info

Tmap_flags:

• clwrap: type Tmap_flags

Tmem_flags:

• clwrap: type Tmem_flags

Tmem_info:

• clwrap: type Tmem_info

Tmem_migration_flags:

• clwrap: type Tmem_migration_flags

TMemObjectDestructorCb:

• clwrap: type TMemObjectDestructorCb

Tmem_object_type:

• clwrap: type Tmem_object_type

toGAType:

• gawrap: proc toGAType(t: typedesc[float32]): cint
• gawrap: proc toGAType(t: typedesc[float64]): cint
• gawrap: proc toGAType(t: typedesc[int32]): cint
• gawrap: proc toGAType(t: typedesc[int64]): cint

totalElements:

• tensorview: proc totalElements[L, T](view: TensorFieldView[L, T]): int

Tplatform_info:

• clwrap: type Tplatform_info

Tprofiling_info:

• clwrap: enum Tprofiling_info

Tprogram_binary_type:

• clwrap: type Tprogram_binary_type

Tprogram_build_info:

• clwrap: type Tprogram_build_info

TProgramCb:

• clwrap: type TProgramCb

Tprogram_info:

• clwrap: type Tprogram_info

trace:

• sitetensor: proc trace[N: static[int]; T](m: Mat[N, N, T]): T

transformAoSoAtoAoS:

• tensorview: proc transformAoSoAtoAoS[T](src: pointer; numSites, elemsPerSite: int): seq[T]

transformAoSoAtoAoSSimd:

• tensorview: proc transformAoSoAtoAoSSimd[T](src: pointer; layout: SimdLatticeLayout; elemsPerSite: int): seq[T]

transformAoStoAoSoA:

• tensorview: proc transformAoStoAoSoA[T](src: pointer; numSites, elemsPerSite: int; siteOffsets: seq[int]): seq[T]

transformAoStoAoSoASimd:

• tensorview: proc transformAoStoAoSoASimd[T](src: pointer; layout: SimdLatticeLayout; elemsPerSite: int; siteOffsets: seq[int]): seq[T]

transpose:

• sitetensor: proc transpose[N: static[int]; M: static[int]; T](m: Mat[N, M, T]): Mat[M, N, T]

trunc:

• clbase: proc trunc(x: float32): float32

Tsampler_info:

• clwrap: type Tsampler_info

TUserCb:

• clwrap: type TUserCb

typesize:

• tensorio: proc typesize(reader: TensorFieldReader): int

unloadCompiler:

• clwrap: proc unloadCompiler(): TClResult

unloadPlatformCompiler:

• clwrap: proc unloadPlatformCompiler(platform: Pplatform_id): TClResult

update:

• qio: proc update(cs: var QIOChecksum; data: openArray[byte]; rank: uint32 = 0)

updateAllGhosts:

• globaltensor: proc updateAllGhosts[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; updateCorners: bool = false)

updateChecksum:

• scidac: proc updateChecksum(cs: var SciDACChecksum; data: openArray[byte]; siteIndex: uint32 = 0)

updateGhostDirection:

• gatypes: proc updateGhostDirection[D: static[int]; T](ga: GlobalArray[D, T]; dir: SomeInteger; side: SomeInteger; update_corners: bool = true)

updateGhosts:

• gatypes: proc updateGhosts[D: static[int]; T](ga: GlobalArray[D, T]; update_corners: bool = true)
• globaltensor: proc updateGhosts[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; dim: int; direction: int = 0; updateCorners: bool = false)

UseOpenCL:

• stencil: const UseOpenCL

UseOpenMP:

• stencil: const UseOpenMP
• parallel: const UseOpenMP
• sitetensor: const UseOpenMP
• tensorview: const UseOpenMP

UseSYCL:

• stencil: const UseSYCL

UseSycl:

• parallel: const UseSycl
• sitetensor: const UseSycl
• tensorview: const UseSycl

UseWorkGroups:

• cldisp: const UseWorkGroups

validateSimdGrid:

• simdlayout: proc validateSimdGrid(globalGeom, mpiGrid, simdGrid: openArray[int]): tuple[ valid: bool, message: string]

Vec:

• sitetensor: object Vec

Vec2:

• sitetensor: type Vec2

Vec2d:

• sitetensor: type Vec2d

Vec2f:

• sitetensor: type Vec2f

Vec3:

• sitetensor: type Vec3

Vec3d:

• sitetensor: type Vec3d

Vec3f:

• sitetensor: type Vec3f

Vec4:

• sitetensor: type Vec4

Vec4d:

• sitetensor: type Vec4d

Vec4f:

• sitetensor: type Vec4f

vecadd:

• tensorview: proc vecadd[L, T](a, b: TensorFieldView[L, T]; site: int): VecAddResult[L, T]

VecAddResult:

• sitetensor: object VecAddResult

vecSize:

• sitetensor: template vecSize[N: static[int]; T](v: typedesc[Vec[N, T]]): int

vectorGroups:

• simdlayout: proc vectorGroups(layout: SimdLatticeLayout): int

VectorWidth:

• stencil: const VectorWidth
• cldisp: const VectorWidth
• tensorview: const VectorWidth

version:

• clbase: proc version(id: Pplatform_id): string

VERSION_1_0:

• clwrap: const VERSION_1_0

VERSION_1_1:

• clwrap: const VERSION_1_1

VERSION_1_2:

• clwrap: const VERSION_1_2

volume:

• qio: proc volume(dims: array[4, int]): int

waitForEvents:

• clwrap: proc waitForEvents(num_events: uint32; event_list: ptr Pevent): TClResult

write:

• clbase: proc write(queue: Pcommand_queue; src: pointer; dest: Pmem; size: int)
• clbase: proc write[A](queue: Pcommand_queue; src: var seq[A]; dest: Pmem)
• clbase: proc write[T](queue: Pcommand_queue; src: var seq[T]; dest: GpuBuffer[T])

writeBytes:

• lime: proc writeBytes(writer: LimeWriter; data: openArray[byte]): LimeStatus

writeData:

• lime: proc writeData(writer: LimeWriter; source: pointer; nbytes: int): (int, LimeStatus)

writeField:

• qio: proc writeField[T](w: QIOFieldWriter[T]; data: openArray[T]; colors: int = 3; spins: int = 0; datacount: int = 4; userXml: string = ""; sourceOrder: ByteOrder = boNative): LimeStatus
• scidac: proc writeField[T](w: SciDACWriter; data: openArray[T]; recordInfo: SciDACRecordInfo; userXml: string = ""): LimeStatus

writeFieldBytes:

• scidac: proc writeFieldBytes(w: SciDACWriter; data: openArray[byte]; recordInfo: SciDACRecordInfo; userXml: string = ""): LimeStatus

writeFileInfo:

• scidac: proc writeFileInfo(w: SciDACWriter; userXml: string = ""): LimeStatus

writeGaugeField:

• qio: proc writeGaugeField(filename: string; field: GaugeField[float64]; userXml: string = ""): LimeStatus
• tensorio: proc writeGaugeField[D: static[int]; L: Lattice[D]]( gaugeField: array[4, TensorField[D, 2, L, Complex64]]; filename: string; userXml: string = ""): LimeStatus

writeGaugeFieldFromTensor:

• tensorio: proc writeGaugeFieldFromTensor[D: static[int]; L: Lattice[D]]( tensor: TensorField[D, 3, L, Complex64]; filename: string; userXml: string = ""): LimeStatus

writeHeader:

• lime: proc writeHeader(writer: LimeWriter; header: LimeRecordHeader): LimeStatus

write_mem_fence:

• clbase: template write_mem_fence(flags: cint)

write_mem_fence_impl:

• clbase: proc write_mem_fence_impl(flags: cint)

writePropagatorFromTensor:

• tensorio: proc writePropagatorFromTensor[D: static[int]; L: Lattice[D]]( tensor: TensorField[D, 4, L, Complex64]; filename: string; userXml: string = ""): LimeStatus

writeRecord:

• lime: proc writeRecord(writer: LimeWriter; limeType: string; data: openArray[byte]; mbFlag = true; meFlag = true): LimeStatus
• lime: proc writeRecord(writer: LimeWriter; limeType: string; data: string; mbFlag = true; meFlag = true): LimeStatus

writeSiteElement:

• tensorview: proc writeSiteElement[L, T](view: TensorFieldView[L, T]; site: int; elementIdx: int; value: T)

writeString:

• lime: proc writeString(writer: LimeWriter; s: string): LimeStatus

writeTensorField:

• tensorio: proc writeTensorField[D: static[int]; R: static[int]; L: Lattice[D]; T]( tensor: TensorField[D, R, L, T]; filename: string; userXml: string = ""; colors: int = 3; spins: int = 0): LimeStatus

X:

• stencil: template X(): Direction

Y:

• stencil: template Y(): Direction

Z:

• stencil: template Z(): Direction