Examples

Vector Addition

This example uses Numba CUDA MLIR to create on-device arrays and a vector addition kernel; it is a warmup for learning how to write GPU kernels using Numba. We’ll begin with some required imports:

from test_ex_vecadd in tests/doc_examples/test_vecadd.py

import numpy as np
from numba import cuda

The following function is the kernel. Note that it is defined in terms of Python variables with unspecified types. When the kernel is launched, Numba CUDA MLIR will examine the types of the arguments that are passed at runtime and generate a CUDA kernel specialized for them.

Note that kernels do not return values and must write any output into arrays passed in as parameters (this is similar to the requirement that CUDA C++ kernels have void return type). Here we pass in c for the results to be written into.

from test_ex_vecadd in tests/doc_examples/test_vecadd.py

@cuda.jit
def f(a, b, c):
    # like threadIdx.x + (blockIdx.x * blockDim.x)
    tid = cuda.grid(1)
    size = len(c)

    if tid < size:
        c[tid] = a[tid] + b[tid]

cuda.to_device() can be used create device-side copies of arrays. cuda.device_array_like() creates an uninitialized array of the same shape and type as an existing array. Here we transfer two vectors and create an empty vector to hold our results:

from test_ex_vecadd in tests/doc_examples/test_vecadd.py

N = 100000
a = cuda.to_device(np.random.random(N))
b = cuda.to_device(np.random.random(N))
c = cuda.device_array_like(a)

A call to forall() generates an appropriate launch configuration with a 1D grid (see Kernel invocation) for a given data size and is often the simplest way of launching a kernel:

from test_ex_vecadd in tests/doc_examples/test_vecadd.py

f.forall(len(a))(a, b, c)
print(c.copy_to_host())

This prints:

[0.73548323 1.32061059 0.12582968 ... 1.25925809 1.49335059 1.59315414]

One can also configure the grid manually using the subscripting syntax. The following example launches a grid with sufficient threads to operate on every vector element:

from test_ex_vecadd in tests/doc_examples/test_vecadd.py

