Compile CUDA in Continuous Integration (#125)

zfergus · web-flow · commit ba24d370eb90 · 2024-09-27T06:24:31.000-04:00
diff --git a/.github/workflows/cuda.yml b/.github/workflows/cuda.yml
@@ -0,0 +1,78 @@
+name: CUDA
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - '.github/workflows/cuda.yml'
+      - 'cmake/**'
+      - 'src/**'
+      - 'tests/**'
+      - 'python/**'
+      - 'CMakeLists.txt'
+
+env:
+  CTEST_OUTPUT_ON_FAILURE: ON
+  CTEST_PARALLEL_LEVEL: 2
+
+jobs:
+  Build:
+    name: CUDA (${{ matrix.config }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - Debug
+          - Release
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4.0.0
+        with:
+          fetch-depth: 10
+
+      - name: Dependencies
+        run: |
+          sudo apt-get install ccache
+          echo 'CACHE_PATH=~/.cache/ccache' >> "$GITHUB_ENV"
+
+      - uses: Jimver/cuda-toolkit@v0.2.17
+        id: cuda-toolkit
+        with:
+          cuda: '12.4.0'
+          sub-packages: '["nvcc"]'
+          method: 'network'
+
+      - name: Get number of CPU cores
+        uses: SimenB/github-actions-cpu-cores@v2.0.0
+        id: cpu-cores
+
+      - name: Cache Build
+        id: cache-build
+        uses: actions/cache@v4.0.2
+        with:
+          path: ${{ env.CACHE_PATH }}
+          key: ${{ runner.os }}-${{ matrix.config }}-cache
+
+      - name: Prepare ccache
+        run: |
+          ccache --max-size=1.0G
+          ccache -V && ccache --show-config
+          ccache --show-stats && ccache --zero-stats
+
+      - name: Configure
+        run: |
+          mkdir -p build
+          cd build
+          cmake .. \
+            -DIPC_TOOLKIT_WITH_CUDA=ON \
+            -DSCALABLE_CCD_CUDA_ARCHITECTURES=75 \
+            -DIPC_TOOLKIT_BUILD_TESTS=ON \
+            -DIPC_TOOLKIT_BUILD_PYTHON=ON \
+            -DCMAKE_BUILD_TYPE=${{ matrix.config }}
+
+      - name: Build
+        run: |
+          cmake --build build -j ${{ steps.cpu-cores.outputs.count }}
+          ccache --show-stats
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
         include:
           - os: ubuntu-latest
             name: Linux
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -218,6 +218,7 @@ target_compile_features(ipc_toolkit PUBLIC cxx_std_17)
 if(IPC_TOOLKIT_WITH_CUDA)
   include(CheckLanguage)
   check_language(CUDA)
+
   if(CMAKE_CUDA_COMPILER)
     enable_language(CUDA)
   else()
@@ -229,17 +230,9 @@ if(IPC_TOOLKIT_WITH_CUDA)
   # other libraries and executables.
   set_target_properties(ipc_toolkit PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
-  if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0")
-    set(CMAKE_CUDA_ARCHITECTURES "native")
-  else()
-    include(FindCUDA/select_compute_arch)
-    CUDA_DETECT_INSTALLED_GPUS(CUDA_ARCH_LIST)
-    string(STRIP "${CUDA_ARCH_LIST}" CUDA_ARCH_LIST)
-    string(REPLACE " " ";" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
-    string(REPLACE "." "" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
-    set(CMAKE_CUDA_ARCHITECTURES ${CUDA_ARCH_LIST})
-  endif()
-  set_target_properties(scalable_ccd PROPERTIES CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
+  # Use the same CUDA architectures Scalable CCD
+  get_target_property(CMAKE_CUDA_ARCHITECTURES scalable_ccd CUDA_ARCHITECTURES)
+  set_target_properties(ipc_toolkit PROPERTIES CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
 endif()
 
 ################################################################################
diff --git a/cmake/recipes/scalable_ccd.cmake b/cmake/recipes/scalable_ccd.cmake
@@ -9,4 +9,4 @@ message(STATUS "Third-party: creating target 'scalable_ccd::scalable_ccd'")
 set(SCALABLE_CCD_WITH_CUDA ${IPC_TOOLKIT_WITH_CUDA} CACHE BOOL "Enable CUDA CCD" FORCE)
 
 include(CPM)
-CPMAddPackage("gh:continuous-collision-detection/scalable-ccd#318352e6aa3c1008a67c80547c6fa21bf18fb1a5")
+CPMAddPackage("gh:continuous-collision-detection/scalable-ccd#95a078bbaf9659f2e1b4285d51475deff163bfa0")
diff --git a/src/ipc/ccd/additive_ccd.cpp b/src/ipc/ccd/additive_ccd.cpp
@@ -60,8 +60,8 @@ namespace {
     }
 } // namespace
 
-AdditiveCCD::AdditiveCCD(const double conservative_rescaling)
-    : conservative_rescaling(conservative_rescaling)
+AdditiveCCD::AdditiveCCD(const double _conservative_rescaling)
+    : conservative_rescaling(_conservative_rescaling)
 {
 }
 
diff --git a/src/ipc/ccd/tight_inclusion_ccd.cpp b/src/ipc/ccd/tight_inclusion_ccd.cpp
@@ -21,12 +21,12 @@ static constexpr double INITIAL_DISTANCE_TOLERANCE_SCALE = 0.5;
 static constexpr long TIGHT_INCLUSION_UNLIMITED_ITERATIONS = -1;
 
 TightInclusionCCD::TightInclusionCCD(
-    const double tolerance,
-    const long max_iterations,
-    const double conservative_rescaling)
-    : tolerance(tolerance)
-    , max_iterations(max_iterations)
-    , conservative_rescaling(conservative_rescaling)
+    const double _tolerance,
+    const long _max_iterations,
+    const double _conservative_rescaling)
+    : tolerance(_tolerance)
+    , max_iterations(_max_iterations)
+    , conservative_rescaling(_conservative_rescaling)
 {
 }
 
diff --git a/src/ipc/implicits/plane.cpp b/src/ipc/implicits/plane.cpp
@@ -100,7 +100,7 @@ double compute_point_plane_collision_free_stepsize(
     const double earliest_toi = tbb::parallel_reduce(
         tbb::blocked_range<size_t>(0, points_t0.rows()),
         /*inital_step_size=*/1.0,
-        [&](tbb::blocked_range<size_t> r, double earliest_toi) {
+        [&](tbb::blocked_range<size_t> r, double current_toi) {
             for (size_t vi = r.begin(); vi < r.end(); vi++) {
                 for (size_t pi = 0; pi < n_planes; pi++) {
                     if (!can_collide(vi, pi)) {
@@ -116,13 +116,13 @@ double compute_point_plane_collision_free_stepsize(
                         plane_normal, toi);
 
                     if (are_colliding) {
-                        if (toi < earliest_toi) {
-                            earliest_toi = toi;
+                        if (toi < current_toi) {
+                            current_toi = toi;
                         }
                     }
                 }
             }
-            return earliest_toi;
+            return current_toi;
         },
         [&](double a, double b) { return std::min(a, b); });
 
diff --git a/src/ipc/ipc.cpp b/src/ipc/ipc.cpp
@@ -56,8 +56,10 @@ double compute_collision_free_stepsize(
                 "Sweep and Tiniest Queue is only supported in 3D!");
         }
         // TODO: Use correct min_distance
-        const double tolerance = TightInclusionCCD::DEFAULT_TOLERANCE;
-        const long max_iterations = TightInclusionCCD::DEFAULT_MAX_ITERATIONS;
+        // TODO: Expose tolerance and max_iterations
+        constexpr double tolerance = TightInclusionCCD::DEFAULT_TOLERANCE;
+        constexpr long max_iterations =
+            TightInclusionCCD::DEFAULT_MAX_ITERATIONS;
         const double step_size = scalable_ccd::cuda::ipc_ccd_strategy(
             vertices_t0, vertices_t1, mesh.edges(), mesh.faces(),
             /*min_distance=*/0.0, max_iterations, tolerance);
diff --git a/tests/src/tests/barrier/test_barrier.cpp b/tests/src/tests/barrier/test_barrier.cpp
@@ -59,7 +59,7 @@ class NormalizedClampedLogBarrier : public ipc::Barrier {
 /// @warning This implementation will not work with dmin > 0
 class PhysicalBarrier : public ipc::NormalizedClampedLogBarrier {
 public:
-    PhysicalBarrier(const bool use_dist_sqr) : use_dist_sqr(use_dist_sqr) { }
+    PhysicalBarrier(const bool _use_dist_sqr) : use_dist_sqr(_use_dist_sqr) { }
 
     double operator()(const double d, const double dhat) const override
     {
diff --git a/tests/src/tests/ccd/test_gpu_ccd.cpp b/tests/src/tests/ccd/test_gpu_ccd.cpp
@@ -43,15 +43,15 @@ TEST_CASE("GPU CCD", "[ccd][gpu]")
     const double min_distance = 0;
 
     const double toi_cpu = compute_collision_free_stepsize(
-        mesh, V0, V1, BroadPhaseMethod::SWEEP_AND_PRUNE, min_distance,
-        tolerance, max_iterations);
+        mesh, V0, V1, min_distance, BroadPhaseMethod::SWEEP_AND_PRUNE,
+        TightInclusionCCD(tolerance, max_iterations));
 
     // Got this value from running the code
     CHECK(toi_cpu == Catch::Approx(4.76837158203125000e-06));
 
     const double toi_gpu = compute_collision_free_stepsize(
-        mesh, V0, V1, BroadPhaseMethod::SWEEP_AND_TINIEST_QUEUE, min_distance,
-        tolerance, max_iterations);
+        mesh, V0, V1, min_distance, BroadPhaseMethod::SWEEP_AND_TINIEST_QUEUE,
+        TightInclusionCCD(tolerance, max_iterations));
 
     // Got this value from running the code
     CHECK(toi_gpu == Catch::Approx(3.05175781250000017e-6));

Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,8 @@ namespace {`
`60`	`60`	`}`
`61`	`61`	`} // namespace`
`62`	`62`
`63`		`-AdditiveCCD::AdditiveCCD(const double conservative_rescaling)`
`64`		`- : conservative_rescaling(conservative_rescaling)`
	`63`	`+AdditiveCCD::AdditiveCCD(const double _conservative_rescaling)`
	`64`	`+ : conservative_rescaling(_conservative_rescaling)`
`65`	`65`	`{`
`66`	`66`	`}`
`67`	`67`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ double compute_point_plane_collision_free_stepsize(`
`100`	`100`	`const double earliest_toi = tbb::parallel_reduce(`
`101`	`101`	`tbb::blocked_range<size_t>(0, points_t0.rows()),`
`102`	`102`	`/inital_step_size=/1.0,`
`103`		`- [&](tbb::blocked_range<size_t> r, double earliest_toi) {`
	`103`	`+ [&](tbb::blocked_range<size_t> r, double current_toi) {`
`104`	`104`	`for (size_t vi = r.begin(); vi < r.end(); vi++) {`
`105`	`105`	`for (size_t pi = 0; pi < n_planes; pi++) {`
`106`	`106`	`if (!can_collide(vi, pi)) {`
`@@ -116,13 +116,13 @@ double compute_point_plane_collision_free_stepsize(`
`116`	`116`	`plane_normal, toi);`
`117`	`117`
`118`	`118`	`if (are_colliding) {`
`119`		`- if (toi < earliest_toi) {`
`120`		`- earliest_toi = toi;`
	`119`	`+ if (toi < current_toi) {`
	`120`	`+ current_toi = toi;`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`	`}`
`125`		`- return earliest_toi;`
	`125`	`+ return current_toi;`
`126`	`126`	`},`
`127`	`127`	`[&](double a, double b) { return std::min(a, b); });`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ class NormalizedClampedLogBarrier : public ipc::Barrier {`
`59`	`59`	`/// @warning This implementation will not work with dmin > 0`
`60`	`60`	`class PhysicalBarrier : public ipc::NormalizedClampedLogBarrier {`
`61`	`61`	`public:`
`62`		`- PhysicalBarrier(const bool use_dist_sqr) : use_dist_sqr(use_dist_sqr) { }`
	`62`	`+ PhysicalBarrier(const bool _use_dist_sqr) : use_dist_sqr(_use_dist_sqr) { }`
`63`	`63`
`64`	`64`	`double operator()(const double d, const double dhat) const override`
`65`	`65`	`{`