PR: Add CUDA

.github/workflows/linux_build_and_test.yaml

@@ -2,9 +2,9 @@ name: linux-build-and-test
 
 on:
   push:
-    branches: [ main ]
+    branches: [ main, develop ]
   pull_request:
-    branches: [ main ]
+    branches: [ main, develop ]
 
 jobs:
   linux-build-and-test:
@@ -17,17 +17,11 @@ jobs:
     - name: Set up CMake
       uses: jwlawson/actions-setup-cmake@v2
 
-    - name: Install OpenEXR (Ubuntu)
-      run: sudo apt-get update && sudo apt-get install -y libopenexr-dev libimath-dev
-
-    - name: Install dependencies
-      run: sudo apt-get update && sudo apt-get install -y g++ ninja-build
-
     - name: Configure
-      run: cmake -S . -B build -G Ninja
+      run: cmake --preset linux-cpu-debug
 
     - name: Build
-      run: cmake --build build --parallel --config Release
+      run: cmake --build --preset linux-cpu-debug
 
     - name: Run tests
-      run: cd build && ctest --output-on-failure --verbose
+      run: ctest --preset linux-cpu-debug

.gitignore

@@ -2,19 +2,17 @@
 Thumbs.db
 /_deps/
 /CMakeFiles/
-/build/
-/build-debug/
-/build-release/
-/build-mac-debug/
-
+/build*
 /Testing/
 *.dSYM
 /.vscode/
 /.VSCodeCounter/
+/vcpkg/
+/vcpkg_installed/
 
 tests/test_files/
 
 CTestTestfile.cmake
 Makefile
 cmake_install.cmake
-
+cuda-keyring_1.1-1_all.deb

CMakeLists.txt

@@ -1,146 +1,145 @@
-cmake_minimum_required(VERSION 3.23)
+cmake_minimum_required(VERSION 3.26)
 
-project(DenoiseMachineX
-    VERSION 0.1.0
-    LANGUAGES CXX
-)
+project(DenoiseMachineX VERSION 0.1.0 LANGUAGES CXX)
+
+option(BUILD_CUDA       "Build CUDA backends"             ON)
+option(BUILD_TESTING    "Build tests"                     ON)
+
+option(DMX_ENABLE_HEAVY_TESTS "Enable heavy/slow tests"   ON)
+if(DMX_ENABLE_HEAVY_TESTS)
+    add_compile_definitions(DMX_ENABLE_HEAVY_TESTS=1)
+else()
+    add_compile_definitions(DMX_ENABLE_HEAVY_TESTS=0)
+endif()
 
-# ---- Options
-option(BUILD_CUDA     "Build CUDA backends" OFF)
-option(BUILD_TESTING  "Build tests"          ON)
 
-# ---- C++ setup
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
+# Log level by Default 0 = TRACE
+set(DMX_MIN_LOG_LEVEL "0" CACHE STRING "Compile-time minimum log level")
+add_compile_definitions(DMX_MIN_LOG_LEVEL=${DMX_MIN_LOG_LEVEL})
 
-# Output dirs (bin/ lib/)
+# Output dirs
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
-# ---- Dependencies: OpenEXR + Imath (prefer CONFIG, fallback to modules)
-# Try config packages first (v3+)
-find_package(Imath CONFIG QUIET)
-find_package(OpenEXR CONFIG QUIET)
-
-# Fallback to classic find modules (v2.x dev packages)
-if(NOT Imath_FOUND)
-    find_package(Imath CONFIG REQUIRED)       # provides Imath::Imath and/or IlmBase::Imath
-endif()
-if(NOT OpenEXR_FOUND)
-    find_package(OpenEXR CONFIG REQUIRED)     # provides OpenEXR::OpenEXR or legacy targets
+if(POLICY CMP0169)
+  cmake_policy(SET CMP0169 OLD)
 endif()
 
+include(FetchContent)
 
