org.bytedeco.pytorch.global

Class torch_cuda

java.lang.Object

org.bytedeco.pytorch.presets.torch_cuda

org.bytedeco.pytorch.global.torch_cuda

All Implemented Interfaces:

LoadEnabled, InfoMapper

public class torch_cuda
extends torch_cuda

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	torch_cuda.RecordContext
static class	torch_cuda.StatType

Field Summary

Fields

Modifier and Type	Field and Description
static int	C10_COMPILE_TIME_MAX_GPUS The maximum number of GPUs that we recognizes.
static int	max_compile_time_stream_priorities

Constructor Summary

Constructors

Constructor and Description
torch_cuda()

Method Summary

Modifier and Type	Method and Description
static BytePointer	_cublasGetErrorEnum(int error)
static BytePointer	_cusolver_backend_suggestion()
static int	C10_CUDA_DSA_ASSERTION_COUNT() Number of assertion failure messages we can store.
static int	C10_CUDA_DSA_MAX_STR_LEN()
static boolean	canDeviceAccessPeer(long device, long peer_device)
static void	clearCublasWorkspaces()
static Tensor	contiguousIfZeroInStrides(Tensor t)
static int	currentStreamCaptureStatusMayInitCtx()
static BytePointer	cusolverGetErrorMessage(int status)
static BytePointer	cusparseGetErrorString(int status)
static int	dataSize(int dataType)
static CUDAAllocator	getAllocator()
static Allocator	getCUDADeviceAllocator()
static int	getCudnnDataTypeFromScalarType(torch.ScalarType dtype)
static Pointer	getCudnnHandle()
static Pointer	getCurrentCUDABlasHandle()
static Pointer	getCurrentCUDASolverDnHandle()
static Pointer	getCurrentCUDASparseHandle()
static CUDAStream	getCurrentCUDAStream()
static CUDAStream	getCurrentCUDAStream(byte device_index) Get the current CUDA stream, for the passed CUDA device, or for the current device if no device index is passed.
static Pointer	getCurrentDeviceProperties()
static CUDAStream	getDefaultCUDAStream()
static CUDAStream	getDefaultCUDAStream(byte device_index) Get the default CUDA stream, for the passed CUDA device, or for the current device if no device index is passed.
static Pointer	getDeviceProperties(long device)
static long	getNumGPUs() DEPRECATED: use device_count() instead
static CUDAStream	getStreamFromExternal(Pointer ext_stream, byte device_index) Get a CUDAStream from a externally allocated one.
static CUDAStream	getStreamFromPool()
static CUDAStream	getStreamFromPool(boolean isHighPriority, byte device) Get a new stream from the CUDA stream pool.
static CUDAStream	getStreamFromPool(int priority)
static CUDAStream	getStreamFromPool(int priority, byte device)
static boolean	is_available() CUDA is available if we compiled with CUDA, and there are one or more devices.
static Generator	make_generator_cuda()
static Generator	make_generator_cuda(byte device_index)
static int	max_compile_time_stream_priorities() Construct an ArrayRef from a C array.
static void	setAllocatorSettings(BytePointer env)
static void	setAllocatorSettings(String env)
static void	setCurrentCUDAStream(CUDAStream stream) Set the current stream on the device of the passed in stream to be the passed in stream.
static Pointer	shiftLeft(Pointer stream, CUDAStream s)
static Pointer	shiftLeft(Pointer os, int status)
static int	warp_size()

Methods inherited from class org.bytedeco.pytorch.presets.torch_cuda

init, map

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

max_compile_time_stream_priorities

public static final int max_compile_time_stream_priorities

C10_COMPILE_TIME_MAX_GPUS

public static final int C10_COMPILE_TIME_MAX_GPUS

The maximum number of GPUs that we recognizes.

See Also:

Constant Field Values

Constructor Detail

torch_cuda

public torch_cuda()

Method Detail

make_generator_cuda

@Namespace(value="at")
 @ByVal
 @Name(value="make_generator<at::CUDAGeneratorImpl>")
public static Generator make_generator_cuda()

make_generator_cuda

@Namespace(value="at")
 @ByVal
 @Name(value="make_generator<at::CUDAGeneratorImpl,int8_t>")
public static Generator make_generator_cuda(@Cast(value="int8_t&&")
                                                                                                                                        byte device_index)

max_compile_time_stream_priorities

@Namespace(value="c10::cuda")
 @MemberGetter
public static int max_compile_time_stream_priorities()

Construct an ArrayRef from a C array.

getStreamFromPool

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getStreamFromPool(@Cast(value="const bool")
                                                                                 boolean isHighPriority,
                                                                                 byte device)

Get a new stream from the CUDA stream pool. You can think of this as "creating" a new stream, but no such creation actually happens; instead, streams are preallocated from the pool and returned in a round-robin fashion. You can request a stream from the high priority pool by setting isHighPriority to true, or a stream for a specific device by setting device (defaulting to the current CUDA stream.)

getStreamFromPool

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getStreamFromPool()

getStreamFromPool

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getStreamFromPool(int priority,
                                                                                 byte device)

getStreamFromPool

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getStreamFromPool(int priority)

getStreamFromExternal

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getStreamFromExternal(@Cast(value="cudaStream_t")
                                                                                     Pointer ext_stream,
                                                                                     byte device_index)

Get a CUDAStream from a externally allocated one. This is mainly for interoperability with different libraries where we want to operate on a non-torch allocated stream for data exchange or similar purposes

getDefaultCUDAStream

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getDefaultCUDAStream(byte device_index)

Get the default CUDA stream, for the passed CUDA device, or for the current device if no device index is passed. The default stream is where most computation occurs when you aren't explicitly using streams.

