CUDA Host API¶
Device detection and enquiry¶
The following functions are available for querying the available hardware:
Returns a boolean to indicate the availability of a CUDA GPU.
This will initialize the driver if it hasn’t been initialized.
Detect supported CUDA hardware and print a summary of the detected hardware.
Returns a boolean indicating whether any supported devices were detected.
CUDA Python functions execute within a CUDA context. Each CUDA device in a
system has an associated CUDA context, and Numba presently allows only one context
per thread. For further details on CUDA Contexts, refer to the CUDA Driver API
Documentation on Context Management and the
CUDA C Programming Guide Context Documentation. CUDA Contexts
are instances of the
This object wraps a CUDA Context resource.
Contexts should not be constructed directly by user code.
Returns (free, total) memory in bytes in the context.
Pops this context off the current CPU thread. Note that this context must be at the top of the context stack, otherwise an error will occur.
Pushes this context on the current CPU Thread.
Clean up all owned resources in this context.
The following functions can be used to get or select the context:
Get the current device or use a device by device number, and return the CUDA context.
A decorator that ensures a CUDA context is available when fn is executed.
Note: The function fn cannot switch CUDA-context.
The following functions affect the current context:
Synchronize the current context.
Explicitly clears all contexts in the current thread, and destroys all contexts if the current thread is the main thread.
Numba maintains a list of supported CUDA-capable devices:
An indexable list of supported CUDA devices. This list is indexed by integer device ID.
Alternatively, the current device can be obtained:
Return the currently-selected device.
Provides a context manager for executing in the context of the chosen device. The normal use of instances of this type is from
numba.cuda.gpus. For example, to execute on device 2:
with numba.cuda.gpus: d_a = numba.cuda.to_device(a)
to copy the array a onto device 2, referred to by d_a.
One may also select a context and device or get the current device using the following three functions:
Make the context associated with device device_id the current context.
Returns a Device instance.
Raises exception on error.
Get current device associated with the current thread
Return a list of all detected devices
numba.cuda.cudadrv.driver.Device class can be used to enquire about
the functionality of the selected device:
The device associated with a particular context.
A tuple, (major, minor) indicating the supported compute capability.
The integer ID of the device.
The name of the device (e.g. “GeForce GTX 970”)
Delete the context for the device. This will destroy all memory allocations, events, and streams created within the context.
Numba provides an entry point for compiling a Python function to PTX without invoking any of the driver API. This can be useful for:
- Generating PTX that is to be inlined into other PTX code (e.g. from outside the Numba / Python ecosystem).
- Generating code when there is no device present.
- Generating code prior to a fork without initializing CUDA.
It is the user’s responsibility to manage any ABI issues arising from the use of compilation to PTX.
compile_ptx(pyfunc, args, debug=False, device=False, fastmath=False, cc=None, opt=True)¶
Compile a Python function to PTX for a given set of argument types.
- pyfunc – The Python function to compile.
- args – A tuple of argument types to compile for.
- debug (bool) – Whether to include debug info in the generated PTX.
- device (bool) – Whether to compile a device function. Defaults to
False, to compile global kernel functions.
- fastmath (bool) – Whether to enable fast math flags (ftz=1, prec_sqrt=0, prec_div=, and fma=1)
- cc (tuple) – Compute capability to compile for, as a tuple
(MAJOR, MINOR). Defaults to
- opt (bool) – Enable optimizations. Defaults to
(ptx, resty): The PTX code and inferred return type
The environment variable
NUMBA_CUDA_DEFAULT_PTX_CC can be set to control
the default compute capability targeted by
compile_ptx - see
GPU support. If PTX for the compute capability of the
current device is required, the
compile_ptx_for_current_device function can
compile_ptx_for_current_device(pyfunc, args, debug=False, device=False, fastmath=False, opt=True)¶
Compile a Python function to PTX for a given set of argument types for the current device’s compute capabilility. This calls
compile_ptx()with an appropriate
ccvalue for the current device.
The NVidia Visual Profiler can be used directly on executing CUDA Python code - it is not a requirement to insert calls to these functions into user code. However, these functions can be used to allow profiling to be performed selectively on specific portions of the code. For further information on profiling, see the NVidia Profiler User’s Guide.
Enable profile collection in the current context.
Disable profile collection in the current context.
Context manager that enables profiling on entry and disables profiling on exit.
Events can be used to monitor the progress of execution and to record the timestamps of specific points being reached. Event creation returns immediately, and the created event can be queried to determine if it has been reached. For further information, see the CUDA C Programming Guide Events section.
The following functions are used for creating and measuring the time between events:
Create a CUDA event. Timing data is only recorded by the event if it is created with
Compute the elapsed time between two events in milliseconds.
Events are instances of the
Event(context, handle, finalizer=None)¶
Returns True if all work before the most recent record has completed; otherwise, returns False.
Set the record point of the event to the current point in the given stream.
The event will be considered to have occurred when all work that was queued in the stream at the time of the call to
record()has been completed.
Synchronize the host thread for the completion of the event.
All future works submitted to stream will wait util the event completes.
Streams allow concurrency of execution on a single device within a given context. Queued work items in the same stream execute sequentially, but work items in different streams may execute concurrently. Most operations involving a CUDA device can be performed asynchronously using streams, including data transfers and kernel execution. For further details on streams, see the CUDA C Programming Guide Streams section.
Streams are instances of
Stream(context, handle, finalizer, external=False)¶
add_callback(self, callback, arg)¶
Add a callback to a compute stream. The user provided function is called from a driver thread once all preceding stream operations are complete.
Callback functions are called from a CUDA driver thread, not from the thread that invoked add_callback. No CUDA API functions may be called from within the callback function.
The duration of a callback function should be kept short, as the callback will block later work in the stream and may block other callbacks from being executed.
Note: This function is marked as deprecated and may be replaced in a future CUDA release.
- callback – Callback function with arguments (stream, status, arg).
- arg – User data to be passed to the callback function.
async_done(self) → _asyncio.Future¶
Return an awaitable that resolves once all preceding stream operations are complete.
A context manager that waits for all commands in this stream to execute and commits any pending memory transfers upon exiting the context.
Wait for all commands in this stream to execute. This will commit any pending memory transfers.
To create a new stream:
Create a CUDA stream that represents a command queue for the device.
To get the default stream:
Get the default CUDA stream. CUDA semantics in general are that the default stream is either the legacy default stream or the per-thread default stream depending on which CUDA APIs are in use. In Numba, the APIs for the legacy default stream are always the ones in use, but an option to use APIs for the per-thread default stream may be provided in future.
To get the default stream with an explicit choice of whether it is the legacy or per-thread default stream:
Get the legacy default CUDA stream.
Get the per-thread default CUDA stream.
To construct a Numba
Stream object using a stream allocated elsewhere, the
external_stream function is provided. Note that the lifetime of external
streams must be managed by the user - Numba will not deallocate an external
stream, and the stream must remain valid whilst the Numba
Stream object is
Numba generally uses the Driver API, but it provides a simple wrapper to the
Runtime API so that the version of the runtime in use can be queried. This is
cuda.runtime, which is an instance of the