Accelerate deformable edge collisions

asv/benchmarks/simulation/bench_cloth.py

@@ -1,8 +1,9 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 The Newton Developers
 # SPDX-License-Identifier: Apache-2.0
 
+import numpy as np
 import warp as wp
-from asv_runner.benchmarks.mark import skip_benchmark_if
+from asv_runner.benchmarks.mark import SkipNotImplemented, skip_benchmark_if
 
 wp.config.log_level = wp.LOG_WARNING
 
@@ -15,10 +16,94 @@
 from benchmark_config import pr_gate_repeat
 
 import newton.examples
+from newton._src.geometry.tri_mesh_collision import TriMeshCollisionDetector
 from newton.examples.cloth.example_cloth_franka import Example as ExampleClothManipulation
 from newton.examples.cloth.example_cloth_twist import Example as ExampleClothTwist
 from newton.viewer import ViewerNull
 
+DEFORMABLE_COLLISION_CASES = ((256, 1), (16, 1024))
+
+
+def _make_collision_grid(resolution, height):
+    x, y = np.meshgrid(np.arange(resolution) * 0.01, np.arange(resolution) * 0.01)
+    vertices = np.column_stack((x.ravel(), y.ravel(), np.full(x.size, height))).astype(np.float32)
+    triangles = []
+    for row in range(resolution - 1):
+        for column in range(resolution - 1):
+            lower = row * resolution + column
+            triangles.extend(
+                ((lower, lower + 1, lower + resolution), (lower + 1, lower + resolution + 1, lower + resolution))
+            )
+    return vertices, np.asarray(triangles, dtype=np.int32)
+
+
+def _make_collision_world(resolution):
+    vertices_a, triangles_a = _make_collision_grid(resolution, 0.0)
+    vertices_b, triangles_b = _make_collision_grid(resolution, 0.006)
+    triangles_b += len(vertices_a)
+    world = newton.ModelBuilder(gravity=wp.vec3(0.0))
+    world.add_cloth_mesh(
+        pos=wp.vec3(0.0),
+        rot=wp.quat_identity(),
+        scale=1.0,
+        vel=wp.vec3(0.0),
+        vertices=np.concatenate((vertices_a, vertices_b)),
+        indices=np.concatenate((triangles_a, triangles_b)).reshape(-1),
+        density=1.0,
+        tri_ke=1.0,
+        tri_ka=1.0,
+        tri_kd=0.0,
+        edge_ke=0.0,
+        edge_kd=0.0,
+    )
+    return world
+
+
+class DeformableSelfCollision:
+    """Benchmark dense self-collision in one large and many RL-style worlds."""
+
+    params = (DEFORMABLE_COLLISION_CASES,)
+    param_names = ["case"]
+    repeat = 3
+    number = 1
+    warmup_count = 3
+    launch_count = 10
+
+    def setup(self, case):
+        device = wp.get_device()
+        if not device.is_cuda:
+            raise SkipNotImplemented
+
+        resolution, world_count = case
+        builder = newton.ModelBuilder()
+        builder.replicate(_make_collision_world(resolution), world_count)
+        self.model = builder.finalize(device=device)
+        self.detector = TriMeshCollisionDetector(
+            self.model,
+            init_collision_info=True,
+            topological_contact_filter_threshold=0,
+            vertex_collision_buffer_pre_alloc=32,
+            edge_collision_buffer_pre_alloc=64,
+        )
+        self.radius = 0.012
+
+        for _ in range(self.warmup_count):
+            self._detect()
+        with wp.ScopedCapture(device=device) as capture:
+            self._detect()
+        self.graph = capture.graph
+
+    def _detect(self):
+        self.detector.refit(self.model.particle_q)
+        self.detector.vertex_triangle_collision_detection(self.radius)
+        self.detector.edge_edge_collision_detection(self.radius)
+
+    @skip_benchmark_if(wp.get_cuda_device_count() == 0)
+    def time_detect(self, case):
+        for _ in range(self.launch_count):
+            wp.capture_launch(self.graph)
+        wp.synchronize_device()
+
 
 class FastExampleClothManipulation:
     timeout = 300
@@ -65,6 +150,7 @@ def time_simulate(self):
     from newton.utils import run_benchmark
 
     benchmark_list = {
+        "DeformableSelfCollision": DeformableSelfCollision,
         "FastExampleClothManipulation": FastExampleClothManipulation,
         "FastExampleClothTwist": FastExampleClothTwist,
     }

asv/tests/test_benchmark_simulation.py

@@ -38,6 +38,7 @@
     from run_pr_benchmarks import build_pr_config, load_benchmark_patterns
     from simulation import (
         bench_anymal,
+        bench_cloth,
         bench_contacts,
         bench_kamino,
         bench_mujoco,
@@ -202,6 +203,20 @@ def test_nightly_collision_benchmarks_cover_distinct_pipeline_paths(self):
             self.assertIn(benchmark_name, inventory)
             self.assertFalse(any(pattern.search(benchmark_name) for pattern in patterns), benchmark_name)
 
+    def test_deformable_collision_benchmark_stays_out_of_pr_gate(self):
+        """Keep deformable collision benchmarks nightly-only."""
+        benchmark_name = "simulation.bench_cloth.DeformableSelfCollision.time_detect"
+        inventory = {entry["name"] for entry in self._discover_benchmarks(pr_gate=False)}
+        patterns = tuple(re.compile(selection) for selection in load_benchmark_patterns())
+        self.assertIn(benchmark_name, inventory)
+        self.assertFalse(
+            any(pattern.search(benchmark_name) for pattern in patterns),
+            benchmark_name,
+        )
+        self.assertEqual(bench_cloth.DeformableSelfCollision.repeat, 3)
+        self.assertEqual(bench_cloth.DeformableSelfCollision.warmup_count, 3)
+        self.assertEqual(bench_cloth.DeformableSelfCollision.launch_count, 10)
+
     def test_fast_kitchen_g1_validates_kitchen_body_count(self):
         """Validate the configured kitchen body count at runtime."""
         benchmark = bench_mujoco.FastKitchenG1()

changelog/+deformable-collision-stack-6f2a9c1d.changed.md

@@ -0,0 +1 @@
+Accelerate CUDA deformable self-collision detection in large and replicated scenes by balancing edge-pair distance evaluations across thread blocks; no migration is required.