cu

package module

Go to main page

Versions in this module

v0

v0.10.0-working

Aug 4, 2021

v0.9.4

Aug 2, 2021

Changes in this version

+ const CapturedEvent

+ const CompatNotSupportedOnDevice

+ const CooperativeLaunchTooLarge

+ const GraphExecUpdateFailure

+ const IllegalState

+ const JitCompilerNotFound

+ const StreamCaptureImplicit

+ const StreamCaptureInvalidated

+ const StreamCaptureIsolation

+ const StreamCaptureMerge

+ const StreamCaptureUnjoined

+ const StreamCaptureUnmatched

+ const StreamCaptureUnsupported

+ const StreamCaptureWrongThread

+ const SystemDriverMismatch

+ const SystemNotReady

+ const Timeout

+ func LauncCooperativeKernelMultiDevice()

+ func LaunchCooperativeKernel()

+ func RegisterFunc(fn HostFunction) unsafe.Pointer

type BatchedContext

+ func (ctx *BatchedContext) Signal()

type CUContext

+ func (ctx *CUContext) ResetL2Cache() error

+ type CopyParams struct

+ Depth uint64

+ DstArray Array

+ DstDevicePtr DevicePtr

+ DstHeight uint64

+ DstHost unsafe.Pointer

+ DstLOD uint64

+ DstPitch uint64

+ DstType MemoryType

+ DstXInBytes uint64

+ DstY uint64

+ DstZ uint64

+ Height uint64

+ Reserved0 unsafe.Pointer

+ Reserved1 unsafe.Pointer

+ SrcArray Array

+ SrcDevicePtr DevicePtr

+ SrcHeight uint64

+ SrcHost unsafe.Pointer

+ SrcLOD uint64

+ SrcPitch uint64

+ SrcType MemoryType

+ SrcXInBytes uint64

+ SrcY uint64

+ SrcZ uint64

+ WidthInBytes uint64

type Ctx

+ func (ctx *Ctx) ResetL2Cache()

type Device

+ func (d Device) UUID() (retVal uuid.UUID, err error)

+ type ExecGraph struct

+ func (g ExecGraph) Destroy() error

+ func (g ExecGraph) String() string

+ type Graph struct

+ func MakeGraph() (Graph, error)

+ func (g Graph) AddDependencies(from, to []Node) error

+ func (g Graph) AddEmptyNode(children []Node) (Node, error)

+ func (g Graph) AddHostNode(children []Node, params *HostNodeParams) (Node, error)

+ func (g Graph) AddKernelNode(children []Node, params *KernelNodeParams) (Node, error)

+ func (g Graph) AddMemcpyNode(children []Node, params *CopyParams, ctx Context) (Node, error)

+ func (g Graph) AddMemsetNode(children []Node, params *MemsetParams, ctx Context) (Node, error)

+ func (g Graph) Clone() (Graph, error)

+ func (g Graph) Destroy() error

+ func (g Graph) Edges(from, to []Node) (edges []int, numEdges int, err error)

+ func (g Graph) String() string

+ type HostFunction func()

+ type HostNodeParams struct

+ Data unsafe.Pointer

+ Func HostFunction

+ type KernelNodeParams struct

+ BlockDimX uint

+ BlockDimY uint

+ BlockDimZ uint

+ Func Function

+ GridDimX uint

+ GridDimY uint

+ GridDimZ uint

+ Params []*KernelNodeParams

+ SharedMemBytes uint

+ type MemsetParams struct

+ Dst DevicePtr

+ ElementSize uint

+ Height uint64

+ Pitch uint64

+ Value uint

+ Width uint64

+ type Node struct

+ func (n Node) AddChild(in Graph, children []Node, childGraph Graph) (Node, error)

+ func (n Node) Destroy() error

+ func (n Node) String() string

v0.9.3

May 5, 2020

v0.9.2

Feb 12, 2020

v0.9.1

Sep 4, 2019

Changes in this version

+ var NoStream = Stream

type Array

+ func (hArray Array) Destroy() (err error)

type BatchedContext

+ func (ctx *BatchedContext) Close() error

+ func (ctx *BatchedContext) IsInitialized() bool

type CUContext

+ func (ctx *CUContext) Destroy() error

type Context

+ Close func() error

type Ctx

+ func (ctx *Ctx) Close() error

+ func (ctx *Ctx) ModuleSurfRef(mod Module, name string) (SurfRef, error)

+ func (ctx *Ctx) ModuleTexRef(mod Module, name string) (TexRef, error)

type DevicePtr

+ func (d DevicePtr) IsCUDAMemory() bool

type Function

+ func (fn Function) Launch(gridDimX, gridDimY, gridDimZ int, blockDimX, blockDimY, blockDimZ int, ...) error

+ type JITCacheMode struct

+ Value JITCacheModeOption

+ type JITCacheModeOption uint64

+ const JITCacheCA

+ const JITCacheCG

+ const JITCacheNone

+ type JITErrorLogBuffer struct

+ Buffer []byte

+ type JITFallbackOption uint64

+ const JITPreferBinary

+ const JITPreferPTX

+ type JITFallbackStrategy struct

+ Value JITFallbackOption

+ type JITGenerateDebugInfo struct

+ Enabled bool

+ type JITGenerateLineInfo struct

+ Enabled bool

+ type JITInfoLogBuffer struct

+ Buffer []byte

+ type JITInputType uint64

+ const JITInputCUBIN

+ const JITInputFatBinary

+ const JITInputLibrary

+ const JITInputObject

+ const JITInputPTX

+ type JITLogVerbose struct

+ Enabled bool

+ type JITMaxRegisters struct

+ Value uint

+ type JITOptimizationLevel struct

+ Value uint

+ type JITOption interface

+ type JITTarget struct

+ Value JITTargetOption

+ type JITTargetFromContext struct

+ type JITTargetOption uint64

+ const JITTarget20

+ const JITTarget21

+ const JITTarget30

+ const JITTarget32

+ const JITTarget35

+ const JITTarget37

+ const JITTarget50

+ const JITTarget52

+ const JITTarget53

+ const JITTarget60

+ const JITTarget61

+ const JITTarget62

+ type JITThreadsPerBlock struct

+ Value uint

+ type JITWallTime struct

+ Result float32

+ type LinkState struct

+ func NewLink(options ...JITOption) (*LinkState, error)

+ func (link *LinkState) AddData(input JITInputType, data string, name string, options ...JITOption) error

