Index

Modules: hippo.

API symbols

`$`:

• hippo: proc `$`(self: ConstCString): string

`=destroy`:

• hippo: proc `=destroy`(mem: var GpuMemory)

amdgcnSdot4:

• hippo: proc amdgcnSdot4(a, b: cint; c: cint): cint

BlockDim:

• hippo: object BlockDim

blockDim:

• hippo: let blockDim

BlockIdx:

• hippo: object BlockIdx

blockIdx:

• hippo: let blockIdx

ConstCString:

• hippo: object ConstCString

cos:

• hippo: proc cos(x: cdouble): cdouble

cosf:

• hippo: proc cosf(x: cfloat): cfloat

Dim3:

• hippo: object Dim3

exp:

• hippo: proc exp(x: cdouble): cdouble

expf:

• hippo: proc expf(x: cfloat): cfloat

fabsf:

• hippo: proc fabsf(x: cfloat): cfloat

floatToHalf:

• hippo: proc floatToHalf(f: cfloat): uint16

fmaxf:

• hippo: proc fmaxf(a: cfloat; b: cfloat): cfloat

generateForLoopMacro:

• hippo: macro generateForLoopMacro(name: static[string]; theType: typedesc; body: untyped): untyped

GridDim:

• hippo: object GridDim

gridDim:

• hippo: let gridDim

halfToFloat:

• hippo: proc halfToFloat(h: uint16): cfloat

handleError:

• hippo: proc handleError(err: hipError_t)

hipAtomicAdd:

