Accelerate deformable edge collisions

Evaluate each unordered edge pair once and use a block-shared tile
stack to redistribute distance tests from divergent BVH traversals.
Preserve directed contact rows, filtering, and world grouping.

Add dense single-world and replicated multi-world benchmarks that
saturate the GPU and cover the full deformable detection pass.

Author: nvtw

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,93 @@
 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 = pr_gate_repeat(5)
+    number = 1
+
+    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
+        self.launch_count = 20
+
+        for _ in range(5):
+            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 +149,7 @@ def time_simulate(self):
     from newton.utils import run_benchmark
 
     benchmark_list = {
+        "DeformableSelfCollision": DeformableSelfCollision,
         "FastExampleClothManipulation": FastExampleClothManipulation,
         "FastExampleClothTwist": FastExampleClothTwist,
     }

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.