Add GitHub Actions CI for external contributors

Author: camille-004

.github/workflows/ci.yml

@@ -16,12 +16,26 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  images:
+    name: Define Base Images
+    runs-on: ubuntu-latest
+    outputs:
+      lint: ghcr.io/nvidia/cutile-python/lint:2026-01-12-aea51b7409cc
+      docs: ghcr.io/nvidia/cutile-python/docs:2026-01-12-96c265b9029e
+      build_py310: ghcr.io/nvidia/cutile-python/build_py_3.10_x86_64:2026-01-12-a3f084500fb0
+      build_py311: ghcr.io/nvidia/cutile-python/build_py_3.11_x86_64:2026-01-12-d0a88a59d0fd
+      build_py312: ghcr.io/nvidia/cutile-python/build_py_3.12_x86_64:2026-01-12-9cf7e54a5580
+      build_py313: ghcr.io/nvidia/cutile-python/build_py_3.13_x86_64:2026-01-12-7f9db97c8ad8
+    steps:
+      - run: echo "Defining image tags"
+
   lint:
     name: Lint
+    needs: images
     runs-on: ubuntu-latest
     timeout-minutes: 10
     container:
-      image: ghcr.io/nvidia/cutile-python/lint:2025-12-06-4cb7d16e4c20
+      image: ${{ needs.images.outputs.lint }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
@@ -30,10 +44,73 @@ jobs:
         run: flake8
 
       - name: Run cpplint
-        run: python3 ci/cpplint.py
+        run: python scripts/cpplint.py
 
       - name: Check license headers (REUSE)
-        run: ci/scripts/check_license.sh
+        run: scripts/check_license.sh
 
       - name: Check inline samples are up to date
-        run: python3 test/tools/inline_samples.py --check
+        run: python test/tools/inline_samples.py --check
+
+  docs:
+    name: Build Docs
+    needs: [images, build]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    container:
+      image: ${{ needs.images.outputs.docs }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Download wheel
+        uses: actions/download-artifact@v4
+        with:
+          name: wheel-py3.12-linux-x86_64
+          path: dist/
+
+      - name: Install wheel
+        run: pip install dist/*.whl
+
+      - name: Build documentation
+        run: make -C docs html
+
+      - name: Upload docs artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: docs-html
+          path: docs/build/html
+          retention-days: 7
+
+  build:
+    name: Build Wheel (Python ${{ matrix.python-version }})
+    needs: images
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        include:
+          - python-version: "3.10"
+            image_key: build_py310
+          - python-version: "3.11"
+            image_key: build_py311
+          - python-version: "3.12"
+            image_key: build_py312
+          - python-version: "3.13"
+            image_key: build_py313
+    container:
+      image: ${{ needs.images.outputs[matrix.image_key] }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Build wheel
+        run: python setup.py bdist_wheel
+
+      - name: Upload wheel artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheel-py${{ matrix.python-version }}-linux-x86_64
+          path: dist/*.whl
+          if-no-files-found: error
+          retention-days: 7

cext/CMakeLists.txt

@@ -74,7 +74,6 @@ target_link_options(_cext_shared PUBLIC ${cext_link_flags} ${nostdlib_flags} -Wl
 add_executable(test_stream_buffer
     test/test_stream_buffer.cpp
     cuda_loader.cpp
-    cuda_helper.cpp
     memory.cpp
     )
 target_compile_options(test_stream_buffer PUBLIC ${cext_compile_flags} ${test_coverage_options})

cext/cuda_helper.cpp

@@ -6,52 +6,40 @@
 #include "cuda_loader.h"
 
 
-const char* get_cuda_error(const DriverApi* driver, CUresult res) {
+const char* get_cuda_error(CUresult res) {
     const char* str = nullptr;
-    driver->cuGetErrorString(res, &str);
+    g_cuGetErrorString(res, &str);
     return str ? str : "Unknown error";
 }
 
-Status check_driver_version(const DriverApi* driver, int minimum_version) {
-    int version;
-    CUresult res = driver->cuDriverGetVersion(&version);
+void try_init_cuda() {
+    ErrorGuard guard;
+    CUresult res = g_cuInit(0);
     if (res != CUDA_SUCCESS) {
-        PyErr_Format(PyExc_RuntimeError, "cuDriverGetVersion: %s", get_cuda_error(driver, res));
-        return ErrorRaised;
-    }
-    if (version < minimum_version) {
-        int major = version / 1000;
-        int minor = (version % 1000) / 10;
-        int required_major = minimum_version / 1000;
-        PyErr_Format(PyExc_RuntimeError,
-                     "Minimum driver version required is %d.0, got %d.%d",
-                     required_major, major, minor);
-        return ErrorRaised;
+        raise(PyExc_RuntimeError, "cuInit: %s", get_cuda_error(res));
+        SavedException exc = save_raised_exception();
+        LOG_PYTHON_ERROR("warning", exc, "Failed to initialized CUDA");
     }
-    return OK;
 }
 
 PyObject* get_max_grid_size(PyObject *self, PyObject *args) {
     int device_id;
     if (!PyArg_ParseTuple(args, "i", &device_id))
         return NULL;
 
-    Result<const DriverApi*> driver = get_driver_api();
-    if (!driver.is_ok()) return NULL;
-
     CUdevice dev;
-    CUresult res = (*driver)->cuDeviceGet(&dev, device_id);
+    CUresult res = g_cuDeviceGet(&dev, device_id);
     if (res != CUDA_SUCCESS)
-        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGet: %s", get_cuda_error(*driver, res));
+        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGet: %s", get_cuda_error(res));
 
     int max_grid_size[3];
     for (int i = 0; i < 3; ++i) {
-        res = (*driver)->cuDeviceGetAttribute(&max_grid_size[i],
+        res = g_cuDeviceGetAttribute(&max_grid_size[i],
             static_cast<CUdevice_attribute>(CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X + i),
             dev);
         if (res != CUDA_SUCCESS) {
             return PyErr_Format(PyExc_RuntimeError,
-                                "cuDeviceGetAttribute: %s", get_cuda_error(*driver, res));
+                                "cuDeviceGetAttribute: %s", get_cuda_error(res));
         }
     }
     return Py_BuildValue("(iii)", max_grid_size[0], max_grid_size[1], max_grid_size[2]);
@@ -60,36 +48,26 @@ PyObject* get_max_grid_size(PyObject *self, PyObject *args) {
 PyObject* get_compute_capability(PyObject *self, PyObject *Py_UNUSED(ignored)) {
     int major, minor;
     CUdevice dev;
-
-    Result<const DriverApi*> driver_result = get_driver_api();
-    if (!driver_result.is_ok()) return NULL;
-    const DriverApi* d = *driver_result;
-
-    CUresult res = d->cuDeviceGet(&dev, 0);
+    CUresult res = g_cuDeviceGet(&dev, 0);
     if (res != CUDA_SUCCESS) {
-        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGet: %s", get_cuda_error(d, res));
+        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGet: %s", get_cuda_error(res));
     }
-    res = d->cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev);
+    res = g_cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev);
     if (res != CUDA_SUCCESS) {
-        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGetAttribute: %s", get_cuda_error(d, res));
+        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGetAttribute: %s", get_cuda_error(res));
     }
-    res = d->cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev);
+    res = g_cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev);
     if (res != CUDA_SUCCESS) {
-        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGetAttribute: %s", get_cuda_error(d, res));
+        return PyErr_Format(PyExc_RuntimeError, "cuDeviceGetAttribute: %s", get_cuda_error(res));
     }
     return Py_BuildValue("(ii)", major, minor);
 }
 
 PyObject* get_driver_version(PyObject *self, PyObject *Py_UNUSED(ignored)) {
     int major, minor;
-
-    Result<const DriverApi*> driver_result = get_driver_api();
-    if (!driver_result.is_ok()) return NULL;
-    const DriverApi* d = *driver_result;
-
-    CUresult res = d->cuDriverGetVersion(&major);
+    CUresult res = g_cuDriverGetVersion(&major);
     if (res != CUDA_SUCCESS) {
-        return PyErr_Format(PyExc_RuntimeError, "cuDriverGetVersion: %s", get_cuda_error(d, res));
+        return PyErr_Format(PyExc_RuntimeError, "cuDriverGetVersion: %s", get_cuda_error(res));
     }
     minor = (major % 1000) / 10;
     major = major / 1000;

cext/cuda_helper.h

@@ -9,12 +9,8 @@
 #include "py.h"
 #include <cuda.h>
 
-struct DriverApi;
-
 Status cuda_helper_init(PyObject* m);
 
-const char* get_cuda_error(const DriverApi*, CUresult res);
-
-void try_cuInit(const DriverApi*);
+const char* get_cuda_error(CUresult res);
 
-Status check_driver_version(const DriverApi*, int minimum_version);
+void try_init_cuda();

cext/cuda_loader.cpp

@@ -50,12 +50,11 @@ F get_proc_address(cuGetProcAddress_v2_t getter,
 FOREACH_CUDA_FUNCTION_TO_LOAD(DEFINE_CUDA_FUNCTION_GLOBAL)
 
 #define GET_PROC_ADDRESS(name, cuda_ver) \
-        if (!(driver_api.name = \
-                    get_proc_address<decltype(name)*>(_cuGetProcAddress, #name, cuda_ver))) \
+        if (!(g_##name = get_proc_address<decltype(name)*>(_cuGetProcAddress, #name, cuda_ver))) \
             return ErrorRaised;
 
 
-static Status cuda_loader_init(DriverApi& driver_api) {
+Status cuda_loader_init() {
     PyPtr load_libcuda_mod = steal(PyImport_ImportModule("cuda.tile._load_libcuda"));
     if (!load_libcuda_mod) return ErrorRaised;
 
@@ -73,22 +72,3 @@ static Status cuda_loader_init(DriverApi& driver_api) {
 
     return OK;
 }
-
-
-static constexpr int MIN_DRIVER_VERSION = 13000;
-
-Result<const DriverApi*> get_driver_api() {
-    static bool initialized;
-    static DriverApi instance;
-    if (!initialized) {
-        if (!cuda_loader_init(instance))
-            return ErrorRaised;
-        CUresult res = instance.cuInit(0);
-        if (res != CUDA_SUCCESS)
-            return raise(PyExc_RuntimeError, "cuInit: %s", get_cuda_error(&instance, res));
-        if (!check_driver_version(&instance, MIN_DRIVER_VERSION))
-            return ErrorRaised;
-        initialized = true;
-    }
-    return &instance;
-}

cext/cuda_loader.h

@@ -9,6 +9,8 @@
 #include "py.h"
 #include <cuda.h>
 
+Status cuda_loader_init();
+
 #define FOREACH_CUDA_FUNCTION_TO_LOAD(X) \
     X(cuInit, 2000) \
     X(cuLibraryLoadFromFile, 12000) \
@@ -45,10 +47,8 @@
 
 
 #define DECLARE_CUDA_FUNC_EXTERN(name, _cuda_version) \
-    decltype(::name)* name;
+    extern decltype(name)* g_##name;
+
+FOREACH_CUDA_FUNCTION_TO_LOAD(DECLARE_CUDA_FUNC_EXTERN)
 
-struct DriverApi {
-    FOREACH_CUDA_FUNCTION_TO_LOAD(DECLARE_CUDA_FUNC_EXTERN)
-};
 
-Result<const DriverApi*> get_driver_api();

cext/module.cpp

@@ -4,6 +4,7 @@
 
 #include "py.h"
 
+#include "cuda_loader.h"
 #include "tile_kernel.h"
 #include "cuda_helper.h"
 
@@ -19,6 +20,11 @@ static PyModuleDef module_def = {
 };
 
 PyMODINIT_FUNC PyInit__cext() {
+    if (!cuda_loader_init())
+        return nullptr;
+
+    try_init_cuda();
+
     PyPtr m = steal(PyModule_Create(&module_def));
     if (!m) return nullptr;