• hippo: proc hipAtomicAdd(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicAdd(address: ptr uint32; val: uint32): uint32

hipAtomicAnd:

• hippo: proc hipAtomicAnd(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicAnd(address: ptr uint32; val: uint32): uint32

hipAtomicCAS:

• hippo: proc hipAtomicCAS(address: ptr int32; compare: int32; val: int32): int32
• hippo: proc hipAtomicCAS(address: ptr uint32; compare: uint32; val: uint32): uint32

hipAtomicExch:

• hippo: proc hipAtomicExch(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicExch(address: ptr uint32; val: uint32): uint32

hipAtomicMax:

• hippo: proc hipAtomicMax(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicMax(address: ptr uint32; val: uint32): uint32

hipAtomicMin:

• hippo: proc hipAtomicMin(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicMin(address: ptr uint32; val: uint32): uint32

hipAtomicOr:

• hippo: proc hipAtomicOr(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicOr(address: ptr uint32; val: uint32): uint32

hipAtomicSub:

• hippo: proc hipAtomicSub(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicSub(address: ptr uint32; val: uint32): uint32

hipAtomicXor:

• hippo: proc hipAtomicXor(address: ptr int32; val: int32): int32
• hippo: proc hipAtomicXor(address: ptr uint32; val: uint32): uint32

hipDeviceProp_t:

• hippo: object hipDeviceProp_t

hipDeviceSynchronize:

• hippo: proc hipDeviceSynchronize(): hipError_t

hipError_t:

• hippo: type hipError_t

hipEventCreate:

• hippo: proc hipEventCreate(event: ptr hipEvent_t): hipError_t

hipEventCreateWithFlags:

• hippo: proc hipEventCreateWithFlags(event: ptr hipEvent_t; flags: uint32_t): hipError_t

hipEventDestroy:

• hippo: proc hipEventDestroy(event: hipEvent_t): hipError_t

hipEventElapsedTime:

• hippo: proc hipEventElapsedTime(ms: ptr cfloat; start: hipEvent_t; stop: hipEvent_t): hipError_t

hipEventQuery:

• hippo: proc hipEventQuery(event: hipEvent_t): hipError_t

hipEventRecord:

• hippo: proc hipEventRecord(event: hipEvent_t; stream: hipStream_t = nil): hipError_t

hipEventSynchronize:

• hippo: proc hipEventSynchronize(event: hipEvent_t): hipError_t

hipEvent_t:

• hippo: type hipEvent_t

hipFree:

• hippo: proc hipFree(ptr: pointer): hipError_t

hipGetDevice:

• hippo: proc hipGetDevice(device: ptr cint): hipError_t

hipGetDeviceProperties:

• hippo: proc hipGetDeviceProperties(prop: ptr hipDeviceProp_t; device: cint): hipError_t

hipGetErrorString:

• hippo: proc hipGetErrorString(err: hipError_t): ConstCString

hipGetLastError:

• hippo: proc hipGetLastError(): hipError_t

hipGraphDestroy:

• hippo: proc hipGraphDestroy(graph: hipGraph_t): hipError_t

hipGraphExecDestroy:

• hippo: proc hipGraphExecDestroy(graphExec: hipGraphExec_t): hipError_t

hipGraphExec_t:

• hippo: type hipGraphExec_t

hipGraphInstantiate:

• hippo: proc hipGraphInstantiate(pGraphExec: ptr hipGraphExec_t; graph: hipGraph_t; errNode: pointer = nil; errLog: pointer = nil; logSize: csize_t = 0): hipError_t

hipGraphLaunch:

• hippo: proc hipGraphLaunch(graphExec: hipGraphExec_t; stream: hipStream_t): hipError_t

hipGraph_t:

• hippo: type hipGraph_t

hipHostAlloc:

• hippo: proc hipHostAlloc(p: ptr pointer; size: csize_t; flags: uint32_t): hipError_t

hipHostFree:

• hippo: proc hipHostFree(p: pointer): hipError_t

hipLaunchCooperativeKernel:

• hippo: proc hipLaunchCooperativeKernel(function_address: pointer; gridDim: Dim3; blockDim: Dim3; kernelParams: ptr pointer; sharedMemBytes: csize_t; stream: hipStream_t): hipError_t

hipLaunchKernel:

• hippo: proc hipLaunchKernel(function_address: pointer; numBlocks: Dim3; dimBlocks: Dim3; args: ptr pointer): hipError_t
• hippo: proc hipLaunchKernel(function_address: pointer; numBlocks: Dim3; dimBlocks: Dim3; args: ptr pointer; sharedMemBytes: csize_t; stream: hipStream_t): cint

hipLaunchKernelGGL:

• hippo: proc hipLaunchKernelGGL(function_address: proc; numBlocks: Dim3; dimBlocks: Dim3; sharedMemBytes: uint32_t; stream: hipStream_t)

hipMalloc:

• hippo: proc hipMalloc(ptr: ptr pointer; size: cint): hipError_t

hipMemcpy:

• hippo: proc hipMemcpy(dst: pointer; src: pointer; size: cint; kind: hipMemcpyKind): hipError_t

hipMemcpyAsync:

• hippo: proc hipMemcpyAsync(dst: pointer; src: pointer; sizeBytes: csize_t; kind: hipMemcpyKind; stream: hipStream_t): hipError_t

hipMemcpyKind:

• hippo: enum hipMemcpyKind

hipMemcpyToSymbol:

• hippo: proc hipMemcpyToSymbol(symbol: pointer; src: pointer; sizeBytes: csize_t; offset: csize_t = 0; kind: hipMemcpyKind = hipMemcpyHostToDevice): hipError_t

hipOccupancyMaxActiveBlocksPerMultiprocessor:

• hippo: proc hipOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks: ptr cint; f: pointer; blockSize: cint; dynSharedMemPerBlk: csize_t): hipError_t

hippoArgs:

• hippo: macro hippoArgs(args: varargs[untyped]): untyped

hippoAtomicAdd:

• hippo: template hippoAtomicAdd(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicAdd(address: ptr [uint32]; val: uint32): uint32

hippoAtomicAnd:

• hippo: template hippoAtomicAnd(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicAnd(address: ptr [uint32]; val: uint32): uint32

hippoAtomicCAS:

• hippo: template hippoAtomicCAS(address: ptr [int32]; compare: int32; val: int32): int32
• hippo: template hippoAtomicCAS(address: ptr [uint32]; compare: uint32; val: uint32): uint32

hippoAtomicExch:

• hippo: template hippoAtomicExch(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicExch(address: ptr [uint32]; val: uint32): uint32

hippoAtomicMax:

• hippo: template hippoAtomicMax(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicMax(address: ptr [uint32]; val: uint32): uint32

hippoAtomicMin:

• hippo: template hippoAtomicMin(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicMin(address: ptr [uint32]; val: uint32): uint32

hippoAtomicOr:

• hippo: template hippoAtomicOr(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicOr(address: ptr [uint32]; val: uint32): uint32

hippoAtomicSub:

• hippo: template hippoAtomicSub(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicSub(address: ptr [uint32]; val: uint32): uint32

hippoAtomicXor:

• hippo: template hippoAtomicXor(address: ptr [int32]; val: int32): int32
• hippo: template hippoAtomicXor(address: ptr [uint32]; val: uint32): uint32

hippoConstant:

• hippo: macro hippoConstant(v: untyped): untyped

hippoCos:

• hippo: template hippoCos(x: cfloat): cfloat

hippoDevice:

• hippo: macro hippoDevice(fn: untyped): untyped

HippoDeviceProp:

• hippo: type HippoDeviceProp

HippoError:

• hippo: type HippoError

HippoErrorNotReady:

• hippo: const HippoErrorNotReady

HippoEvent:

• hippo: type HippoEvent

HippoEventBlockingSync:

• hippo: const HippoEventBlockingSync

hippoEventCreate:

• hippo: template hippoEventCreate(): HippoEvent

hippoEventCreateWithFlags:

• hippo: template hippoEventCreateWithFlags(flags: uint32 = 0'u32): HippoEvent

HippoEventDefault:

• hippo: const HippoEventDefault

hippoEventDestroy:

• hippo: template hippoEventDestroy(event: HippoEvent)

HippoEventDisableTiming:

• hippo: const HippoEventDisableTiming

hippoEventElapsedTime:

• hippo: template hippoEventElapsedTime(start: HippoEvent; stop: HippoEvent): float32

HippoEventInterprocess:

• hippo: const HippoEventInterprocess

hippoEventQuery:

• hippo: template hippoEventQuery(event: HippoEvent): bool

hippoEventRecord:

• hippo: template hippoEventRecord(event: HippoEvent; stream: HippoStream = nil)

hippoEventSynchronize:

• hippo: template hippoEventSynchronize(event: HippoEvent)

hippoExp:

• hippo: template hippoExp(x: cdouble): cdouble
• hippo: template hippoExp(x: cfloat): cfloat

hippoFabsf:

• hippo: template hippoFabsf(x: cfloat): cfloat

hippoFloatToHalf:

• hippo: template hippoFloatToHalf(f: cfloat): uint16

hippoFmaxf:

• hippo: template hippoFmaxf(a: cfloat; b: cfloat): cfloat

hippoFree:

• hippo: template hippoFree(p: pointer)

hippoGetDevice:

• hippo: template hippoGetDevice(): cint

hippoGetDeviceProperties:

• hippo: template hippoGetDeviceProperties(prop: var HippoDeviceProp; device: cint)

hippoGlobal:

• hippo: macro hippoGlobal(fn: untyped): untyped

hippoGraphDestroy:

• hippo: template hippoGraphDestroy(graph: hipGraph_t)

hippoGraphExecDestroy:

• hippo: template hippoGraphExecDestroy(exec: hipGraphExec_t)

hippoGraphInstantiate:

• hippo: template hippoGraphInstantiate(graph: hipGraph_t): hipGraphExec_t

hippoGraphLaunch:

• hippo: template hippoGraphLaunch(exec: hipGraphExec_t; stream: HippoStream)

hippoGridSync:

• hippo: template hippoGridSync()

hippoHalfToFloat:

• hippo: template hippoHalfToFloat(h: uint16): cfloat

hippoHost:

• hippo: macro hippoHost(fn: untyped): untyped

hippoHostAlloc:

• hippo: template hippoHostAlloc(size: int): pointer

hippoHostDevice:

• hippo: macro hippoHostDevice(fn: untyped): untyped

hippoHostFree:

• hippo: template hippoHostFree(p: pointer)

hippoLaunchCooperative:

• hippo: template hippoLaunchCooperative(kernel: untyped; gridDim: Dim3 = newDim3(1, 1, 1); blockDim: Dim3 = newDim3(1, 1, 1); sharedMemBytes: uint32 = 0; stream: HippoStream = nil; args: untyped)

hippoLaunchKernel:

• hippo: template hippoLaunchKernel(kernel: untyped; ## The GPU kernel procedure to launch gridDim: Dim3 = newDim3(1, 1, 1); ## default to a grid of 1 block blockDim: Dim3 = newDim3(1, 1, 1); ## default to 1 thread per block sharedMemBytes: uint32 = 0; ## dynamic shared memory amount to allocate stream: HippoStream = nil; ## Which device stream to run under (defaults to null) args: untyped)

hippoLoadU32:

• hippo: template hippoLoadU32(p: ptr uint8): uint32

hippoLog:

• hippo: template hippoLog(x: cdouble): cdouble
• hippo: template hippoLog(x: cfloat): cfloat

hippoMalloc:

• hippo: template hippoMalloc(size: int): GpuRef

hippoMaxActiveBlocksPerSM:

• hippo: proc hippoMaxActiveBlocksPerSM(kernel: pointer; blockSize: int; sharedMem: int = 0): int

hippoMemcpy:

• hippo: template hippoMemcpy(dst: GpuRef; src: GpuRef; size: int; kind: HippoMemcpyKind)
• hippo: template hippoMemcpy(dst: GpuRef; src: pointer; size: int; kind: HippoMemcpyKind)
• hippo: template hippoMemcpy(dst: pointer; src: GpuRef; size: int; kind: HippoMemcpyKind)
• hippo: template hippoMemcpy(dst: pointer; src: pointer; size: int; kind: HippoMemcpyKind)

hippoMemcpyAsync:

• hippo: template hippoMemcpyAsync(dst: pointer; src: pointer; size: int; kind: HippoMemcpyKind; stream: HippoStream)

HippoMemcpyDefault:

• hippo: const HippoMemcpyDefault

HippoMemcpyDeviceToDevice:

• hippo: const HippoMemcpyDeviceToDevice

HippoMemcpyDeviceToHost:

• hippo: const HippoMemcpyDeviceToHost

HippoMemcpyHostToDevice:

• hippo: const HippoMemcpyHostToDevice

HippoMemcpyHostToHost:

• hippo: const HippoMemcpyHostToHost

HippoMemcpyKind:

• hippo: type HippoMemcpyKind

hippoMemcpyToSymbol:

• hippo: template hippoMemcpyToSymbol(symbol: untyped; src: pointer; size: int; offset: int = 0; kind: HippoMemcpyKind = HippoMemcpyHostToDevice)

HippoPlatform:

• hippo: const HippoPlatform

hippoPow:

• hippo: template hippoPow(base: cdouble; exp: cdouble): cdouble
• hippo: template hippoPow(base: cfloat; exp: cfloat): cfloat

hippoRoundf:

• hippo: template hippoRoundf(x: cfloat): cfloat

HippoRuntime:

• hippo: const HippoRuntime

hippoSdot4:

• hippo: template hippoSdot4(a, b: cint; c: cint): cint

hippoShared:

• hippo: macro hippoShared(v: untyped): untyped

hippoShfl:

• hippo: template hippoShfl(val: cfloat; srcLane: int): cfloat
• hippo: template hippoShfl(val: cint; srcLane: int): cint

hippoShflDown:

• hippo: template hippoShflDown(val: cfloat; delta: int): cfloat
• hippo: template hippoShflDown(val: cint; delta: int): cint

hippoSin:

• hippo: template hippoSin(x: cfloat): cfloat

hippoSqrt:

• hippo: template hippoSqrt(x: cfloat): cfloat

HippoStream:

• hippo: type HippoStream

hippoStreamBeginCapture:

• hippo: template hippoStreamBeginCapture(stream: HippoStream; mode: hipStreamCaptureMode = hipStreamCaptureModeGlobal)

hippoStreamCreate:

• hippo: template hippoStreamCreate(): HippoStream

hippoStreamDestroy:

• hippo: template hippoStreamDestroy(stream: HippoStream)

hippoStreamEndCapture:

• hippo: template hippoStreamEndCapture(stream: HippoStream): hipGraph_t

hippoStreamSynchronize:

• hippo: template hippoStreamSynchronize(stream: HippoStream)

hippoStreamWaitEvent:

• hippo: template hippoStreamWaitEvent(stream: HippoStream; event: pointer; flags: uint32 = 0'u32)

hippoSynchronize:

• hippo: template hippoSynchronize()

hippoSyncthreads:

• hippo: proc hippoSyncthreads()

hippoVsubss4:

• hippo: template hippoVsubss4(a, b: cint): cint

HippoWarpSize:

• hippo: const HippoWarpSize

hippoWmmaF32_16x16x16_f16:

• hippo: template hippoWmmaF32_16x16x16_f16(a, b: HippoWmmaHalf16; c: HippoWmmaFloat8): HippoWmmaFloat8

HippoWmmaFloat8:

• hippo: type HippoWmmaFloat8

hippoWmmaGetF32:

• hippo: template hippoWmmaGetF32(v: HippoWmmaFloat8; idx: int): cfloat

HippoWmmaHalf16:

• hippo: type HippoWmmaHalf16

hippoWmmaSetF16:

• hippo: template hippoWmmaSetF16(v: var HippoWmmaHalf16; idx: int; val: uint16)

hippoWmmaSetF32:

• hippo: template hippoWmmaSetF32(v: var HippoWmmaFloat8; idx: int; val: cfloat)

hippoWmmaZeroF32:

• hippo: template hippoWmmaZeroF32(): HippoWmmaFloat8

hipStreamBeginCapture:

• hippo: proc hipStreamBeginCapture(stream: hipStream_t; mode: hipStreamCaptureMode): hipError_t

hipStreamCaptureMode:

• hippo: enum hipStreamCaptureMode

hipStreamCreate:

• hippo: proc hipStreamCreate(stream: ptr hipStream_t): hipError_t

hipStreamDestroy:

• hippo: proc hipStreamDestroy(stream: hipStream_t): hipError_t

hipStreamEndCapture:

• hippo: proc hipStreamEndCapture(stream: hipStream_t; pGraph: ptr hipGraph_t): hipError_t

hipStreamSynchronize:

• hippo: proc hipStreamSynchronize(stream: hipStream_t): hipError_t

hipStream_t:

• hippo: type hipStream_t

hipStreamWaitEvent:

• hippo: proc hipStreamWaitEvent(stream: hipStream_t; event: hipEvent_t; flags: uint32_t = 0'u32): hipError_t

hipSymbol:

• hippo: proc hipSymbol[T](sym: var T): pointer

hipSyncthreads:

• hippo: proc hipSyncthreads()

loadU32:

• hippo: proc loadU32(p: ptr uint8): uint32

log:

• hippo: proc log(x: cdouble): cdouble

logf:

• hippo: proc logf(x: cfloat): cfloat

newDim3:

• hippo: proc newDim3(x: uint32_t = 1; y: uint32_t = 1; z: uint32_t = 1): Dim3

pow:

• hippo: proc pow(base: cdouble; exp: cdouble): cdouble

powf:

• hippo: proc powf(base: cfloat; exp: cfloat): cfloat

roundf:

• hippo: proc roundf(x: cfloat): cfloat

shfl:

• hippo: proc shfl(val: cfloat; srcLane: cint): cfloat
• hippo: proc shfl(val: cint; srcLane: cint): cint

shflDown:

• hippo: proc shflDown(val: cfloat; delta: cint): cfloat
• hippo: proc shflDown(val: cint; delta: cint): cint

sin:

• hippo: proc sin(x: cdouble): cdouble

sinf:

• hippo: proc sinf(x: cfloat): cfloat

size_t:

• hippo: type size_t

sqrt:

• hippo: proc sqrt(x: cdouble): cdouble

sqrtf:

• hippo: proc sqrtf(x: cfloat): cfloat

ThreadIdx:

• hippo: object ThreadIdx

threadIdx:

• hippo: let threadIdx

toConstCString:

• hippo: converter toConstCString(self: cstring): ConstCString

toCString:

• hippo: converter toCString(self: ConstCString): cstring

uint16_t:

• hippo: type uint16_t

uint32_t:

• hippo: type uint32_t

uint64_t:

• hippo: type uint64_t

uint8_t:

• hippo: type uint8_t

vsubss4:

• hippo: proc vsubss4(a, b: cint): cint

WarpSize:

• hippo: const WarpSize

wmmaF32_16x16x16_f16_w32:

• hippo: proc wmmaF32_16x16x16_f16_w32(a, b: WmmaHalf16; c: WmmaFloat8): WmmaFloat8

WmmaFloat8:

• hippo: object WmmaFloat8

wmmaGetF32:

• hippo: proc wmmaGetF32(v: WmmaFloat8; idx: cint): cfloat

WmmaHalf16:

• hippo: object WmmaHalf16

wmmaSetF16:

• hippo: proc wmmaSetF16(v: var WmmaHalf16; idx: cint; val: cushort)

wmmaSetF32:

• hippo: proc wmmaSetF32(v: var WmmaFloat8; idx: cint; val: cfloat)

wmmaZeroF32:

• hippo: proc wmmaZeroF32(): WmmaFloat8