GH actions build

Author: txus

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ permissions:
 
 jobs:
   build-and-test:
-    name: ${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.build_type }}
+    name: ${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.backend }}-${{ matrix.build_type }}
     runs-on: ${{ matrix.os }}
 
     strategy:
@@ -22,10 +22,26 @@ jobs:
         os: [ubuntu-latest]
         compiler: [clang-20, gcc-14]
         build_type: [Release, Debug]
+        backend: [cuda, cpu]
+        exclude:
+          # Only test CPU backend with one compiler in Debug to save CI time
+          - backend: cpu
+            compiler: clang-20
+            build_type: Debug
 
     steps:
     - uses: actions/checkout@v4
 
+    - name: Install CUDA Toolkit
+      if: matrix.backend == 'cuda'
+      uses: Jimver/cuda-toolkit@v0.2.21
+      id: cuda-toolkit
+      with:
+        cuda: '12.8.0'
+        method: 'network'
+        sub-packages: '["nvcc", "cudart", "thrust"]'
+        non-cuda-sub-packages: '["libcublas", "libcublas-dev"]'
+
     - name: Set up compiler (Clang)
       if: matrix.compiler == 'clang-20'
       uses: egor-tensin/setup-clang@v1
@@ -102,12 +118,19 @@ jobs:
       uses: actions/cache@v4
       with:
         path: .cmake/fetchcontent
-        key: ${{ runner.os }}-${{ matrix.compiler }}-cmake-${{ hashFiles('**/CMakeLists.txt') }}
+        key: ${{ runner.os }}-${{ matrix.compiler }}-${{ matrix.backend }}-cmake-${{ hashFiles('**/CMakeLists.txt') }}
         restore-keys: |
-          ${{ runner.os }}-${{ matrix.compiler }}-cmake-
+          ${{ runner.os }}-${{ matrix.compiler }}-${{ matrix.backend }}-cmake-
 
     - name: Configure CMake
-      run: cmake -S . -B build -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+      run: |
+        CMAKE_ARGS="-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}"
+        if [[ "${{ matrix.backend }}" == "cuda" ]]; then
+          CMAKE_ARGS="$CMAKE_ARGS -DBACKEND_CUDA=ON -DSKIP_CUDA_TESTS=ON -DCMAKE_CUDA_ARCHITECTURES=120"
+        else
+          CMAKE_ARGS="$CMAKE_ARGS -DBACKEND_CUDA=OFF"
+        fi
+        cmake -S . -B build $CMAKE_ARGS
 
     - name: Build
       run: cmake --build build --config ${{ matrix.build_type }} --parallel
@@ -120,48 +143,4 @@ jobs:
       if: always()
       with:
         files: build/test-results.xml
-        check_name: Test Results (${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.build_type }})
-
-  # CUDA compilation check (no GPU required, just verifies code compiles)
-  cuda-build:
-    name: CUDA Build Check
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install CUDA Toolkit
-      uses: Jimver/cuda-toolkit@v0.2.21
-      id: cuda-toolkit
-      with:
-        cuda: '12.8.0'
-        method: 'network'
-        sub-packages: '["nvcc", "cudart", "thrust"]'
-        non-cuda-sub-packages: '["libcublas", "libcublas-dev"]'
-
-    - name: Install OpenMP
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgomp1
-
-    - name: Cache CMake dependencies
-      uses: actions/cache@v4
-      with:
-        path: .cmake/fetchcontent
-        key: ${{ runner.os }}-cuda-cmake-${{ hashFiles('**/CMakeLists.txt') }}
-        restore-keys: |
-          ${{ runner.os }}-cuda-cmake-
-
-    - name: Configure CMake with CUDA
-      run: |
-        cmake -S . -B build \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DTENSOR_BUILD_CUDA=ON \
-          -DSKIP_CUDA_TESTS=ON \
-          -DCMAKE_CUDA_ARCHITECTURES=89
-
-    - name: Build (including CUDA)
-      run: cmake --build build --config Release --parallel
-
-    - name: Run tests (CUDA tests will be skipped)
-      run: ctest --test-dir build --output-on-failure
+        check_name: Test Results (${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.backend }}-${{ matrix.build_type }})

CMakeLists.txt