-if(NOT OpenEXR_FOUND OR NOT Imath_FOUND)
-    message(FATAL_ERROR
-        "\nOpenEXR and/or Imath not found!\n"
-        "Please install them before configuring this project.\n"
-        "On macOS, run:\n"
-        "    brew install openexr imath\n"
-        "On Ubuntu/Debian, run:\n"
-        "    sudo apt install libopenexr-dev libimath-dev\n"
-        "On Windows (vcpkg):\n"
-        "    vcpkg install openexr\n"
-    )
-endif()
-
-# Include headers
-include_directories(${CMAKE_SOURCE_DIR}/include)
-
-# ---- Sources (CPP always; CU optional when BUILD_CUDA=ON)
-file(GLOB_RECURSE SRC_CPP CONFIGURE_DEPENDS
-  ${CMAKE_SOURCE_DIR}/src/*.cpp
+FetchContent_Declare(Imath
+  GIT_REPOSITORY https://github.com/AcademySoftwareFoundation/Imath.git
+  GIT_TAG v3.1.10
+)
+FetchContent_MakeAvailable(Imath)
+FetchContent_Declare(OpenEXR
+  GIT_REPOSITORY https://github.com/AcademySoftwareFoundation/openexr.git
+  GIT_TAG v3.2.4
 )
+FetchContent_MakeAvailable(OpenEXR)
 
-# keep CLI separate so we can add it explicitly to the exe
+# ---- Sources
+file(GLOB_RECURSE SRC_CPP CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE SRC_CU  CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/src/*.cu)
 set(CLI_MAIN ${CMAKE_SOURCE_DIR}/cli/main.cpp)
 
-
 if(BUILD_CUDA)
   enable_language(CUDA)
   find_package(CUDAToolkit REQUIRED)
   add_compile_definitions(DMX_ENABLE_CUDA=1)
-  file(GLOB_RECURSE SRC_CU CONFIGURE_DEPENDS
-    ${CMAKE_SOURCE_DIR}/src/*.cu
-  )
+  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    set(CMAKE_CUDA_ARCHITECTURES "75;86;87;89;90;120" CACHE STRING "CUDA architectures")
+  endif()
 else()
   add_compile_definitions(DMX_ENABLE_CUDA=0)
   set(SRC_CU)
 endif()
 
+# ---- Executable
+add_executable(dmxdenoiser
+  ${CLI_MAIN}
+  ${SRC_CPP}
+  ${SRC_CU}
+)
 
-# ---- Executable (DIRECTLY links all sources → static registrars run)
-add_executable(dmxdenoiser ${SRC_CPP} ${SRC_CU} ${CLI_MAIN})
-
-
-# CLI executable
-#add_executable(dmxdenoiser ${SRC_FILES} cli/main.cpp)
-
-target_include_directories(dmxdenoiser
-    PUBLIC
-        ${CMAKE_SOURCE_DIR}/include
+target_include_directories(dmxdenoiser PRIVATE
+  ${CMAKE_SOURCE_DIR}/include
+  ${imath_SOURCE_DIR}/src
+  ${imath_BINARY_DIR}/config
+  ${openexr_SOURCE_DIR}/src/lib
+  ${openexr_BINARY_DIR}/config
 )
 
-# Link OpenEXR/Imath via whatever targets exist
 target_link_libraries(dmxdenoiser
-    PUBLIC
-        $<$<TARGET_EXISTS:OpenEXR::OpenEXR>:OpenEXR::OpenEXR>
-        $<$<TARGET_EXISTS:Imath::Imath>:Imath::Imath>
-        $<$<TARGET_EXISTS:Imath::Half>:Imath::Half>
-        $<$<TARGET_EXISTS:OpenEXR::IlmImf>:OpenEXR::IlmImf>
-        $<$<TARGET_EXISTS:IlmBase::Imath>:IlmBase::Imath>
-        $<$<TARGET_EXISTS:IlmBase::Half>:IlmBase::Half>
-        $<$<TARGET_EXISTS:IlmBase::IlmThread>:IlmBase::IlmThread>
-        $<$<TARGET_EXISTS:Iex::Iex>:Iex::Iex>
+  PRIVATE
+    Imath::Imath
+    OpenEXR::OpenEXR
 )
 
 if(BUILD_CUDA)
   target_link_libraries(dmxdenoiser PRIVATE CUDA::cudart CUDA::cuda_driver)
-  set_target_properties(dmxdenoiser PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+  set_target_properties(dmxdenoiser PROPERTIES
+    CUDA_SEPARABLE_COMPILATION ON
+    CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}"
+  )
 endif()
 
-
+# Silence MSVC deprecation spam from OpenEXR threadpool atomics
+if(MSVC)
+  add_compile_definitions(_SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING)
+endif()
 
 # ---- Tests
 if(BUILD_TESTING)
-    include(FetchContent)
-    include(CTest)
-    enable_testing()
-
-    FetchContent_Declare(
-      googletest
-      GIT_REPOSITORY https://github.com/google/googletest.git
-      GIT_TAG        v1.14.0
+  include(CTest)
+  enable_testing()
+
+  FetchContent_Declare(googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG v1.14.0
+  )
+  FetchContent_MakeAvailable(googletest)
+
+  file(GLOB TEST_SOURCES CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/*.cpp)
+  foreach(test_src ${TEST_SOURCES})
+    get_filename_component(test_name ${test_src} NAME_WE)
+    add_executable(${test_name}
+      ${SRC_CPP}
+      ${SRC_CU}
+      ${test_src}
     )
-    FetchContent_MakeAvailable(googletest)
-
-    file(GLOB TEST_SOURCES CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/*.cpp)
-
-    foreach(test_src ${TEST_SOURCES})
-      get_filename_component(test_name ${test_src} NAME_WE)
-      # Build each test with the same src set (direct linkage)
-      add_executable(${test_name} ${SRC_CPP} ${SRC_CU} ${test_src})
-      target_include_directories(${test_name} PRIVATE ${CMAKE_SOURCE_DIR}/include)
-      target_link_libraries(${test_name} PRIVATE
-        gtest_main
-        $<$<TARGET_EXISTS:OpenEXR::OpenEXR>:OpenEXR::OpenEXR>
-        $<$<TARGET_EXISTS:Imath::Imath>:Imath::Imath>
-        $<$<TARGET_EXISTS:Imath::Half>:Imath::Half>
-        $<$<TARGET_EXISTS:OpenEXR::IlmImf>:OpenEXR::IlmImf>
-        $<$<TARGET_EXISTS:IlmBase::Imath>:IlmBase::Imath>
-        $<$<TARGET_EXISTS:IlmBase::Half>:IlmBase::Half>
-        $<$<TARGET_EXISTS:IlmBase::IlmThread>:IlmBase::IlmThread>
-        $<$<TARGET_EXISTS:Iex::Iex>:Iex::Iex>
+
+    target_include_directories(${test_name} PRIVATE
+      ${CMAKE_SOURCE_DIR}/include
+      ${imath_SOURCE_DIR}/src
+      ${imath_BINARY_DIR}/config
+      ${openexr_SOURCE_DIR}/src/lib
+      ${openexr_BINARY_DIR}/config
+    )
+
+    target_link_libraries(${test_name} PRIVATE
+      gtest_main
+      Imath::Imath
+      OpenEXR::OpenEXR
+    )
+
+    if(BUILD_CUDA)
+      target_link_libraries(${test_name} PRIVATE CUDA::cudart CUDA::cuda_driver)
+      set_target_properties(${test_name} PROPERTIES
+        CUDA_SEPARABLE_COMPILATION ON
+        CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}"
       )
-      if(BUILD_CUDA)
-        target_link_libraries(${test_name} PRIVATE CUDA::cudart CUDA::cuda_driver)
-        set_target_properties(${test_name} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
-      endif()
-      add_test(NAME ${test_name} COMMAND ${test_name})
-    endforeach()
-endif()
+    endif()
 
+    if(MSVC)
+      target_compile_definitions(${test_name}
+        PUBLIC _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING)
+    endif()
 
+    add_test(NAME ${test_name} COMMAND ${test_name})
+  endforeach()
+endif()