add cuda

Author: alanray-tech

.github/workflows/linux-cuda.yml

@@ -0,0 +1,75 @@
+name: Build Python Wheels (Linux CUDA)
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - '*'
+  pull_request:
+    branches:
+      - main
+  release:
+    types: [published]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.head_ref || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build-cuda-wheels:
+    name: Build CUDA Wheels (Linux)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          show-progress: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build wheels
+        uses: pypa/[email protected]
+        env:
+          CIBW_BUILD: "cp311-*linux*"
+          CIBW_MANYLINUX_X86_64_IMAGE: "quay.io/pypa/manylinux_2_28_x86_64:latest"
+          CIBW_BEFORE_BUILD: |
+            # Install CUDA toolkit
+            # For manylinux containers, you may need to install CUDA manually
+            # Option 1: Use system package manager (if available)
+            yum install -y cuda-toolkit-12-4 2>/dev/null || \
+            apt-get update && apt-get install -y nvidia-cuda-toolkit 2>/dev/null || \
+            echo "CUDA toolkit installation skipped - may need manual setup"
+            
+            # Set CUDA environment variables
+            export CUDA_HOME=/usr/local/cuda
+            export PATH=$PATH:/usr/local/cuda/bin
+            export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
+            
+            # Verify CUDA if available
+            if command -v nvcc &> /dev/null; then
+              echo "CUDA compiler version:"
+              nvcc --version || true
+            fi
+          CIBW_ENVIRONMENT: "CUDA_HOME=/usr/local/cuda PATH=$PATH:/usr/local/cuda/bin LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH"
+          CIBW_CONFIG_SETTINGS: "wheel.build-tag=${{ github.run_number }}"
+        with:
+          output-dir: wheelhouse
+          package-dir: linux-cuda
+
+      - name: List built wheels
+        shell: bash
+        run: |
+          echo "Built CUDA wheels:"
+          ls -lh wheelhouse/*.whl || echo "No wheels found"
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheelhouse-linux-cuda
+          path: wheelhouse/*.whl
+

linux-cuda/CMakeLists.txt

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.26)
+
+function(split_version str MAJOR MINOR PATCH)
+    # Parse the string directly into the names provided by the arguments
+    string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" _ ${str})
+    
+    set(${MAJOR} ${CMAKE_MATCH_1})
+    set(${MINOR} ${CMAKE_MATCH_2})
+    set(${PATCH} ${CMAKE_MATCH_3})
+
+    return(PROPAGATE ${MAJOR} ${MINOR} ${PATCH})
+endfunction()
+
+if(DEFINED SKBUILD_PROJECT_VERSION)
+    set(HELLO_CUDA_VERSION ${SKBUILD_PROJECT_VERSION})
+else()
+    set(HELLO_CUDA_VERSION "0.9.0")
+endif()
+
+split_version(${HELLO_CUDA_VERSION} 
+    HELLO_CUDA_VERSION_MAJOR
+    HELLO_CUDA_VERSION_MINOR
+    HELLO_CUDA_VERSION_PATCH)
+
+# Enable CUDA language support
+enable_language(CUDA)
+
+project(hello_cuda VERSION ${HELLO_CUDA_VERSION} LANGUAGES CXX CUDA)
+
+message(STATUS "HELLO_CUDA_VERSION_MAJOR: ${HELLO_CUDA_VERSION_MAJOR}")
+message(STATUS "HELLO_CUDA_VERSION_MINOR: ${HELLO_CUDA_VERSION_MINOR}")
+message(STATUS "HELLO_CUDA_VERSION_PATCH: ${HELLO_CUDA_VERSION_PATCH}")
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CUDA_STANDARD 17)
+set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+
+# Find CUDA
+find_package(CUDA REQUIRED)
+message(STATUS "CUDA found: ${CUDA_FOUND}")
+message(STATUS "CUDA version: ${CUDA_VERSION}")
+message(STATUS "CUDA toolkit root: ${CUDA_TOOLKIT_ROOT_DIR}")
+
+# Set CUDA architectures (can be overridden by cmake.args in pyproject.toml)
+if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    set(CMAKE_CUDA_ARCHITECTURES "75;80;86;89;90" CACHE STRING "CUDA architectures")
+endif()
+
+# Find pybind11
+find_package(pybind11 CONFIG REQUIRED)
+
+# Create the pybind11 module with CUDA support
+pybind11_add_module(hello_cuda 
+    src/hello_cuda.cpp
+    src/cuda_kernel.cu
+)
+
+# Link CUDA libraries
+target_link_libraries(hello_cuda PRIVATE 
+    ${CUDA_LIBRARIES}
+)
+
+# Include CUDA directories
+target_include_directories(hello_cuda PRIVATE
+    ${CUDA_INCLUDE_DIRS}
+)
+
+# Compile definitions
+target_compile_definitions(hello_cuda PUBLIC 
+    HELLO_CUDA_VERSION="${HELLO_CUDA_VERSION}"
+    CUDA_VERSION="${CUDA_VERSION}"
+)
+
+# Set CUDA separable compilation
+set_property(TARGET hello_cuda PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+
+install(
+  TARGETS hello_cuda
+  LIBRARY DESTINATION ${SKBUILD_PLATLIB_DIR}
+  RUNTIME DESTINATION ${SKBUILD_PLATLIB_DIR}
+  ARCHIVE DESTINATION ${SKBUILD_PLATLIB_DIR}
+)
+

linux-cuda/README.md

@@ -0,0 +1,38 @@
+# CUDA Hello World Example
+
+This directory contains a simple CUDA-enabled Python extension built with pybind11 and CMake.
+
+## Structure
+
+- `CMakeLists.txt` - CMake configuration with CUDA support
+- `src/hello_cuda.cpp` - Main C++ code with pybind11 bindings
+- `src/cuda_kernel.cu` - CUDA kernel implementation
+- `pyproject.toml` - Build configuration for scikit-build-core
+
+## Features
+
+- Simple hello world function that detects CUDA devices
+- Vector addition using CUDA kernels
+- Demonstrates CUDA integration with pybind11
+
+## Usage
+
+After building and installing:
+
+```python
+import hello_cuda
+
+# Get CUDA info
+print(hello_cuda.hello())
+
+# Add vectors using CUDA
+a = [1.0, 2.0, 3.0, 4.0]
+b = [5.0, 6.0, 7.0, 8.0]
+result = hello_cuda.add_vectors(a, b)
+print(result)  # [6.0, 8.0, 10.0, 12.0]
+```
+
+## Building
+
+This is configured to build with cibuildwheel in the GitHub Actions workflow (`.github/workflows/linux-cuda.yml`).
+

linux-cuda/pyproject.toml

@@ -0,0 +1,24 @@
+# CUDA-specific build configuration for Linux
+# This file is used when building with cibuildwheel for CUDA-enabled wheels
+# The actual CUDA installation and environment setup is handled in the GitHub Actions workflow
+
+[tool.scikit-build]
+minimum-version = "0.9"
+cmake.version = ">=3.26"
+build-dir = "build/{wheel_tag}"
+wheel.packages = []
+
+# CMake configuration for CUDA
+# These args will be passed to CMake during the build
+# Note: CUDA language support should be enabled in your CMakeLists.txt
+cmake.args = [
+    "-DCMAKE_CUDA_ARCHITECTURES=75;80;86;89;90",  # Common GPU architectures (adjust as needed)
+    "-DENABLE_CUDA=ON",
+    "-DCMAKE_CUDA_COMPILER=nvcc",
+]
+
+# Example CMakeLists.txt additions needed for CUDA:
+# cmake_minimum_required(VERSION 3.26)
+# enable_language(CUDA)
+# find_package(CUDA REQUIRED)
+# set(CMAKE_CUDA_STANDARD 17)

linux-cuda/src/cuda_kernel.cu

@@ -0,0 +1,23 @@
+#include <cuda_runtime.h>
+
+// CUDA kernel to add two vectors
+__global__ void add_vectors_kernel(float* a, float* b, float* c, int n) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) {
+        c[idx] = a[idx] + b[idx];
+    }
+}
+
+// C interface for the CUDA kernel
+extern "C" void add_vectors_cuda(float* a, float* b, float* c, int n) {
+    // Calculate grid and block dimensions
+    int threads_per_block = 256;
+    int blocks_per_grid = (n + threads_per_block - 1) / threads_per_block;
+    
+    // Launch kernel
+    add_vectors_kernel<<<blocks_per_grid, threads_per_block>>>(a, b, c, n);
+    
+    // Wait for kernel to complete
+    cudaDeviceSynchronize();
+}
+

linux-cuda/src/hello_cuda.cpp

@@ -0,0 +1,91 @@
+#include <pybind11/pybind11.h>
+#include <vector>
+#include <string>
+#include <cuda_runtime.h>
+
+namespace py = pybind11;
+
+// CUDA kernel declaration (defined in cuda_kernel.cu)
+extern "C" void add_vectors_cuda(float* a, float* b, float* c, int n);
+
+// Simple hello function
+std::string hello() {
+    int device_count = 0;
+    cudaError_t err = cudaGetDeviceCount(&device_count);
+    
+    std::string result = "v" + std::string(HELLO_CUDA_VERSION) + ": Hello from C++ with CUDA!";
+    
+    if (err == cudaSuccess && device_count > 0) {
+        result += "\nFound " + std::to_string(device_count) + " CUDA device(s)";
+        
+        // Get device info
+        cudaDeviceProp prop;
+        if (cudaGetDeviceProperties(&prop, 0) == cudaSuccess) {
+            result += "\nDevice 0: " + std::string(prop.name);
+            result += " (Compute " + std::to_string(prop.major) + "." + std::to_string(prop.minor) + ")";
+        }
+    } else {
+        result += "\nCUDA devices not available";
+    }
+    
+    return result;
+}
+
+// Python function that uses CUDA kernel
+py::list add_vectors(py::list a, py::list b) {
+    // Convert Python lists to vectors
+    std::vector<float> vec_a, vec_b;
+    for (auto item : a) {
+        vec_a.push_back(py::cast<float>(item));
+    }
+    for (auto item : b) {
+        vec_b.push_back(py::cast<float>(item));
+    }
+    
+    if (vec_a.size() != vec_b.size()) {
+        throw std::runtime_error("Vectors must have the same size");
+    }
+    
+    int n = vec_a.size();
+    if (n == 0) {
+        return py::list();
+    }
+    
+    // Allocate device memory
+    float *d_a, *d_b, *d_c;
+    cudaMalloc(&d_a, n * sizeof(float));
+    cudaMalloc(&d_b, n * sizeof(float));
+    cudaMalloc(&d_c, n * sizeof(float));
+    
+    // Copy data to device
+    cudaMemcpy(d_a, vec_a.data(), n * sizeof(float), cudaMemcpyHostToDevice);
+    cudaMemcpy(d_b, vec_b.data(), n * sizeof(float), cudaMemcpyHostToDevice);
+    
+    // Launch CUDA kernel
+    add_vectors_cuda(d_a, d_b, d_c, n);
+    
+    // Copy result back
+    std::vector<float> result(n);
+    cudaMemcpy(result.data(), d_c, n * sizeof(float), cudaMemcpyDeviceToHost);
+    
+    // Free device memory
+    cudaFree(d_a);
+    cudaFree(d_b);
+    cudaFree(d_c);
+    
+    // Convert to Python list
+    py::list py_result;
+    for (float val : result) {
+        py_result.append(val);
+    }
+    
+    return py_result;
+}
+
+PYBIND11_MODULE(hello_cuda, m) {
+    m.doc() = "Hello world pybind11 module with CUDA support";
+    m.def("hello", &hello, "Return a friendly greeting from C++ with CUDA info");
+    m.def("add_vectors", &add_vectors, "Add two vectors using CUDA",
+          py::arg("a"), py::arg("b"));
+}
+