+ func (link *LinkState) AddFile(input JITInputType, path string, options ...JITOption) error

+ func (link *LinkState) Complete() (string, error)

+ func (link *LinkState) Destroy() error

type Module

+ func LoadDataEx(image string, options ...JITOption) (Module, error)

+ func LoadFatBinary(image string) (Module, error)

+ func (hmod Module) Unload() (err error)

+ func (mod Module) SurfRef(name string) (SurfRef, error)

+ func (mod Module) TexRef(name string) (TexRef, error)

type Stream

+ func (hStream *Stream) Destroy() error

+ func (s Stream) C() C.CUstream

v0.9.0-working

Aug 18, 2018

v0.9.0-beta

Aug 12, 2018

v0.8.0

Dec 17, 2017

Changes in this version

+ const AlreadyAcquired

+ const AlreadyMapped

+ const ArrayIsMapped

+ const Assert

+ const ContextAlreadyCurrent

+ const ContextAlreadyInUse

+ const ContextIsDestroyed

+ const DEBUG

+ const Deinitialized

+ const EccUncorrectable

+ const FileNotFound

+ const HardwareStackError

+ const HostMemoryAlreadyRegistered

+ const HostMemoryNotRegistered

+ const IllegalAddress

+ const IllegalInstruction

+ const InvalidAddressSpace

+ const InvalidContext

+ const InvalidDevice

+ const InvalidGraphicsContext

+ const InvalidHandle

+ const InvalidImage

+ const InvalidPc

+ const InvalidPtx

+ const InvalidSource

+ const InvalidValue

+ const LaunchFailed

+ const LaunchIncompatibleTexturing

+ const LaunchOutOfResources

+ const LaunchTimeout

+ const MapFailed

+ const MisalignedAddress

+ const NoBinaryForGpu

+ const NoDevice

+ const NotFound

+ const NotInitialized

+ const NotMapped

+ const NotMappedAsArray

+ const NotMappedAsPointer

+ const NotPermitted

+ const NotReady

+ const NotSupported

+ const NvlinkUncorrectable

+ const OperatingSystem

+ const OutOfMemory

+ const PeerAccessAlreadyEnabled

+ const PeerAccessNotEnabled

+ const PeerAccessUnsupported

+ const PrimaryContextActive

+ const ProfilerAlreadyStarted

+ const ProfilerAlreadyStopped

+ const ProfilerDisabled

+ const ProfilerNotInitialized

+ const SharedObjectInitFailed

+ const SharedObjectSymbolNotFound

+ const Success

+ const TooManyPeers

+ const Unknown

+ const UnmapFailed

+ const UnsupportedLimit

+ func AverageQueueLength() int

+ func BlockingCallers() map[string]int

+ func DestroyArray(hArray Array) (err error)

+ func DestroyContext(ctx *CUContext) error

+ func DestroyEvent(event *Event) (err error)

+ func DestroyStream(hStream *Stream) error

+ func Limits(limit Limit) (pvalue int64, err error)

+ func MemFree(dptr DevicePtr) (err error)

+ func MemFreeHost(p unsafe.Pointer) (err error)

+ func MemInfo() (free int64, total int64, err error)

+ func Memcpy(dst DevicePtr, src DevicePtr, ByteCount int64) (err error)

+ func Memcpy2D(pCopy Memcpy2dParam) (err error)

+ func Memcpy2DAsync(pCopy Memcpy2dParam, hStream Stream) (err error)

+ func Memcpy2DUnaligned(pCopy Memcpy2dParam) (err error)

+ func Memcpy3D(pCopy Memcpy3dParam) (err error)

+ func Memcpy3DAsync(pCopy Memcpy3dParam, hStream Stream) (err error)

+ func Memcpy3DPeer(pCopy Memcpy3dPeerParam) (err error)

+ func Memcpy3DPeerAsync(pCopy Memcpy3dPeerParam, hStream Stream) (err error)

+ func MemcpyAsync(dst DevicePtr, src DevicePtr, ByteCount int64, hStream Stream) (err error)

+ func MemcpyAtoA(dstArray Array, dstOffset int64, srcArray Array, srcOffset int64, ...) (err error)

+ func MemcpyAtoD(dstDevice DevicePtr, srcArray Array, srcOffset int64, ByteCount int64) (err error)

+ func MemcpyAtoH(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64) (err error)

+ func MemcpyAtoHAsync(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64, ...) (err error)

+ func MemcpyDtoA(dstArray Array, dstOffset int64, srcDevice DevicePtr, ByteCount int64) (err error)

+ func MemcpyDtoD(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64) (err error)

+ func MemcpyDtoDAsync(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64, hStream Stream) (err error)

+ func MemcpyDtoH(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64) (err error)

+ func MemcpyDtoHAsync(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64, hStream Stream) (err error)

+ func MemcpyHtoA(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64) (err error)

+ func MemcpyHtoAAsync(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64, ...) (err error)

+ func MemcpyHtoD(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64) (err error)

+ func MemcpyHtoDAsync(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64, hStream Stream) (err error)

+ func MemcpyPeer(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...) (err error)

+ func MemcpyPeerAsync(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...) (err error)

+ func MemsetD16(dstDevice DevicePtr, us uint16, N int64) (err error)

+ func MemsetD16Async(dstDevice DevicePtr, us uint16, N int64, hStream Stream) (err error)

+ func MemsetD2D16(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64) (err error)

+ func MemsetD2D16Async(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64, ...) (err error)

+ func MemsetD2D32(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64) (err error)

+ func MemsetD2D32Async(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64, ...) (err error)

+ func MemsetD2D8(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64) (err error)

+ func MemsetD2D8Async(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64, ...) (err error)

+ func MemsetD32(dstDevice DevicePtr, ui uint32, N int64) (err error)

+ func MemsetD32Async(dstDevice DevicePtr, ui uint, N int64, hStream Stream) (err error)

+ func MemsetD8(dstDevice DevicePtr, uc byte, N int64) (err error)

+ func MemsetD8Async(dstDevice DevicePtr, uc byte, N int64, hStream Stream) (err error)

+ func NumDevices() (count int, err error)

+ func PushCurrentCtx(ctx CUContext) (err error)

+ func QueueLengths() []int

+ func SetCurrentCacheConfig(config FuncCacheConfig) (err error)

+ func SetCurrentContext(ctx CUContext) (err error)

+ func SetLimit(limit Limit, value int64) (err error)

+ func SetSharedMemConfig(config SharedConfig) (err error)