getDefaultCUDAStream

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getDefaultCUDAStream()

getCurrentCUDAStream

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getCurrentCUDAStream(byte device_index)

Get the current CUDA stream, for the passed CUDA device, or for the current device if no device index is passed. The current CUDA stream will usually be the default CUDA stream for the device, but it may be different if someone called 'setCurrentCUDAStream' or used 'StreamGuard' or 'CUDAStreamGuard'.

getCurrentCUDAStream

@Namespace(value="c10::cuda")
 @ByVal
public static CUDAStream getCurrentCUDAStream()

setCurrentCUDAStream

@Namespace(value="c10::cuda")
public static void setCurrentCUDAStream(@ByVal
                                                                      CUDAStream stream)

Set the current stream on the device of the passed in stream to be the passed in stream. Yes, you read that right: this function has *nothing* to do with the current device: it toggles the current stream of the device of the passed stream. Confused? Avoid using this function; prefer using 'CUDAStreamGuard' instead (which will switch both your current device and current stream in the way you expect, and reset it back to its original state afterwards).

shiftLeft

@Namespace(value="c10::cuda")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer stream,
                                                                                                                                @Const @ByRef
                                                                                                                                CUDAStream s)

getNumGPUs

@Namespace(value="at::cuda")
 @Cast(value="int64_t")
public static long getNumGPUs()

DEPRECATED: use device_count() instead

is_available

@Namespace(value="at::cuda")
 @Cast(value="bool")
public static boolean is_available()

CUDA is available if we compiled with CUDA, and there are one or more devices. If we compiled with CUDA but there is a driver problem, etc., this function will report CUDA is not available (rather than raise an error.)

getCurrentDeviceProperties

@Namespace(value="at::cuda")
public static Pointer getCurrentDeviceProperties()

warp_size

@Namespace(value="at::cuda")
public static int warp_size()

getDeviceProperties

@Namespace(value="at::cuda")
public static Pointer getDeviceProperties(@Cast(value="int64_t")
                                                                       long device)

canDeviceAccessPeer

@Namespace(value="at::cuda")
 @Cast(value="bool")
public static boolean canDeviceAccessPeer(@Cast(value="int64_t")
                                                                                            long device,
                                                                                            @Cast(value="int64_t")
                                                                                            long peer_device)

getCUDADeviceAllocator

@Namespace(value="at::cuda")
public static Allocator getCUDADeviceAllocator()

getCurrentCUDASparseHandle

@Namespace(value="at::cuda")
 @Cast(value="cusparseHandle_t")
public static Pointer getCurrentCUDASparseHandle()

getCurrentCUDABlasHandle

@Namespace(value="at::cuda")
 @Cast(value="cublasHandle_t")
public static Pointer getCurrentCUDABlasHandle()

clearCublasWorkspaces

@Namespace(value="at::cuda")
public static void clearCublasWorkspaces()

getCurrentCUDASolverDnHandle

@Namespace(value="at::cuda")
 @Cast(value="cusolverDnHandle_t")
public static Pointer getCurrentCUDASolverDnHandle()

C10_CUDA_DSA_ASSERTION_COUNT

@MemberGetter
public static int C10_CUDA_DSA_ASSERTION_COUNT()

Number of assertion failure messages we can store. If this is too small threads will fail silently.

C10_CUDA_DSA_MAX_STR_LEN

@MemberGetter
public static int C10_CUDA_DSA_MAX_STR_LEN()

_cublasGetErrorEnum

@Namespace(value="at::cuda::blas")
 @Cast(value="const char*")
public static BytePointer _cublasGetErrorEnum(@Cast(value="cublasStatus_t")
                                                                                                             int error)

cusparseGetErrorString

@Cast(value="const char*")
public static BytePointer cusparseGetErrorString(@Cast(value="cusparseStatus_t")
                                                                            int status)

cusolverGetErrorMessage

@Namespace(value="at::cuda::solver")
 @Cast(value="const char*")
public static BytePointer cusolverGetErrorMessage(@Cast(value="cusolverStatus_t")
                                                                                                                   int status)

_cusolver_backend_suggestion

@Namespace(value="at::cuda::solver")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer _cusolver_backend_suggestion()

contiguousIfZeroInStrides

@Namespace(value="at::native")
 @ByVal
public static Tensor contiguousIfZeroInStrides(@Const @ByRef
                                                                                      Tensor t)

getCudnnHandle

@Namespace(value="at::native")
 @Cast(value="cudnnHandle_t")
public static Pointer getCudnnHandle()

shiftLeft

@Namespace(value="c10::cuda")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                Pointer os,
                                                                                                                                @Cast(value="c10::cuda::CaptureStatus")
                                                                                                                                int status)

currentStreamCaptureStatusMayInitCtx

@Namespace(value="c10::cuda")
 @Cast(value="c10::cuda::CaptureStatus")
public static int currentStreamCaptureStatusMayInitCtx()

setAllocatorSettings

@Namespace(value="c10::cuda::CUDACachingAllocator")
public static void setAllocatorSettings(@StdString
                                                                                            BytePointer env)

setAllocatorSettings

@Namespace(value="c10::cuda::CUDACachingAllocator")
public static void setAllocatorSettings(@StdString
                                                                                            String env)

getAllocator

@Namespace(value="c10::cuda::CUDACachingAllocator")
 @Name(value="get")
public static CUDAAllocator getAllocator()

dataSize

@Namespace(value="at::native")
public static int dataSize(@Cast(value="cudnnDataType_t")
                                                          int dataType)

getCudnnDataTypeFromScalarType

@Namespace(value="at::native")
 @Cast(value="cudnnDataType_t")
public static int getCudnnDataTypeFromScalarType(torch.ScalarType dtype)