@@ -10,21 +10,25 @@ project(
 # Add cmake module path for our custom modules
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
-# Backend detection
+# Backend detection - can be overridden via -DBACKEND_CUDA=ON/OFF
 if(APPLE)
-  set(BACKEND_METAL ON)
-  set(BACKEND_CUDA OFF)
+  option(BACKEND_METAL "Enable Metal backend" ON)
+  option(BACKEND_CUDA "Enable CUDA backend" OFF)
 else()
-  set(BACKEND_CUDA ON)
-  set(BACKEND_METAL OFF)
+  option(BACKEND_CUDA "Enable CUDA backend" ON)
+  option(BACKEND_METAL "Enable Metal backend" OFF)
 endif()
 
 # Propagate backend flags as compile definitions
 if(BACKEND_CUDA)
   add_compile_definitions(BACKEND_CUDA)
+  message(STATUS "Backend: CUDA enabled")
+else()
+  message(STATUS "Backend: CUDA disabled")
 endif()
 if(BACKEND_METAL)
   add_compile_definitions(BACKEND_METAL)
+  message(STATUS "Backend: Metal enabled")
 endif()
 
 set(FETCHCONTENT_BASE_DIR "${CMAKE_SOURCE_DIR}/.cmake/fetchcontent")
@@ -33,8 +37,13 @@ set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 # msgpack in tokenizers_cpp is doing weird stuff
 set(CMAKE_POLICY_VERSION_MINIMUM 3.5)
 
-set(CMAKE_C_COMPILER_LAUNCHER ccache)
-set(CMAKE_CXX_COMPILER_LAUNCHER ccache)
+# Use ccache if available
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+  set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+  set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+  message(STATUS "Using ccache: ${CCACHE_PROGRAM}")
+endif()
 
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
   set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

CMakePresets.json

@@ -27,7 +27,7 @@
         "CMAKE_CUDA_ARCHITECTURES": "120",
         "CMAKE_CUDA_COMPILER_TOOLKIT_ROOT": "$env{CUDA_PATH}",
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-        "TENSOR_BUILD_CUDA": "ON",
+        "BACKEND_CUDA": "ON",
         "CUDAToolkit_ROOT": "$env{CUDA_PATH}",
         "OpenMP_ROOT": "$env{OPENMP_ROOT}",
         "CLANG_RESOURCE_DIR": "$env{CLANG_RESOURCE_DIR}",
@@ -44,7 +44,7 @@
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "$env{CLANGXX_PATH}",
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-        "TENSOR_BUILD_CUDA": "OFF",
+        "BACKEND_CUDA": "OFF",
         "OpenMP_ROOT": "$env{OPENMP_ROOT}"
       }
     }

benchmarks/CMakeLists.txt