+ func StreamPriorityRange() (leastPriority int, greatestPriority int, err error)

+ func Synchronize() (err error)

+ func Unload(hmod Module) (err error)

+ func Version() int

+ type AddressMode byte

+ const BorderMode

+ const ClampMode

+ const MirrorMode

+ const WrapMode

+ type Array uintptr

+ func Make3DArray(pAllocateArray Array3Desc) (pHandle Array, err error)

+ func MakeArray(pAllocateArray ArrayDesc) (pHandle Array, err error)

+ func (hArray Array) Descriptor() (pArrayDescriptor ArrayDesc, err error)

+ func (hArray Array) Descriptor3() (pArrayDescriptor Array3Desc, err error)

+ type Array3Desc struct

+ Depth uint

+ Flags uint

+ Format Format

+ Height uint

+ NumChannels uint

+ Width uint

+ type ArrayDesc struct

+ Format Format

+ Height uint

+ NumChannels uint

+ Width uint

+ type BatchedContext struct

+ func NewBatchedContext(c Context, d Device) *BatchedContext

+ func (ctx *BatchedContext) AllocAndCopy(p unsafe.Pointer, bytesize int64) (retVal DevicePtr, err error)

+ func (ctx *BatchedContext) Cleanup()

+ func (ctx *BatchedContext) DoWork()

+ func (ctx *BatchedContext) Errors() error

+ func (ctx *BatchedContext) FirstError() error

+ func (ctx *BatchedContext) LaunchAndSync(function Function, gridDimX, gridDimY, gridDimZ int, ...)

+ func (ctx *BatchedContext) LaunchKernel(function Function, gridDimX, gridDimY, gridDimZ int, ...)

+ func (ctx *BatchedContext) MemAlloc(bytesize int64) (retVal DevicePtr, err error)

+ func (ctx *BatchedContext) MemAllocManaged(bytesize int64, flags MemAttachFlags) (retVal DevicePtr, err error)

+ func (ctx *BatchedContext) MemFree(mem DevicePtr)

+ func (ctx *BatchedContext) MemFreeHost(p unsafe.Pointer)

+ func (ctx *BatchedContext) Memcpy(dst, src DevicePtr, byteCount int64)

+ func (ctx *BatchedContext) MemcpyDtoH(dst unsafe.Pointer, src DevicePtr, byteCount int64)

+ func (ctx *BatchedContext) MemcpyHtoD(dst DevicePtr, src unsafe.Pointer, byteCount int64)

+ func (ctx *BatchedContext) Run(errChan chan error) error

+ func (ctx *BatchedContext) SetCurrent()

+ func (ctx *BatchedContext) Synchronize()

+ func (ctx *BatchedContext) WorkAvailable() <-chan struct{}

+ type CUContext uintptr

+ func CurrentContext() (pctx CUContext, err error)

+ func PopCurrentCtx() (pctx CUContext, err error)

+ func (ctx CUContext) APIVersion() (version uint, err error)

+ func (ctx CUContext) Lock() error

+ func (ctx CUContext) String() string

+ func (ctx CUContext) Unlock() error

+ func (peerContext CUContext) DisablePeerAccess() (err error)

+ func (peerContext CUContext) EnablePeerAccess(Flags uint) (err error)

+ type Context interface

+ Address func(hTexRef TexRef) (pdptr DevicePtr, err error)

+ AddressMode func(hTexRef TexRef, dim int) (pam AddressMode, err error)

+ Array func(hTexRef TexRef) (phArray Array, err error)

+ AttachMemAsync func(hStream Stream, dptr DevicePtr, length int64, flags uint)

+ BorderColor func(hTexRef TexRef) (pBorderColor [3]float32, err error)

+ CUDAContext func() CUContext

+ CurrentCacheConfig func() (pconfig FuncCacheConfig, err error)

+ CurrentDevice func() (device Device, err error)

+ CurrentFlags func() (flags ContextFlags, err error)

+ Descriptor func(hArray Array) (pArrayDescriptor ArrayDesc, err error)

+ Descriptor3 func(hArray Array) (pArrayDescriptor Array3Desc, err error)

+ DestroyArray func(hArray Array)

+ DestroyEvent func(event *Event)

+ DestroyStream func(hStream *Stream)

+ DisablePeerAccess func(peerContext CUContext)

+ Do func(fn func() error) error

+ Elapsed func(hStart Event, hEnd Event) (pMilliseconds float64, err error)

+ EnablePeerAccess func(peerContext CUContext, Flags uint)

+ ErrChan func() chan<- error

+ Error func() error

+ FilterMode func(hTexRef TexRef) (pfm FilterMode, err error)

+ Format func(hTexRef TexRef) (pFormat Format, pNumChannels int, err error)

+ FunctionAttribute func(fn Function, attrib FunctionAttribute) (pi int, err error)

+ GetArray func(hSurfRef SurfRef) (phArray Array, err error)

+ LaunchKernel func(fn Function, gridDimX, gridDimY, gridDimZ int, ...)

+ Limits func(limit Limit) (pvalue int64, err error)

+ Load func(name string) (m Module, err error)

+ MakeEvent func(flags EventFlags) (event Event, err error)

+ MakeStream func(flags StreamFlags) (stream Stream, err error)

+ MakeStreamWithPriority func(priority int, flags StreamFlags) (stream Stream, err error)

+ MaxAnisotropy func(hTexRef TexRef) (pmaxAniso int, err error)

+ MemAlloc func(bytesize int64) (dptr DevicePtr, err error)

+ MemAllocManaged func(bytesize int64, flags MemAttachFlags) (dptr DevicePtr, err error)

+ MemAllocPitch func(WidthInBytes int64, Height int64, ElementSizeBytes uint) (dptr DevicePtr, pPitch int64, err error)

+ MemFree func(dptr DevicePtr)

+ MemFreeHost func(p unsafe.Pointer)

+ MemInfo func() (free int64, total int64, err error)

+ Memcpy func(dst DevicePtr, src DevicePtr, ByteCount int64)

+ Memcpy2D func(pCopy Memcpy2dParam)

+ Memcpy2DAsync func(pCopy Memcpy2dParam, hStream Stream)

+ Memcpy2DUnaligned func(pCopy Memcpy2dParam)

+ Memcpy3D func(pCopy Memcpy3dParam)

+ Memcpy3DAsync func(pCopy Memcpy3dParam, hStream Stream)

+ Memcpy3DPeer func(pCopy Memcpy3dPeerParam)

