Torch.FFI.THC.General

Documentation

c_THCState_alloc :: IO (Ptr C'THCState)

c_THCState_alloc : -> THCState *

c_THCState_free :: Ptr C'THCState -> IO ()

c_THCState_free : state -> void

c_THCudaInit :: Ptr C'THCState -> IO ()

c_THCudaInit : state -> void

c_THCudaShutdown :: Ptr C'THCState -> IO ()

c_THCudaShutdown : state -> void

c_THCState_getPeerToPeerAccess :: Ptr C'THCState -> CInt -> CInt -> IO CInt

c_THCState_getPeerToPeerAccess : state dev devToAccess -> int

c_THCState_setPeerToPeerAccess :: Ptr C'THCState -> CInt -> CInt -> CInt -> IO ()

c_THCState_setPeerToPeerAccess : state dev devToAccess enable -> void

c_THCState_getKernelPeerToPeerAccessEnabled :: Ptr C'THCState -> IO CInt

c_THCState_getKernelPeerToPeerAccessEnabled : state -> int

c_THCState_setKernelPeerToPeerAccessEnabled :: Ptr C'THCState -> CInt -> IO ()

c_THCState_setKernelPeerToPeerAccessEnabled : state val -> void

c_THCState_getCudaHostAllocator :: Ptr C'THCState -> IO (Ptr C'THAllocator)

c_THCState_getCudaHostAllocator : state -> THAllocator *

c_THCState_getCudaUVAAllocator :: Ptr C'THCState -> IO (Ptr C'THAllocator)

c_THCState_getCudaUVAAllocator : state -> THAllocator *

c_THCState_isCachingAllocatorEnabled :: Ptr C'THCState -> IO CInt

c_THCState_isCachingAllocatorEnabled : state -> int

c_THCMagma_init :: Ptr C'THCState -> IO ()

c_THCMagma_init : state -> void

c_THCState_getNumDevices :: Ptr C'THCState -> IO CInt

c_THCState_getNumDevices : state -> int

c_THCState_reserveStreams :: Ptr C'THCState -> CInt -> CInt -> IO ()

c_THCState_reserveStreams : state numStreams nonBlocking -> void

c_THCState_getNumStreams :: Ptr C'THCState -> IO CInt

c_THCState_getNumStreams : state -> int

c_THCState_getStream :: Ptr C'THCState -> IO (Ptr C'THCStream)

c_THCState_getStream : state -> THCStream *

c_THCState_setStream :: Ptr C'THCState -> Ptr C'THCStream -> IO ()

c_THCState_setStream : state stream -> void

c_THCState_getCurrentStreamIndex :: Ptr C'THCState -> IO CInt

c_THCState_getCurrentStreamIndex : state -> int

c_THCState_setCurrentStreamIndex :: Ptr C'THCState -> CInt -> IO ()

c_THCState_setCurrentStreamIndex : state stream -> void

c_THCState_reserveBlasHandles :: Ptr C'THCState -> CInt -> IO ()

c_THCState_reserveBlasHandles : state numHandles -> void

c_THCState_getNumBlasHandles :: Ptr C'THCState -> IO CInt

c_THCState_getNumBlasHandles : state -> int

c_THCState_reserveSparseHandles :: Ptr C'THCState -> CInt -> IO ()

c_THCState_reserveSparseHandles : state numHandles -> void

c_THCState_getNumSparseHandles :: Ptr C'THCState -> IO CInt

c_THCState_getNumSparseHandles : state -> int

c_THCState_getCurrentBlasHandleIndex :: Ptr C'THCState -> IO CInt

c_THCState_getCurrentBlasHandleIndex : state -> int

c_THCState_setCurrentBlasHandleIndex :: Ptr C'THCState -> CInt -> IO ()

c_THCState_setCurrentBlasHandleIndex : state handle -> void

c_THCState_getCurrentSparseHandleIndex :: Ptr C'THCState -> IO CInt

c_THCState_getCurrentSparseHandleIndex : state -> int

c_THCState_setCurrentSparseHandleIndex :: Ptr C'THCState -> CInt -> IO ()

c_THCState_setCurrentSparseHandleIndex : state handle -> void

c_THCState_getCurrentDeviceScratchSpace :: Ptr C'THCState -> IO (Ptr ())

c_THCState_getCurrentDeviceScratchSpace : state -> void *

c_THCState_getDeviceScratchSpace :: Ptr C'THCState -> CInt -> CInt -> IO (Ptr ())

c_THCState_getDeviceScratchSpace : state device stream -> void *

c_THCState_getCurrentDeviceScratchSpaceSize :: Ptr C'THCState -> IO CSize

c_THCState_getCurrentDeviceScratchSpaceSize : state -> size_t

c_THCState_getDeviceScratchSpaceSize :: Ptr C'THCState -> CInt -> IO CSize

c_THCState_getDeviceScratchSpaceSize : state device -> size_t

c_THCudaHostAlloc :: Ptr C'THCState -> CSize -> IO (Ptr ())

c_THCudaHostAlloc : state size -> void *

c_THCudaHostFree :: Ptr C'THCState -> Ptr () -> IO ()

c_THCudaHostFree : state ptr -> void

c_THCudaHostRecord :: Ptr C'THCState -> Ptr () -> IO ()

c_THCudaHostRecord : state ptr -> void

