You are viewing archived documentation from the old Numba documentation site. The current documentation is located at https://numba.readthedocs.io.


Device Management

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.

Context management

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 Context class:

class numba.cuda.cudadrv.driver.Context(device, handle)

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.

Device management

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.

Getting a device through numba.cuda.gpus always provides an instance of numba.cuda.cudadrv.devices._DeviceContextManager, which acts as a context manager for the selected device:

class numba.cuda.cudadrv.devices._DeviceContextManager(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[2]:
    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

The numba.cuda.cudadrv.driver.Device class can be used to enquire about the functionality of the selected device:

class numba.cuda.cudadrv.driver.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.

numba.cuda.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 (5, 2).
  • opt (bool) – Enable optimizations. Defaults to True.

(ptx, resty): The PTX code and inferred return type

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 be used:

numba.cuda.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 cc value 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 timing=True.

numba.cuda.event_elapsed_time(evtstart, evtend)

Compute the elapsed time between two events in milliseconds.

Events are instances of the numba.cuda.cudadrv.driver.Event class:

class numba.cuda.cudadrv.driver.Event(context, handle, finalizer=None)

Returns True if all work before the most recent record has completed; otherwise, returns False.

record(self, stream=0)

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.

wait(self, stream=0)

All future works submitted to stream will wait util the event completes.

Stream Management

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 numba.cuda.cudadrv.driver.Stream:

class numba.cuda.cudadrv.driver.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 in use.


Create a Numba stream object for a stream allocated outside Numba.

Parameters:ptr (int) – Pointer to the external stream to wrap in a Numba Stream


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 accessed through cuda.runtime, which is an instance of the numba.cuda.cudadrv.runtime.Runtime class:

class numba.cuda.cudadrv.runtime.Runtime

Runtime object that lazily binds runtime API functions.


Returns the CUDA Runtime version as a tuple (major, minor).