+ Memcpy3DPeerAsync func(pCopy Memcpy3dPeerParam, hStream Stream)

+ MemcpyAsync func(dst DevicePtr, src DevicePtr, ByteCount int64, hStream Stream)

+ MemcpyAtoA func(dstArray Array, dstOffset int64, srcArray Array, srcOffset int64, ...)

+ MemcpyAtoD func(dstDevice DevicePtr, srcArray Array, srcOffset int64, ByteCount int64)

+ MemcpyAtoH func(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64)

+ MemcpyAtoHAsync func(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64, ...)

+ MemcpyDtoA func(dstArray Array, dstOffset int64, srcDevice DevicePtr, ByteCount int64)

+ MemcpyDtoD func(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64)

+ MemcpyDtoDAsync func(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64, hStream Stream)

+ MemcpyDtoH func(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64)

+ MemcpyDtoHAsync func(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64, hStream Stream)

+ MemcpyHtoA func(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64)

+ MemcpyHtoAAsync func(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64, ...)

+ MemcpyHtoD func(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64)

+ MemcpyHtoDAsync func(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64, hStream Stream)

+ MemcpyPeer func(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...)

+ MemcpyPeerAsync func(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...)

+ MemsetD16 func(dstDevice DevicePtr, us uint16, N int64)

+ MemsetD16Async func(dstDevice DevicePtr, us uint16, N int64, hStream Stream)

+ MemsetD2D16 func(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64)

+ MemsetD2D16Async func(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64, ...)

+ MemsetD2D32 func(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64)

+ MemsetD2D32Async func(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64, ...)

+ MemsetD2D8 func(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64)

+ MemsetD2D8Async func(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64, ...)

+ MemsetD32 func(dstDevice DevicePtr, ui uint, N int64)

+ MemsetD32Async func(dstDevice DevicePtr, ui uint, N int64, hStream Stream)

+ MemsetD8 func(dstDevice DevicePtr, uc byte, N int64)

+ MemsetD8Async func(dstDevice DevicePtr, uc byte, N int64, hStream Stream)

+ ModuleFunction func(m Module, name string) (function Function, err error)

+ ModuleGlobal func(m Module, name string) (dptr DevicePtr, size int64, err error)

+ Priority func(hStream Stream) (priority int, err error)

+ QueryEvent func(hEvent Event)

+ QueryStream func(hStream Stream)

+ Record func(hEvent Event, hStream Stream)

+ Run func(chan error) error

+ SetAddress func(hTexRef TexRef, dptr DevicePtr, bytes int64) (ByteOffset int64, err error)

+ SetAddress2D func(hTexRef TexRef, desc ArrayDesc, dptr DevicePtr, Pitch int64)

+ SetAddressMode func(hTexRef TexRef, dim int, am AddressMode)

+ SetBorderColor func(hTexRef TexRef, pBorderColor [3]float32)

+ SetCacheConfig func(fn Function, config FuncCacheConfig)

+ SetCurrentCacheConfig func(config FuncCacheConfig)

+ SetFilterMode func(hTexRef TexRef, fm FilterMode)

+ SetFormat func(hTexRef TexRef, fmt Format, NumPackedComponents int)

+ SetFunctionSharedMemConfig func(fn Function, config SharedConfig)

+ SetLimit func(limit Limit, value int64)

+ SetMaxAnisotropy func(hTexRef TexRef, maxAniso uint)

+ SetMipmapFilterMode func(hTexRef TexRef, fm FilterMode)

+ SetMipmapLevelBias func(hTexRef TexRef, bias float64)

+ SetMipmapLevelClamp func(hTexRef TexRef, minMipmapLevelClamp float64, maxMipmapLevelClamp float64)

+ SetSharedMemConfig func(config SharedConfig)

+ SetTexRefFlags func(hTexRef TexRef, Flags TexRefFlags)

+ SharedMemConfig func() (pConfig SharedConfig, err error)

+ StreamFlags func(hStream Stream) (flags uint, err error)

+ StreamPriorityRange func() (leastPriority int, greatestPriority int, err error)

+ SurfRefSetArray func(hSurfRef SurfRef, hArray Array, Flags uint)

+ Synchronize func()

+ SynchronizeEvent func(hEvent Event)

+ SynchronizeStream func(hStream Stream)

+ TexRefFlags func(hTexRef TexRef) (pFlags uint, err error)

+ TexRefSetArray func(hTexRef TexRef, hArray Array, Flags uint)

+ Unload func(hmod Module)

+ Wait func(hStream Stream, hEvent Event, Flags uint)

+ WaitOnValue32 func(stream Stream, addr DevicePtr, value uint32, flags uint)

+ Work func() <-chan func() error

+ WriteValue32 func(stream Stream, addr DevicePtr, value uint32, flags uint)

+ type ContextFlags byte

+ const FlagsMas

+ const LMemResizeToMax

+ const MapHost

+ const SchedAuto

+ const SchedBlockingSync

+ const SchedMask

+ const SchedSpin

+ const SchedYield

+ func CurrentFlags() (flags ContextFlags, err error)

+ type Ctx struct

+ func CtxFromCUContext(d Device, cuctx CUContext, flags ContextFlags) *Ctx

+ func NewContext(d Device, flags ContextFlags) *Ctx

+ func NewManuallyManagedContext(d Device, flags ContextFlags) *Ctx

+ func (ctx *Ctx) Address(hTexRef TexRef) (pdptr DevicePtr, err error)

+ func (ctx *Ctx) AddressMode(hTexRef TexRef, dim int) (pam AddressMode, err error)

+ func (ctx *Ctx) Array(hTexRef TexRef) (phArray Array, err error)

+ func (ctx *Ctx) AttachMemAsync(hStream Stream, dptr DevicePtr, length int64, flags uint)

+ func (ctx *Ctx) BorderColor(hTexRef TexRef) (pBorderColor [3]float32, err error)

+ func (ctx *Ctx) CUDAContext() CUContext

+ func (ctx *Ctx) CanAccessPeer(dev Device, peerDev Device) (canAccessPeer int, err error)

+ func (ctx *Ctx) CurrentCacheConfig() (pconfig FuncCacheConfig, err error)

+ func (ctx *Ctx) CurrentDevice() (device Device, err error)

+ func (ctx *Ctx) CurrentFlags() (flags ContextFlags, err error)

+ func (ctx *Ctx) Descriptor(hArray Array) (pArrayDescriptor ArrayDesc, err error)