p_THCState_alloc :: FunPtr (IO (Ptr C'THCState))

p_THCState_alloc : Pointer to function : -> THCState *

p_THCState_free :: FunPtr (Ptr C'THCState -> IO ())

p_THCState_free : Pointer to function : state -> void

p_THCudaInit :: FunPtr (Ptr C'THCState -> IO ())

p_THCudaInit : Pointer to function : state -> void

p_THCudaShutdown :: FunPtr (Ptr C'THCState -> IO ())

p_THCudaShutdown : Pointer to function : state -> void

p_THCState_getPeerToPeerAccess :: FunPtr (Ptr C'THCState -> CInt -> CInt -> IO CInt)

p_THCState_getPeerToPeerAccess : Pointer to function : state dev devToAccess -> int

p_THCState_setPeerToPeerAccess :: FunPtr (Ptr C'THCState -> CInt -> CInt -> CInt -> IO ())

p_THCState_setPeerToPeerAccess : Pointer to function : state dev devToAccess enable -> void

p_THCState_getKernelPeerToPeerAccessEnabled :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getKernelPeerToPeerAccessEnabled : Pointer to function : state -> int

p_THCState_setKernelPeerToPeerAccessEnabled :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_setKernelPeerToPeerAccessEnabled : Pointer to function : state val -> void

p_THCState_getCudaHostAllocator :: FunPtr (Ptr C'THCState -> IO (Ptr C'THAllocator))

p_THCState_getCudaHostAllocator : Pointer to function : state -> THAllocator *

p_THCState_getCudaUVAAllocator :: FunPtr (Ptr C'THCState -> IO (Ptr C'THAllocator))

p_THCState_getCudaUVAAllocator : Pointer to function : state -> THAllocator *

p_THCState_isCachingAllocatorEnabled :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_isCachingAllocatorEnabled : Pointer to function : state -> int

p_THCMagma_init :: FunPtr (Ptr C'THCState -> IO ())

p_THCMagma_init : Pointer to function : state -> void

p_THCState_getNumDevices :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getNumDevices : Pointer to function : state -> int

p_THCState_reserveStreams :: FunPtr (Ptr C'THCState -> CInt -> CInt -> IO ())

p_THCState_reserveStreams : Pointer to function : state numStreams nonBlocking -> void

p_THCState_getNumStreams :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getNumStreams : Pointer to function : state -> int

p_THCState_getStream :: FunPtr (Ptr C'THCState -> IO (Ptr C'THCStream))

p_THCState_getStream : Pointer to function : state -> THCStream *

p_THCState_setStream :: FunPtr (Ptr C'THCState -> Ptr C'THCStream -> IO ())

p_THCState_setStream : Pointer to function : state stream -> void

p_THCState_getCurrentStreamIndex :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getCurrentStreamIndex : Pointer to function : state -> int

p_THCState_setCurrentStreamIndex :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_setCurrentStreamIndex : Pointer to function : state stream -> void

p_THCState_reserveBlasHandles :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_reserveBlasHandles : Pointer to function : state numHandles -> void

p_THCState_getNumBlasHandles :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getNumBlasHandles : Pointer to function : state -> int

p_THCState_reserveSparseHandles :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_reserveSparseHandles : Pointer to function : state numHandles -> void

p_THCState_getNumSparseHandles :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getNumSparseHandles : Pointer to function : state -> int

p_THCState_getCurrentBlasHandleIndex :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getCurrentBlasHandleIndex : Pointer to function : state -> int

p_THCState_setCurrentBlasHandleIndex :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_setCurrentBlasHandleIndex : Pointer to function : state handle -> void

p_THCState_getCurrentSparseHandleIndex :: FunPtr (Ptr C'THCState -> IO CInt)

p_THCState_getCurrentSparseHandleIndex : Pointer to function : state -> int

p_THCState_setCurrentSparseHandleIndex :: FunPtr (Ptr C'THCState -> CInt -> IO ())

p_THCState_setCurrentSparseHandleIndex : Pointer to function : state handle -> void

p_THCState_getCurrentDeviceScratchSpace :: FunPtr (Ptr C'THCState -> IO (Ptr ()))

p_THCState_getCurrentDeviceScratchSpace : Pointer to function : state -> void *

p_THCState_getDeviceScratchSpace :: FunPtr (Ptr C'THCState -> CInt -> CInt -> IO (Ptr ()))

p_THCState_getDeviceScratchSpace : Pointer to function : state device stream -> void *

p_THCState_getCurrentDeviceScratchSpaceSize :: FunPtr (Ptr C'THCState -> IO CSize)

p_THCState_getCurrentDeviceScratchSpaceSize : Pointer to function : state -> size_t

p_THCState_getDeviceScratchSpaceSize :: FunPtr (Ptr C'THCState -> CInt -> IO CSize)

p_THCState_getDeviceScratchSpaceSize : Pointer to function : state device -> size_t

p_THCudaHostAlloc :: FunPtr (Ptr C'THCState -> CSize -> IO (Ptr ()))

p_THCudaHostAlloc : Pointer to function : state size -> void *

p_THCudaHostFree :: FunPtr (Ptr C'THCState -> Ptr () -> IO ())

p_THCudaHostFree : Pointer to function : state ptr -> void

p_THCudaHostRecord :: FunPtr (Ptr C'THCState -> Ptr () -> IO ())

p_THCudaHostRecord : Pointer to function : state ptr -> void