import ctypes lib = ctypes.CDLL("./libmy_experiment.so")  # (re)define function signature for `void myfunc(float*, size_t)` lib.myfunc.argtypes = [ctypes.c_void_p, ctypes.c_size_t] lib.myfunc.restype = None  input_array = np.array([1, 2, 3], dtype=np.float32) # call function lib.myfunc(  input_array.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),  ctypes.c_size_t(len(input_array)))

#include <Python.h> #include <numpy/arrayobject.h>  static PyObject *myfunc(PyObject *self, PyObject *args) {  PyObject *arr = NULL;  if (!PyArg_ParseTuple(args, "O", &arr)) return NULL;  PyArrayObject *np_arr = PyArray_FROM_OTF(  arr, NPY_FLOAT32, NPY_ARRAY_INOUT_ARRAY);  float *arr_ptr = PyArray_DATA(np_arr);  npy_intp *size = PyArray_SHAPE(np_arr);  for (size_t i = 0; i < size[0]; ++i) arr_ptr[i] *= 2; }

static struct PyModuleDef my_module = {  PyModuleDef_HEAD_INIT,  .m_name = "my_experiment" }; static PyMethodDef my_methods[] = {  {"myfunc", myfunc, METH_VARARGS, "In-place modifies ndarray[float]"},  {NULL, NULL, 0, NULL} // Sentinel }; PyMODINIT_FUNC PyInit_spam(void) {  import_array();  return PyModule_Create(&my_module); }

>>> import my_experiment >>> help(my_experiment.myfunc) Help on built-in function myfunc in my_experiment:  my_experiment.myfunc = myfunc(...)  In-place modifies ndarray[float]

int my_buffer(PyObject *obj, Py_buffer *view, int flags) {  view->buf = (void *)MY_GET_ARR_PTR(obj);  view->obj = obj;  view->len = MY_GET_ARR_SIZE(obj) * sizeof(float);  view->readonly = 0;  view->itemsize = sizeof(float);  view->format = "f";  view->ndim = MY_GET_ARR_NDIM(obj);  view->shape = MY_GET_ARR_SHAPE(obj);  view->strides = MY_GET_ARR_STRIDES(obj);  view->suboffsets = NULL; view->internal = NULL;  Py_INCREF(view->obj);  return 0; }

static PyObject *myfunc(PyObject *self, PyObject *args) {  Py_buffer *view = NULL;  if (!PyArg_ParseTuple(args, "w*", &view)) return NULL;  float *arr_ptr = view->buf;  for (size_t i = 0; i < view->shape[0]; ++i) arr_ptr[i] *= 2;  PyBuffer_Release(view); }

#include <pybind11/pybind11.h>  void myfunc(pybind11::buffer view) {  pybind11::buffer_info arr = view.request();  float *ptr = arr.ptr;  if (arr.ndim != 1) throw std::runtime_error("expected 1D array");  for (size_t i = 0; i < arr.size; ++i) ptr[i] *= 2; } using namespace pybind11::literals; PYBIND11_MODULE(my_examples, m){  m.def("myfunc", &myfunc, "input_array"_a,  "In-place modifies ndarray[float]"); }

@property def __cuda_array_interface__(self) -> Dict[str, Any]:  return {'shape': self.shape, 'typestr': numpy.dtype(self.typechar).str,  'data': (self.get_memory_address(), self.read_only), 'version': 3}

@property def __dlpack__(self, copy=False, max_version: tuple[int]=None,  stream: int=None, dl_device: tuple[int]=None ):  dl_tensor = DLTensor(data=self.addr, device=dl_device, ndim=self.ndim,  dtype=DLDataType.from_dtype(self.dtype),  shape=ctypes.cast(self.shape, ctypes.POINTER(ctypes.c_int64)),  strides=None, byte_offset=0)   managed_tensor = DLManagedTensor(dl_tensor=dl_tensor, manager_ctx=0,  deleter=DLTensorDeleter(lambda addr: None))  return pythonapi.PyCapsule_New(ctypes.byref(managed_tensor), b'dltensor', None)

#include <cuda_runtime.h> int N = ...; float cpu_data[N]; for (int i = 0; i < N; ++i) data[i] = ...;  float *gpu_data; cudaMalloc(&gpu_data, sizeof(float) * N); cudaMemcpy(gpu_data, cpu_data, sizeof(float) * N, cudaMemcpyHostToDevice); mykernel<<<1, N>>>(gpu_data, N); cudaDeviceSynchronize(); cudaMemcpy(cpu_data, gpu_data, sizeof(float) * N, cudaMemcpyDeviceToHost); cudaDeviceSynchronize(); cudaFree(gpu_data);

#include <cuda_runtime.h> int N = ...; float *data; cudaMallocManaged(&data, sizeof(float) * N); for (int i = 0; i < N; ++i) data[i] = ...;  mykernel<<<1, N>>>(data, N); cudaDeviceSynchronize();