+ func (ctx *Ctx) Descriptor3(hArray Array) (pArrayDescriptor Array3Desc, err error)

+ func (ctx *Ctx) DestroyArray(hArray Array)

+ func (ctx *Ctx) DestroyEvent(event *Event)

+ func (ctx *Ctx) DestroyStream(hStream *Stream)

+ func (ctx *Ctx) DisablePeerAccess(peerContext CUContext)

+ func (ctx *Ctx) Do(fn func() error) error

+ func (ctx *Ctx) Elapsed(hStart Event, hEnd Event) (pMilliseconds float64, err error)

+ func (ctx *Ctx) EnablePeerAccess(peerContext CUContext, Flags uint)

+ func (ctx *Ctx) ErrChan() chan<- error

+ func (ctx *Ctx) Error() error

+ func (ctx *Ctx) FilterMode(hTexRef TexRef) (pfm FilterMode, err error)

+ func (ctx *Ctx) Format(hTexRef TexRef) (pFormat Format, pNumChannels int, err error)

+ func (ctx *Ctx) FunctionAttribute(fn Function, attrib FunctionAttribute) (pi int, err error)

+ func (ctx *Ctx) GetArray(hSurfRef SurfRef) (phArray Array, err error)

+ func (ctx *Ctx) LaunchKernel(fn Function, gridDimX, gridDimY, gridDimZ int, ...)

+ func (ctx *Ctx) Limits(limit Limit) (pvalue int64, err error)

+ func (ctx *Ctx) Load(name string) (m Module, err error)

+ func (ctx *Ctx) MakeEvent(flags EventFlags) (event Event, err error)

+ func (ctx *Ctx) MakeStream(flags StreamFlags) (stream Stream, err error)

+ func (ctx *Ctx) MakeStreamWithPriority(priority int, flags StreamFlags) (stream Stream, err error)

+ func (ctx *Ctx) MaxAnisotropy(hTexRef TexRef) (pmaxAniso int, err error)

+ func (ctx *Ctx) MemAlloc(bytesize int64) (dptr DevicePtr, err error)

+ func (ctx *Ctx) MemAllocManaged(bytesize int64, flags MemAttachFlags) (dptr DevicePtr, err error)

+ func (ctx *Ctx) MemAllocPitch(WidthInBytes int64, Height int64, ElementSizeBytes uint) (dptr DevicePtr, pPitch int64, err error)

+ func (ctx *Ctx) MemFree(dptr DevicePtr)

+ func (ctx *Ctx) MemFreeHost(p unsafe.Pointer)

+ func (ctx *Ctx) MemInfo() (free int64, total int64, err error)

+ func (ctx *Ctx) Memcpy(dst DevicePtr, src DevicePtr, ByteCount int64)

+ func (ctx *Ctx) Memcpy2D(pCopy Memcpy2dParam)

+ func (ctx *Ctx) Memcpy2DAsync(pCopy Memcpy2dParam, hStream Stream)

+ func (ctx *Ctx) Memcpy2DUnaligned(pCopy Memcpy2dParam)

+ func (ctx *Ctx) Memcpy3D(pCopy Memcpy3dParam)

+ func (ctx *Ctx) Memcpy3DAsync(pCopy Memcpy3dParam, hStream Stream)

+ func (ctx *Ctx) Memcpy3DPeer(pCopy Memcpy3dPeerParam)

+ func (ctx *Ctx) Memcpy3DPeerAsync(pCopy Memcpy3dPeerParam, hStream Stream)

+ func (ctx *Ctx) MemcpyAsync(dst DevicePtr, src DevicePtr, ByteCount int64, hStream Stream)

+ func (ctx *Ctx) MemcpyAtoA(dstArray Array, dstOffset int64, srcArray Array, srcOffset int64, ...)

+ func (ctx *Ctx) MemcpyAtoD(dstDevice DevicePtr, srcArray Array, srcOffset int64, ByteCount int64)

+ func (ctx *Ctx) MemcpyAtoH(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64)

+ func (ctx *Ctx) MemcpyAtoHAsync(dstHost unsafe.Pointer, srcArray Array, srcOffset int64, ByteCount int64, ...)

+ func (ctx *Ctx) MemcpyDtoA(dstArray Array, dstOffset int64, srcDevice DevicePtr, ByteCount int64)

+ func (ctx *Ctx) MemcpyDtoD(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64)

+ func (ctx *Ctx) MemcpyDtoDAsync(dstDevice DevicePtr, srcDevice DevicePtr, ByteCount int64, hStream Stream)

+ func (ctx *Ctx) MemcpyDtoH(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64)

+ func (ctx *Ctx) MemcpyDtoHAsync(dstHost unsafe.Pointer, srcDevice DevicePtr, ByteCount int64, hStream Stream)

+ func (ctx *Ctx) MemcpyHtoA(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64)

+ func (ctx *Ctx) MemcpyHtoAAsync(dstArray Array, dstOffset int64, srcHost unsafe.Pointer, ByteCount int64, ...)

+ func (ctx *Ctx) MemcpyHtoD(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64)

+ func (ctx *Ctx) MemcpyHtoDAsync(dstDevice DevicePtr, srcHost unsafe.Pointer, ByteCount int64, hStream Stream)

+ func (ctx *Ctx) MemcpyPeer(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...)

+ func (ctx *Ctx) MemcpyPeerAsync(dstDevice DevicePtr, dstContext CUContext, srcDevice DevicePtr, ...)

+ func (ctx *Ctx) MemsetD16(dstDevice DevicePtr, us uint16, N int64)

+ func (ctx *Ctx) MemsetD16Async(dstDevice DevicePtr, us uint16, N int64, hStream Stream)

+ func (ctx *Ctx) MemsetD2D16(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64)

+ func (ctx *Ctx) MemsetD2D16Async(dstDevice DevicePtr, dstPitch int64, us uint16, Width int64, Height int64, ...)

+ func (ctx *Ctx) MemsetD2D32(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64)

+ func (ctx *Ctx) MemsetD2D32Async(dstDevice DevicePtr, dstPitch int64, ui uint, Width int64, Height int64, ...)

+ func (ctx *Ctx) MemsetD2D8(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64)

+ func (ctx *Ctx) MemsetD2D8Async(dstDevice DevicePtr, dstPitch int64, uc byte, Width int64, Height int64, ...)

+ func (ctx *Ctx) MemsetD32(dstDevice DevicePtr, ui uint, N int64)