# Enough threads per block for several warps per block
nthreads = 256
# Enough blocks to cover the entire vector depending on its length
nblocks = (len(a) // nthreads) + 1
f[nblocks, nthreads](a, b, c)
print(c.copy_to_host())

This also prints:

[0.73548323 1.32061059 0.12582968 ... 1.25925809 1.49335059 1.59315414]

1D Heat Equation

This example solves Laplace’s equation in one dimension for a certain set of initial conditions and boundary conditions. A full discussion of Laplace’s equation is out of scope for this documentation, but it will suffice to say that it describes how heat propagates through an object over time. It works by discretizing the problem in two ways:

1. The domain is partitioned into a mesh of points that each have an individual temperature.

2. Time is partitioned into discrete intervals that are advanced forward sequentially.

Then, the following assumption is applied: The temperature of a point after some interval has passed is some weighted average of the temperature of the points that are directly adjacent to it. Intuitively, if all the points in the domain are very hot and a single point in the middle is very cold, as time passes, the hot points will cause the cold one to heat up and the cold point will cause the surrounding hot pieces to cool slightly. Simply put, the heat spreads throughout the object.

We can implement this simulation using a kernel. Let’s start simple by assuming we have a one dimensional object which we’ll represent with an array of values. The position of the element in the array is the position of a point within the object, and the value of the element represents the temperature.

from test_ex_laplace in tests/doc_examples/test_laplace.py

import numpy as np
from numba import cuda

Some initial setup here. Let’s make one point in the center of the object very hot.

from test_ex_laplace in tests/doc_examples/test_laplace.py

# Use an odd problem size.
# This is so there can be an element truly in the "middle" for symmetry.
size = 1001
data = np.zeros(size)

# Middle element is made very hot
data[500] = 10000
buf_0 = cuda.to_device(data)

# This extra array is used for synchronization purposes
buf_1 = cuda.device_array_like(buf_0)

niter = 10000

The initial state of the problem can be visualized as:

In our kernel each thread will be responsible for managing the temperature update for a single element in a loop over the desired number of timesteps. The kernel is below. Note the use of cooperative group synchronization and the use of two buffers swapped at each iteration to avoid race conditions. See cuda.cg.this_grid() for details.

from test_ex_laplace in tests/doc_examples/test_laplace.py

@cuda.jit
def solve_heat_equation(buf_0, buf_1, timesteps, k):
    i = cuda.grid(1)

    # Don't continue if our index is outside the domain
    if i >= len(buf_0):
        return

    # Prepare to do a grid-wide synchronization later
    grid = cuda.cg.this_grid()

    for step in range(timesteps):
        # Select the buffer from the previous timestep
        if (step % 2) == 0:
            data = buf_0
            next_data = buf_1
        else:
            data = buf_1
            next_data = buf_0

        # Get the current temperature associated with this point
        curr_temp = data[i]

        # Apply formula from finite difference equation
        if i == 0:
            # Left wall is held at T = 0
            next_temp = curr_temp + k * (data[i + 1] - (2 * curr_temp))
        elif i == len(data) - 1:
            # Right wall is held at T = 0
            next_temp = curr_temp + k * (data[i - 1] - (2 * curr_temp))
        else:
            # Interior points are a weighted average of their neighbors
            next_temp = curr_temp + k * (data[i - 1] - (2 * curr_temp) + data[i + 1])

        # Write new value to the next buffer
        next_data[i] = next_temp

        # Wait for every thread to write before moving on
        grid.sync()

Calling the kernel:

from test_ex_laplace in tests/doc_examples/test_laplace.py

solve_heat_equation.forall(len(data))(buf_0, buf_1, niter, 0.25)

Plotting the final data shows an arc that is highest where the object was hot initially and gradually sloping down to zero towards the edges where the temperature is fixed at zero. In the limit of infinite time, the arc will flatten out completely.

Shared Memory Reduction

Numba CUDA MLIR exposes many CUDA features, including shared memory. To demonstrate shared memory, let’s reimplement a famous CUDA solution for summing a vector which works by “folding” the data up using a successively smaller number of threads.

Note that this is a fairly naive implementation, and there are more efficient ways of implementing reductions - see Monte Carlo Integration for an example.

from test_ex_reduction in tests/doc_examples/test_reduction.py

import numpy as np
from numba import cuda
from numba.cuda.types import int32

Let’s create some one dimensional data that we’ll use to demonstrate the kernel itself:

from test_ex_reduction in tests/doc_examples/test_reduction.py

# generate data
a = cuda.to_device(np.arange(1024))
nelem = len(a)

Here is a version of the kernel implemented using Numba CUDA MLIR:

from test_ex_reduction in tests/doc_examples/test_reduction.py

@cuda.jit
def array_sum(data):
    tid = cuda.threadIdx.x
    size = len(data)
    if tid < size:
        i = cuda.grid(1)

        # Declare an array in shared memory
        shr = cuda.shared.array(nelem, int32)
        shr[tid] = data[i]

        # Ensure writes to shared memory are visible
        # to all threads before reducing
        cuda.syncthreads()

        s = 1
        while s < cuda.blockDim.x:
            if tid % (2 * s) == 0:
                # Stride by `s` and add
                shr[tid] += shr[tid + s]
            s *= 2
            cuda.syncthreads()

        # After the loop, the zeroth  element contains the sum
        if tid == 0:
            data[tid] = shr[tid]

We can run kernel and verify that the same result is obtained through summing data on the host as follows:

from test_ex_reduction in tests/doc_examples/test_reduction.py

array_sum[1, nelem](a)
print(a[0])  # 523776
print(sum(np.arange(1024)))  # 523776

This algorithm can be greatly improved upon by redesigning the inner loop to use sequential memory accesses, and even further by using strategies that keep more threads active and working, since in this example most threads quickly become idle.

Dividing Click Data into Sessions

A common problem in business analytics is that of grouping the activity of users of an online platform into sessions, called “sessionization”. The idea is that users generally traverse through a website and perform various actions (clicking something, filling out a form, etc.) in discrete groups. Perhaps a customer spends some time shopping for an item in the morning and then again at night - often the business is interested in treating these periods as separate interactions with their service, and this creates the problem of programmatically splitting up activity in some agreed-upon way.

Here we’ll illustrate how to write a kernel to solve this problem. We’ll start with data containing two fields: let user_id represent a unique ID corresponding to an individual customer, and let action_time be a time that some unknown action was taken on the service. Right now, we’ll assume there’s only one type of action, so all there is to know is when it happened.

Our goal will be to create a new column called session_id, which contains a label corresponding to a unique session. We’ll define the boundary between sessions as when there has been at least one hour between clicks.

from test_ex_sessionize in tests/doc_examples/test_sessionize.py

import numpy as np
from numba import cuda

# Set the timeout to one hour
session_timeout = np.int64(np.timedelta64("3600", "s"))

Here is a solution:

from test_ex_sessionize in tests/doc_examples/test_sessionize.py

@cuda.jit
def sessionize(user_id, timestamp, results):
    gid = cuda.grid(1)
    size = len(user_id)

    if gid >= size:
        return

    # Determine session boundaries
    is_first_datapoint = gid == 0
    if not is_first_datapoint:
        new_user = user_id[gid] != user_id[gid - 1]
        timed_out = timestamp[gid] - timestamp[gid - 1] > session_timeout
        is_sess_boundary = new_user or timed_out
    else:
        is_sess_boundary = True

    # Determine session labels
    if is_sess_boundary:
        # This thread marks the start of a session
        results[gid] = gid

        # Make sure all session boundaries are written
        # before populating the session id
        grid = cuda.cg.this_grid()
        grid.sync()

        look_ahead = 1
        # Check elements 'forward' of this one
        # until a new session boundary is found
        while results[gid + look_ahead] == 0:
            results[gid + look_ahead] = gid
            look_ahead += 1
            # Avoid out-of-bounds accesses by the last thread
            if gid + look_ahead == size - 1:
                results[gid + look_ahead] = gid
                break

Let’s generate some data and try out the kernel:

from test_ex_sessionize in tests/doc_examples/test_sessionize.py

# Generate data
ids = cuda.to_device(
    np.array(
        [
            1,
            1,
            1,
            1,
            1,
            1,
            2,
            2,
            2,
            3,
            3,
            3,
            3,
            3,
            3,
            3,
            3,
            3,
            3,
            4,
            4,
            4,
            4,
            4,
            4,
            4,
            4,
            4,
        ]
    )
)
sec = cuda.to_device(
    np.array(
        [
            1,
            2,
            3,
            5000,
            5001,
            5002,
            1,
            2,
            3,
            1,
            2,
            5000,
            5001,
            10000,
            10001,
            10002,
            10003,
            15000,
            150001,
            1,
            5000,
            50001,
            15000,
            20000,
            25000,
            25001,
            25002,
            25003,
        ],
        dtype="datetime64[ns]",
    ).astype("int64")  # Cast to int64 for compatibility
)
# Create a vector to hold the results
results = cuda.to_device(np.zeros(len(ids)))

As can be seen above, the kernel successfully divided the first three datapoints from the second three for the first user ID, and a similar pattern is seen throughout.

JIT Function CPU-GPU Compatibility

This example demonstrates how numba.jit can be used to jit compile a function for the CPU, while at the same time making it available for use inside CUDA kernels. This can be very useful for users that are migrating workflows from CPU to GPU as they can directly reuse potential business logic with fewer code changes.

Take the following example function:

from test_ex_cpu_gpu_compat in tests/doc_examples/test_cpu_gpu_compat.py

@numba.jit
def business_logic(x, y, z):
    return 4 * z * (2 * x - (4 * y) / 2 * pi)

The function business_logic can be run standalone in compiled form on the CPU:

from test_ex_cpu_gpu_compat in tests/doc_examples/test_cpu_gpu_compat.py

print(business_logic(1, 2, 3))  # -126.79644737231007

It can also be directly reused threadwise inside a GPU kernel. For example one may generate some vectors to represent x, y, and z:

from test_ex_cpu_gpu_compat in tests/doc_examples/test_cpu_gpu_compat.py

X = cuda.to_device([1, 10, 234])
Y = cuda.to_device([2, 2, 4014])
Z = cuda.to_device([3, 14, 2211])
results = cuda.to_device([0.0, 0.0, 0.0])

And a numba kernel referencing the decorated function:

from test_ex_cpu_gpu_compat in tests/doc_examples/test_cpu_gpu_compat.py

@cuda.jit
def f(res, xarr, yarr, zarr):
    tid = cuda.grid(1)
    if tid < len(xarr):
        # The function decorated with numba.jit may be directly reused
        res[tid] = business_logic(xarr[tid], yarr[tid], zarr[tid])

This kernel can be invoked in the normal way:

from test_ex_cpu_gpu_compat in tests/doc_examples/test_cpu_gpu_compat.py

f.forall(len(X))(results, X, Y, Z)
print(results)
# [-126.79644737231007, 416.28324559588634, -218912930.2987788]

Monte Carlo Integration

This example shows how to approximate the value of a definite integral by rapidly generating random numbers on the GPU. A detailed description of the mathematical mechanics of Monte Carlo integration is out of the scope of the example, but it can briefly be described as an averaging process where the area under the curve is approximated by taking the average of many rectangles formed by its function values.

In addition, this example shows how to perform reductions in numba using the cuda.reduce() API.

from test_ex_montecarlo in tests/doc_examples/test_montecarlo.py

import numba
import numpy as np
from numba import cuda
from numba.cuda.random import (
    create_xoroshiro128p_states,
    xoroshiro128p_uniform_float32,
)

Let’s create a variable to control the number of samples drawn:

from test_ex_montecarlo in tests/doc_examples/test_montecarlo.py

# number of samples, higher will lead to a more accurate answer
nsamps = 1000000

The following kernel implements the main integration routine:

from test_ex_montecarlo in tests/doc_examples/test_montecarlo.py

@cuda.jit
def mc_integrator_kernel(out, rng_states, lower_lim, upper_lim):
    """
    kernel to draw random samples and evaluate the function to
    be integrated at those sample values
    """
    size = len(out)

    gid = cuda.grid(1)
    if gid < size:
        # draw a sample between 0 and 1 on this thread
        samp = xoroshiro128p_uniform_float32(rng_states, gid)

        # normalize this sample to the limit range
        samp = samp * (upper_lim - lower_lim) + lower_lim

        # evaluate the function to be
        # integrated at the normalized
        # value of the sample
        y = func(samp)
        out[gid] = y

This convenience function calls the kernel performs some preprocessing and post processing steps. Note the use of the reduction API to take sum of the array and compute the final result:

from test_ex_montecarlo in tests/doc_examples/test_montecarlo.py

@cuda.reduce
def sum_reduce(a, b):
    return a + b

def mc_integrate(lower_lim, upper_lim, nsamps):
    """
    approximate the definite integral of `func` from
    `lower_lim` to `upper_lim`
    """
    out = cuda.to_device(np.zeros(nsamps, dtype="float32"))
    rng_states = create_xoroshiro128p_states(nsamps, seed=42)

    # jit the function for use in CUDA kernels

    mc_integrator_kernel.forall(nsamps)(out, rng_states, lower_lim, upper_lim)
    # normalization factor to convert
    # to the average: (b - a)/(N - 1)
    factor = (upper_lim - lower_lim) / (nsamps - 1)

    return sum_reduce(out) * factor

We can now use mc_integrate to compute the definite integral of this function between two limits:

from test_ex_montecarlo in tests/doc_examples/test_montecarlo.py

# define a function to integrate
@numba.jit
def func(x):
    return 1.0 / x

mc_integrate(1, 2, nsamps)  # array(0.6929643, dtype=float32)
mc_integrate(2, 3, nsamps)  # array(0.4054021, dtype=float32)

Matrix multiplication

First, import the modules needed for this example:

from test_ex_matmul in tests/doc_examples/test_matmul.py

from numba import cuda
from numba.cuda import float32
import numpy as np
import math

Here is a naïve implementation of matrix multiplication using a CUDA kernel:

from test_ex_matmul in tests/doc_examples/test_matmul.py

@cuda.jit
def matmul(A, B, C):
    """Perform square matrix multiplication of C = A * B."""
    i, j = cuda.grid(2)
    if i < C.shape[0] and j < C.shape[1]:
        tmp = 0.0
        for k in range(A.shape[1]):
            tmp += A[i, k] * B[k, j]
        C[i, j] = tmp

An example usage of this function is as follows:

from test_ex_matmul in tests/doc_examples/test_matmul.py

x_h = np.arange(16).reshape([4, 4])
y_h = np.ones([4, 4])
z_h = np.zeros([4, 4])

x_d = cuda.to_device(x_h)
y_d = cuda.to_device(y_h)
z_d = cuda.to_device(z_h)

threadsperblock = (16, 16)
blockspergrid_x = math.ceil(z_h.shape[0] / threadsperblock[0])
blockspergrid_y = math.ceil(z_h.shape[1] / threadsperblock[1])
blockspergrid = (blockspergrid_x, blockspergrid_y)

matmul[blockspergrid, threadsperblock](x_d, y_d, z_d)
z_h = z_d.copy_to_host()
print(z_h)
print(x_h @ y_h)

This implementation is straightforward and intuitive but performs poorly, because the same matrix elements will be loaded multiple times from device memory, which is slow (some devices may have transparent data caches, but they may not be large enough to hold the entire inputs at once).

It will be faster if we use a blocked algorithm to reduce accesses to the device memory. CUDA provides a fast shared memory for threads in a block to cooperatively compute on a task. The following implements a faster version of the square matrix multiplication using shared memory:

from test_ex_matmul in tests/doc_examples/test_matmul.py

# Controls threads per block and shared memory usage.
# The computation will be done on blocks of TPBxTPB elements.
# TPB should not be larger than 32 in this example
TPB = 16

@cuda.jit
def fast_matmul(A, B, C):
    """
    Perform matrix multiplication of C = A * B using CUDA shared memory.

    Reference: https://stackoverflow.com/a/64198479/13697228 by @RobertCrovella
    """
    # Define an array in the shared memory
    # The size and type of the arrays must be known at compile time
    sA = cuda.shared.array(shape=(TPB, TPB), dtype=float32)
    sB = cuda.shared.array(shape=(TPB, TPB), dtype=float32)

    x, y = cuda.grid(2)

    tx = cuda.threadIdx.x
    ty = cuda.threadIdx.y
    bpg = cuda.gridDim.x  # blocks per grid

    # Each thread computes one element in the result matrix.
    # The dot product is chunked into dot products of TPB-long vectors.
    tmp = float32(0.0)
    for i in range(bpg):
        # Preload data into shared memory
        sA[ty, tx] = 0
        sB[ty, tx] = 0
        if y < A.shape[0] and (tx + i * TPB) < A.shape[1]:
            sA[ty, tx] = A[y, tx + i * TPB]
        if x < B.shape[1] and (ty + i * TPB) < B.shape[0]:
            sB[ty, tx] = B[ty + i * TPB, x]

        # Wait until all threads finish preloading
        cuda.syncthreads()

        # Computes partial product on the shared memory
        for j in range(TPB):
            tmp += sA[ty, j] * sB[j, tx]

        # Wait until all threads finish computing
        cuda.syncthreads()
    if y < C.shape[0] and x < C.shape[1]:
        C[y, x] = tmp

Because the shared memory is a limited resource, the code preloads a small block at a time from the input arrays. Then, it calls syncthreads() to wait until all threads have finished preloading and before doing the computation on the shared memory. It synchronizes again after the computation to ensure all threads have finished with the data in shared memory before overwriting it in the next loop iteration.

An example usage of the fast_matmul function is as follows:

from test_ex_matmul in tests/doc_examples/test_matmul.py

x_h = np.arange(16).reshape([4, 4])
y_h = np.ones([4, 4])
z_h = np.zeros([4, 4])

x_d = cuda.to_device(x_h)
y_d = cuda.to_device(y_h)
z_d = cuda.to_device(z_h)

threadsperblock = (TPB, TPB)
blockspergrid_x = math.ceil(z_h.shape[0] / threadsperblock[0])
blockspergrid_y = math.ceil(z_h.shape[1] / threadsperblock[1])
blockspergrid = (blockspergrid_x, blockspergrid_y)

fast_matmul[blockspergrid, threadsperblock](x_d, y_d, z_d)
z_h = z_d.copy_to_host()
print(z_h)
print(x_h @ y_h)

This passes a CUDA memory check test, which can help with debugging. Running the code above produces the following output:

$ python fast_matmul.py
[[ 6.  6.  6.  6.]
[22. 22. 22. 22.]
[38. 38. 38. 38.]
[54. 54. 54. 54.]]
[[ 6.  6.  6.  6.]
[22. 22. 22. 22.]
[38. 38. 38. 38.]
[54. 54. 54. 54.]]

Note

For high performance matrix multiplication in CUDA, see also the CuPy implementation.

The approach outlined here generalizes to non-square matrix multiplication as follows by adjusting the blockspergrid variable:

Again, here is an example usage:

from test_ex_matmul in tests/doc_examples/test_matmul.py

x_h = np.arange(115).reshape([5, 23])
y_h = np.ones([23, 7])
z_h = np.zeros([5, 7])

x_d = cuda.to_device(x_h)
y_d = cuda.to_device(y_h)
z_d = cuda.to_device(z_h)

threadsperblock = (TPB, TPB)
grid_y_max = max(x_h.shape[0], y_h.shape[0])
grid_x_max = max(x_h.shape[1], y_h.shape[1])
blockspergrid_x = math.ceil(grid_x_max / threadsperblock[0])
blockspergrid_y = math.ceil(grid_y_max / threadsperblock[1])
blockspergrid = (blockspergrid_x, blockspergrid_y)

fast_matmul[blockspergrid, threadsperblock](x_d, y_d, z_d)
z_h = z_d.copy_to_host()
print(z_h)
print(x_h @ y_h)

and the corresponding output:

$ python nonsquare_matmul.py
[[ 253.  253.  253.  253.  253.  253.  253.]
[ 782.  782.  782.  782.  782.  782.  782.]
[1311. 1311. 1311. 1311. 1311. 1311. 1311.]
[1840. 1840. 1840. 1840. 1840. 1840. 1840.]
[2369. 2369. 2369. 2369. 2369. 2369. 2369.]]
[[ 253.  253.  253.  253.  253.  253.  253.]
[ 782.  782.  782.  782.  782.  782.  782.]
[1311. 1311. 1311. 1311. 1311. 1311. 1311.]
[1840. 1840. 1840. 1840. 1840. 1840. 1840.]
[2369. 2369. 2369. 2369. 2369. 2369. 2369.]]

Calling a NumPy UFunc

UFuncs supported in Numba CUDA MLIR (see NumPy support) can be called inside kernels, but the output array must be passed in as a positional argument. The following example demonstrates a call to np.sin() inside a kernel following this pattern:

from test_ex_cuda_ufunc_call in tests/doc_examples/test_ufunc.py

import numpy as np
from numba import cuda

# A kernel calling a ufunc (sin, in this case)
@cuda.jit
def f(r, x):
    # Compute sin(x) with result written to r
    np.sin(x, r)

# Declare input and output arrays
x = np.arange(10, dtype=np.float32) - 5
r = np.zeros_like(x)

# Launch kernel that calls the ufunc
f[1, 1](r, x)

# A quick sanity check demonstrating equality of the sine computed by
# the sin ufunc inside the kernel, and NumPy's sin ufunc
np.testing.assert_allclose(r, np.sin(x))

Passing a pointer to a kernel

Instead of using arrays, it can be useful for a kernel to accept a pointer argument - for example, when data is provided by another (potentially non-Python) library.

Using pointers requires them to be explicitly specified in the signature. We can create them with types.CPointer:

from test_ex_cpointer in tests/doc_examples/test_cpointer.py

import numpy as np
from numba import cuda
from numba.cuda import types

# The first kernel argument is a pointer to a uint8 array.
# The second argument holds the length as a uint32.
# The return type of a kernel is always void.
sig = types.void(types.CPointer(types.uint8), types.uint32)

Next, we provide the signature to the @jit decorator when defining the kernel. Note that unlike with arrays, Numba CUDA MLIR does not implicitly know anything about the shape of the array. We need to pass the length into the kernel, instead of being able to use len(x) or x.shape as we would with an array.

from test_ex_cpointer in tests/doc_examples/test_cpointer.py

@cuda.jit(sig)
def add_one(x, n):
    i = cuda.grid(1)
    if i < n:
        x[i] += 1

To set up an example using the kernel and passing a pointer as an integer, we create a device array in the usual way, then use the CUDA Array Interface to obtain the pointer for the purpose of this example. However, the pointer could have been provided from anywhere - for example, from another library that doesn’t support the CUDA Array Interface, or from cudaMalloc in a C / C++ program, etc..

from test_ex_cpointer in tests/doc_examples/test_cpointer.py

x = cuda.to_device(np.arange(10, dtype=np.uint8))

# Print initial values of x
print(x.copy_to_host())  # [0 1 2 3 4 5 6 7 8 9]

# Obtain a pointer to the data from from the CUDA Array Interface
x_ptr = x.__cuda_array_interface__["data"][0]
x_len = len(x)

# Launch the kernel with the pointer and length
add_one[1, 32](x_ptr, x_len)

# Demonstrate that the data was updated by the kernel
print(x.copy_to_host())  # [ 1  2  3  4  5  6  7  8  9 10]