@@ -9,10 +9,4 @@ FetchContent_Declare(
 
 FetchContent_MakeAvailable(googlebenchmark)
 
-if(APPLE)
-  option(TENSOR_CUDA "Benchmark tensor_cuda library" OFF)
-else()
-  option(TENSOR_CUDA "Benchmark tensor_cuda library" ON)
-endif()
-
 add_subdirectory(tensor)

benchmarks/tensor/CMakeLists.txt

@@ -1,4 +1,4 @@
-if(TENSOR_CUDA)
+if(BACKEND_CUDA)
 add_executable(bm_tensor cpu/bm_ops.cpp cuda/bm_ops.cpp)
 target_link_libraries(bm_tensor PRIVATE tensor_core tensor_cpu tensor_cuda benchmark::benchmark_main)
 else()

src/forward/sampler.cpp

@@ -37,9 +37,12 @@ std::tuple<std::string, GenerationStats> Sampler<T, D, C>::generate(llama::Model
     Tensor<int, device::CPU> inputs_cpu({1, token_ids.size()}, std::vector<int>(token_ids));
 
     Tensor<int, D> inputs = [&]() {
+#ifdef BACKEND_CUDA
       if constexpr (std::same_as<D, device::CUDA>) {
         return inputs_cpu.cuda();
-      } else {
+      } else
+#endif
+      {
         return std::move(inputs_cpu);
       }
     }();
@@ -56,9 +59,12 @@ std::tuple<std::string, GenerationStats> Sampler<T, D, C>::generate(llama::Model
 
     // Transfer sampled ids to CPU to read values
     Tensor<int, device::CPU> sampled_ids_cpu = [&]() {
+#ifdef BACKEND_CUDA
       if constexpr (std::same_as<D, device::CUDA>) {
         return sampled_ids.cpu();
-      } else {
+      } else
+#endif
+      {
         return std::move(sampled_ids);
       }
     }();

tests/CMakeLists.txt

@@ -15,14 +15,8 @@ configure_file(
   ${CMAKE_CURRENT_BINARY_DIR}/common/test_config.h
 )
 
-# compiled library code
-if(APPLE)
-  option(BUILD_CUDA "Build CUDA tests" OFF)
-else()
-  option(BUILD_CUDA "Build CUDA tests" ON)
-endif()
-
-if(BUILD_CUDA)
+# Build CUDA tests if BACKEND_CUDA is enabled
+if(BACKEND_CUDA)
   enable_language(CUDA)
   find_package(CUDAToolkit REQUIRED)
   add_subdirectory(tensor/cuda)

tests/llama/test_grouped_query_attention.cpp

@@ -34,6 +34,7 @@ TEST(LlamaGQATest, Parity) {
   tensor_is_close<bfloat16>(output.view().span(), output_activations.span());
 }
 
+#ifdef BACKEND_CUDA
 TEST(LlamaCUDAGQATest, Parity) {
   SKIP_IF_NO_GPU();
   Loader<bfloat16, CUDA> act_loader(TEST_ACTIVATIONS_PATH);
@@ -63,6 +64,7 @@ TEST(LlamaCUDAGQATest, Parity) {
   // Use slightly higher tolerance for CUDA due to bf16 precision and kernel ordering differences
   tensor_is_close<bfloat16>(output_cpu.view().span(), output_activations.span(), 2e-3f, 2e-3f);
 }
+#endif
 
 TEST(LlamaGQATest, ParityWithKVCache) {
   Loader<bfloat16, CPU> act_loader(TEST_ACTIVATIONS_PATH);
@@ -104,6 +106,7 @@ TEST(LlamaGQATest, ParityWithKVCache) {
   EXPECT_EQ(gqa.get_cache_size(), 4);
 }
 
+#ifdef BACKEND_CUDA
 TEST(LlamaCUDAGQATest, ParityWithKVCache) {
   SKIP_IF_NO_GPU();
   Loader<bfloat16, CUDA> act_loader(TEST_ACTIVATIONS_PATH);
@@ -148,3 +151,4 @@ TEST(LlamaCUDAGQATest, ParityWithKVCache) {
 
   EXPECT_EQ(gqa.get_cache_size(), 4);
 }
+#endif

tests/llama/test_layer.cpp

@@ -39,6 +39,7 @@ TEST(LlamaLayerTest, Parity) {
   tensor_is_close<bfloat16>(output.view().span(), output_activations.span(), 1e-02);
 }
 
+#ifdef BACKEND_CUDA
 TEST(LlamaCUDALayerTest, Parity) {
   SKIP_IF_NO_GPU();
   Loader<bfloat16, CUDA> act_loader(TEST_ACTIVATIONS_PATH);
@@ -72,3 +73,4 @@ TEST(LlamaCUDALayerTest, Parity) {
 
   tensor_is_close<bfloat16>(output_cpu.view().span(), output_activations.span(), 1e-02);
 }
+#endif

tests/llama/test_mlp.cpp

@@ -30,6 +30,7 @@ TEST(LlamaMLPTest, Parity) {
   tensor_is_close<bfloat16>(output.view().span(), output_activations.span());
 }
 
+#ifdef BACKEND_CUDA
 TEST(LlamaCUDAMLPTest, Parity) {
   SKIP_IF_NO_GPU();
   Loader<bfloat16, CUDA> act_loader(TEST_ACTIVATIONS_PATH);
@@ -53,3 +54,4 @@ TEST(LlamaCUDAMLPTest, Parity) {
   // Use slightly relaxed tolerance for CUDA (3x default) due to cuBLAS precision differences
   tensor_is_close<bfloat16>(output_cpu.view().span(), output_activations.span(), 3e-3f, 3e-3f);
 }
+#endif