+ func (ctx *Ctx) MemsetD32Async(dstDevice DevicePtr, ui uint, N int64, hStream Stream)

+ func (ctx *Ctx) MemsetD8(dstDevice DevicePtr, uc byte, N int64)

+ func (ctx *Ctx) MemsetD8Async(dstDevice DevicePtr, uc byte, N int64, hStream Stream)

+ func (ctx *Ctx) ModuleFunction(m Module, name string) (function Function, err error)

+ func (ctx *Ctx) ModuleGlobal(m Module, name string) (dptr DevicePtr, size int64, err error)

+ func (ctx *Ctx) Priority(hStream Stream) (priority int, err error)

+ func (ctx *Ctx) QueryEvent(hEvent Event)

+ func (ctx *Ctx) QueryStream(hStream Stream)

+ func (ctx *Ctx) Record(hEvent Event, hStream Stream)

+ func (ctx *Ctx) Run(errChan chan error) error

+ func (ctx *Ctx) SetAddress(hTexRef TexRef, dptr DevicePtr, bytes int64) (ByteOffset int64, err error)

+ func (ctx *Ctx) SetAddress2D(hTexRef TexRef, desc ArrayDesc, dptr DevicePtr, Pitch int64)

+ func (ctx *Ctx) SetAddressMode(hTexRef TexRef, dim int, am AddressMode)

+ func (ctx *Ctx) SetBorderColor(hTexRef TexRef, pBorderColor [3]float32)

+ func (ctx *Ctx) SetCacheConfig(fn Function, config FuncCacheConfig)

+ func (ctx *Ctx) SetCurrentCacheConfig(config FuncCacheConfig)

+ func (ctx *Ctx) SetFilterMode(hTexRef TexRef, fm FilterMode)

+ func (ctx *Ctx) SetFormat(hTexRef TexRef, fmt Format, NumPackedComponents int)

+ func (ctx *Ctx) SetFunctionSharedMemConfig(fn Function, config SharedConfig)

+ func (ctx *Ctx) SetLimit(limit Limit, value int64)

+ func (ctx *Ctx) SetMaxAnisotropy(hTexRef TexRef, maxAniso uint)

+ func (ctx *Ctx) SetMipmapFilterMode(hTexRef TexRef, fm FilterMode)

+ func (ctx *Ctx) SetMipmapLevelBias(hTexRef TexRef, bias float64)

+ func (ctx *Ctx) SetMipmapLevelClamp(hTexRef TexRef, minMipmapLevelClamp float64, maxMipmapLevelClamp float64)

+ func (ctx *Ctx) SetSharedMemConfig(config SharedConfig)

+ func (ctx *Ctx) SetTexRefFlags(hTexRef TexRef, Flags TexRefFlags)

+ func (ctx *Ctx) SharedMemConfig() (pConfig SharedConfig, err error)

+ func (ctx *Ctx) StreamFlags(hStream Stream) (flags uint, err error)

+ func (ctx *Ctx) StreamPriorityRange() (leastPriority int, greatestPriority int, err error)

+ func (ctx *Ctx) SurfRefSetArray(hSurfRef SurfRef, hArray Array, Flags uint)

+ func (ctx *Ctx) Synchronize()

+ func (ctx *Ctx) SynchronizeEvent(hEvent Event)

+ func (ctx *Ctx) SynchronizeStream(hStream Stream)

+ func (ctx *Ctx) TexRefFlags(hTexRef TexRef) (pFlags uint, err error)

+ func (ctx *Ctx) TexRefSetArray(hTexRef TexRef, hArray Array, Flags uint)

+ func (ctx *Ctx) Unload(hmod Module)

+ func (ctx *Ctx) Wait(hStream Stream, hEvent Event, Flags uint)

+ func (ctx *Ctx) WaitOnValue32(stream Stream, addr DevicePtr, value uint32, flags uint)

+ func (ctx *Ctx) Work() <-chan func() error

+ func (ctx *Ctx) WriteValue32(stream Stream, addr DevicePtr, value uint32, flags uint)

+ type Device int

+ const BadDevice

+ const CPU

+ func CurrentDevice() (device Device, err error)

+ func GetDevice(ordinal int) (device Device, err error)

+ func (d Device) ComputeCapability() (major, minor int, err error)

+ func (d Device) IsGPU() bool

+ func (d Device) MakeContext(flags ContextFlags) (CUContext, error)

+ func (d Device) Name() (string, error)

+ func (d Device) RetainPrimaryCtx() (primaryContext CUContext, err error)

+ func (d Device) String() string

+ func (dev Device) Attribute(attrib DeviceAttribute) (pi int, err error)

+ func (dev Device) Attributes(attrs ...DeviceAttribute) ([]int, error)

+ func (dev Device) CanAccessPeer(peerDev Device) (canAccessPeer int, err error)

+ func (dev Device) PrimaryCtxState() (flags ContextFlags, active int, err error)

+ func (dev Device) ReleasePrimaryCtx() (err error)

+ func (dev Device) ResetPrimaryCtx() (err error)

+ func (dev Device) SetPrimaryCtxFlags(flags ContextFlags) (err error)

+ func (dev Device) TotalMem() (bytes int64, err error)

+ func (srcDevice Device) P2PAttribute(attrib P2PAttribute, dstDevice Device) (value int, err error)

+ type DeviceAttribute int

+ const AsyncEngineCount

+ const CanMapHostMemory

+ const CanTex2dGather

+ const CanUseHostPointerForRegisteredMem

+ const ClockRate

+ const ComputeCapabilityMajor

+ const ComputeCapabilityMinor

+ const ComputeMode

+ const ComputePreemptionSupported

+ const ConcurrentKernels

+ const ConcurrentManagedAccess

+ const EccEnabled

+ const GlobalL1CacheSupported

+ const GlobalMemoryBusWidth

+ const GpuOverlap

+ const HostNativeAtomicSupported

+ const Integrated

+ const KernelExecTimeout

+ const L2CacheSize

+ const LocalL1CacheSupported

+ const ManagedMemory

+ const MaxBlockDimX

+ const MaxBlockDimY

+ const MaxBlockDimZ

+ const MaxGridDimX

+ const MaxGridDimY

+ const MaxGridDimZ

+ const MaxPitch

+ const MaxRegistersPerBlock

+ const MaxRegistersPerMultiprocessor

+ const MaxSharedMemoryPerBlock

+ const MaxSharedMemoryPerMultiprocessor

+ const MaxThreadsPerBlock

+ const MaxThreadsPerMultiprocessor

+ const MaximumSurface1dLayeredLayers

+ const MaximumSurface1dLayeredWidth

+ const MaximumSurface1dWidth

+ const MaximumSurface2dHeight

+ const MaximumSurface2dLayeredHeight

+ const MaximumSurface2dLayeredLayers

+ const MaximumSurface2dLayeredWidth

+ const MaximumSurface2dWidth

+ const MaximumSurface3dDepth

+ const MaximumSurface3dHeight

+ const MaximumSurface3dWidth

+ const MaximumSurfacecubemapLayeredLayers

+ const MaximumSurfacecubemapLayeredWidth

+ const MaximumSurfacecubemapWidth

+ const MaximumTexture1dLayeredLayers

+ const MaximumTexture1dLayeredWidth

+ const MaximumTexture1dLinearWidth

+ const MaximumTexture1dMipmappedWidth

+ const MaximumTexture1dWidth

+ const MaximumTexture2dArrayHeight

+ const MaximumTexture2dArrayNumslices

+ const MaximumTexture2dArrayWidth

+ const MaximumTexture2dGatherHeight

+ const MaximumTexture2dGatherWidth

+ const MaximumTexture2dHeight

+ const MaximumTexture2dLayeredHeight

+ const MaximumTexture2dLayeredLayers

+ const MaximumTexture2dLayeredWidth

+ const MaximumTexture2dLinearHeight

+ const MaximumTexture2dLinearPitch

+ const MaximumTexture2dLinearWidth

+ const MaximumTexture2dMipmappedHeight

+ const MaximumTexture2dMipmappedWidth

+ const MaximumTexture2dWidth

+ const MaximumTexture3dDepth

+ const MaximumTexture3dDepthAlternate

+ const MaximumTexture3dHeight

+ const MaximumTexture3dHeightAlternate

+ const MaximumTexture3dWidth

+ const MaximumTexture3dWidthAlternate

+ const MaximumTexturecubemapLayeredLayers

+ const MaximumTexturecubemapLayeredWidth

+ const MaximumTexturecubemapWidth

+ const MemoryClockRate

+ const MultiGpuBoard

+ const MultiGpuBoardGroupID

+ const MultiprocessorCount

+ const PageableMemoryAccess

+ const PciBusID

+ const PciDeviceID

+ const PciDomainID

+ const RegistersPerBlock

+ const SharedMemoryPerBlock

+ const SingleToDoublePrecisionPerfRatio

+ const StreamPrioritiesSupported

+ const SurfaceAlignment

+ const TccDriver

+ const TextureAlignment

+ const TexturePitchAlignment

+ const TotalConstantMemory

+ const UnifiedAddressing

+ const WarpSize

+ type DevicePtr uintptr

+ func AllocAndCopy(p unsafe.Pointer, bytesize int64) (DevicePtr, error)

+ func MemAlloc(bytesize int64) (dptr DevicePtr, err error)

+ func MemAllocManaged(bytesize int64, flags MemAttachFlags) (dptr DevicePtr, err error)

+ func MemAllocPitch(WidthInBytes int64, Height int64, ElementSizeBytes uint) (dptr DevicePtr, pPitch int64, err error)

+ func (d DevicePtr) AddressRange() (size int64, base DevicePtr, err error)

+ func (d DevicePtr) MemAdvise(count int64, advice MemAdvice, dev Device) error

+ func (d DevicePtr) MemPrefetchAsync(count int64, dst Device, hStream Stream) error

+ func (d DevicePtr) PtrAttribute(attr PointerAttribute) (unsafe.Pointer, error)

+ func (d DevicePtr) SetPtrAttribute(value unsafe.Pointer, attr PointerAttribute) error

+ func (d DevicePtr) String() string

+ func (mem DevicePtr) MemSize() uintptr

+ func (mem DevicePtr) MemoryType() (typ MemoryType, err error)

+ func (mem DevicePtr) Pointer() unsafe.Pointer

+ func (mem DevicePtr) Uintptr() uintptr

+ type ErrorLister interface

+ ListErrors func() []error

+ type Event uintptr

+ func MakeEvent(flags EventFlags) (event Event, err error)

+ func (hEvent Event) Query() (err error)

+ func (hEvent Event) Record(hStream Stream) (err error)

+ func (hEvent Event) Synchronize() (err error)

+ func (hStart Event) Elapsed(hEnd Event) (pMilliseconds float64, err error)

+ type EventFlags byte

+ const BlockingSyncEvent

+ const DefaultEvent

+ const DisableTiming

+ const InterprocessEvent

+ type FilterMode byte

+ const LinearFilterMode

+ const PointFilterMode

+ type Format byte

+ const Float16

+ const Float32

+ const Int16

+ const Int32

+ const Int8

+ const Uin32

+ const Uint16

+ const Uint8

+ type FuncCacheConfig byte

+ const PreferEqual

+ const PreferL1

+ const PreferNone

+ const PreferShared

+ func CurrentCacheConfig() (pconfig FuncCacheConfig, err error)

+ type Function uintptr

+ func (fn Function) Attribute(attrib FunctionAttribute) (pi int, err error)

+ func (fn Function) LaunchAndSync(...) error

+ func (fn Function) LaunchKernel(gridDimX, gridDimY, gridDimZ int, blockDimX, blockDimY, blockDimZ int, ...) error

+ func (fn Function) MaxActiveBlocksPerMultiProcessor(blockSize int, dynamicSmemSize int64) (int, error)

+ func (fn Function) MaxActiveBlocksPerMultiProcessorWithFlags(blockSize int, dynamicSmemSize int64, flags OccupancyFlags) (int, error)

+ func (fn Function) SetCacheConfig(config FuncCacheConfig) (err error)

+ func (fn Function) SetSharedMemConfig(config SharedConfig) (err error)

+ type FunctionAttribute int

+ const BinaryVersion

+ const CacheModeCa

+ const ConstSizeBytes

+ const FnMaxThreadsPerBlock

+ const LocalSizeBytes

+ const NumRegs

+ const PtxVersion

+ const SharedSizeBytes

+ type Limit byte

+ const DevRuntimePendingLaunchCount

+ const DevRuntimeSyncDepth

+ const MallocHeapSize

+ const PrintfFIFOSize

+ const StackSize

+ type MemAdvice byte

+ const SetAccessedBy

+ const SetPreferredLocation

+ const SetReadMostly

+ const UnsetAccessedBy

+ const UnsetPreferredLocation

+ const UnsetReadMostly

+ type MemAttachFlags byte

+ const AttachGlobal

+ const AttachHost

+ const AttachSingle

+ type Memcpy2dParam struct

+ DstArray Array

+ DstDevice DevicePtr

+ DstHost unsafe.Pointer

+ DstMemoryType MemoryType

+ DstPitch int64

+ DstXInBytes int64

+ DstY int64

+ Height int64

+ SrcArray Array

+ SrcDevice DevicePtr

+ SrcHost unsafe.Pointer

+ SrcMemoryType MemoryType

+ SrcPitch int64

+ SrcXInBytes int64

+ SrcY int64

+ WidthInBytes int64

+ type Memcpy3dParam struct

+ Depth int64

+ DstArray Array

+ DstDevice DevicePtr

+ DstHeight int64

+ DstHost unsafe.Pointer

+ DstLOD int64

+ DstMemoryType MemoryType

+ DstPitch int64

+ DstXInBytes int64

+ DstY int64

+ DstZ int64

+ Height int64

+ SrcArray Array

+ SrcDevice DevicePtr

+ SrcHeight int64

+ SrcHost unsafe.Pointer

+ SrcLOD int64

+ SrcMemoryType MemoryType

+ SrcPitch int64

+ SrcXInBytes int64

+ SrcY int64

+ SrcZ int64

+ WidthInBytes int64

+ type Memcpy3dPeerParam struct

+ Depth int64

+ DstArray Array

+ DstContext CUContext

+ DstDevice DevicePtr

+ DstHeight int64

+ DstHost unsafe.Pointer

+ DstLOD int64

+ DstMemoryType MemoryType

+ DstPitch int64

+ DstXInBytes int64

+ DstY int64

+ DstZ int64

+ Height int64

+ SrcArray Array

+ SrcContext CUContext

+ SrcDevice DevicePtr

+ SrcHeight int64

+ SrcHost unsafe.Pointer

+ SrcLOD int64

+ SrcMemoryType MemoryType

+ SrcPitch int64

+ SrcXInBytes int64

+ SrcY int64

+ SrcZ int64

+ WidthInBytes int64

+ type MemoryType byte

+ const ArrayMemory

+ const DeviceMemory

+ const HostMemory

+ const UnifiedMemory

+ type Module uintptr

+ func Load(name string) (Module, error)

+ func LoadData(image string) (Module, error)

+ func (m Module) Function(name string) (Function, error)

+ func (m Module) Global(name string) (DevicePtr, int64, error)

+ type OccupancyFlags byte

+ const DefaultOccupancy

+ const DisableCachingOverride

+ type P2PAttribute byte

+ const P2PAccessSupported

+ const P2PNativeAomicSupported

+ const PerformanceRank

+ type PointerAttribute int

+ const BufferIDAttr

+ const ContextAttr

+ const DevicePointerAttr

+ const HostPointerAttr

+ const IsManagedAttr

+ const MemoryTypeAttr

+ const P2PTokenAttr

+ const SymcMemopsAttr

+ type SharedConfig byte

+ const DefaultBankSize

+ const EightByteBankSize

+ const FourByteBankSize

+ func SharedMemConfig() (pConfig SharedConfig, err error)

+ type Stream uintptr

+ func MakeStream(flags StreamFlags) (Stream, error)

+ func MakeStreamWithPriority(priority int, flags StreamFlags) (Stream, error)

+ func (hStream Stream) AttachMemAsync(dptr DevicePtr, length int64, flags uint) (err error)

+ func (hStream Stream) Flags() (flags StreamFlags, err error)

+ func (hStream Stream) Priority() (priority int, err error)

+ func (hStream Stream) Query() (err error)

+ func (hStream Stream) Synchronize() (err error)

+ func (hStream Stream) Wait(hEvent Event, Flags uint) (err error)

+ func (stream Stream) WaitOnValue32(addr DevicePtr, value uint32, flags uint) (err error)

+ func (stream Stream) WriteValue32(addr DevicePtr, value uint32, flags uint) (err error)

+ type StreamFlags byte

+ const DefaultStream

+ const NonBlocking

+ type SurfRef uintptr

+ func (hSurfRef SurfRef) GetArray() (phArray Array, err error)

+ func (hSurfRef SurfRef) SetArray(hArray Array, Flags uint) (err error)

+ type TexRef uintptr

+ func (hTexRef TexRef) Address() (pdptr DevicePtr, err error)

+ func (hTexRef TexRef) AddressMode(dim int) (pam AddressMode, err error)

+ func (hTexRef TexRef) Array() (phArray Array, err error)

+ func (hTexRef TexRef) BorderColor() (pBorderColor [3]float32, err error)

+ func (hTexRef TexRef) FilterMode() (pfm FilterMode, err error)

+ func (hTexRef TexRef) Flags() (pFlags TexRefFlags, err error)

+ func (hTexRef TexRef) Format() (pFormat Format, pNumChannels int, err error)

+ func (hTexRef TexRef) MaxAnisotropy() (pmaxAniso int, err error)

+ func (hTexRef TexRef) SetAddress(dptr DevicePtr, bytes int64) (ByteOffset int64, err error)

+ func (hTexRef TexRef) SetAddress2D(desc ArrayDesc, dptr DevicePtr, Pitch int64) (err error)

+ func (hTexRef TexRef) SetAddressMode(dim int, am AddressMode) (err error)

+ func (hTexRef TexRef) SetArray(hArray Array, Flags uint) (err error)

+ func (hTexRef TexRef) SetBorderColor(pBorderColor [3]float32) (err error)

+ func (hTexRef TexRef) SetFilterMode(fm FilterMode) (err error)

+ func (hTexRef TexRef) SetFlags(Flags TexRefFlags) (err error)

+ func (hTexRef TexRef) SetFormat(fmt Format, NumPackedComponents int) (err error)

+ func (hTexRef TexRef) SetMaxAnisotropy(maxAniso uint) (err error)

+ func (hTexRef TexRef) SetMipmapFilterMode(fm FilterMode) (err error)

+ func (hTexRef TexRef) SetMipmapLevelBias(bias float64) (err error)

+ func (hTexRef TexRef) SetMipmapLevelClamp(minMipmapLevelClamp float64, maxMipmapLevelClamp float64) (err error)

+ type TexRefFlags byte

+ const NormalizeCoordinates

+ const ReadAsInteger

+ const SRGB

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL