warp-lang 1.0.0b5__py3-none-manylinux2014_aarch64.whl → 1.0.0b6__py3-none-manylinux2014_aarch64.whl

warp/config.py

@@ -5,7 +5,7 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-version = "1.0.0-beta.5"
+version = "1.0.0-beta.6"
 
 cuda_path = (
     None  # path to local CUDA toolchain, if None at init time warp will attempt to find the SDK using CUDA_PATH env var

{warp_lang-1.0.0b5.dist-info → warp_lang-1.0.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: warp-lang
-Version: 1.0.0b5
+Version: 1.0.0b6
 Summary: A Python framework for high-performance simulation and graphics programming
 Author-email: NVIDIA <mmacklin@nvidia.com>
 License: NVSCL

{warp_lang-1.0.0b5.dist-info → warp_lang-1.0.0b6.dist-info}/RECORD

@@ -1,13 +1,5 @@
 docs/conf.py,sha256=FHItR6eNAj6TeuWRo--2UjFrfM_dFTZmeZkMJ12e3L8,4763
 examples/benchmark_api.py,sha256=3W6ETJyumNs3jfzWecDdCcHfiGmFatcG66-EkHwTeiI,3894
-examples/benchmark_cloth.py,sha256=fGP0VkJJU5F5nLhP8sGHyva3P5Wra_tDNmrwnCKCkQg,9223
-examples/benchmark_cloth_cupy.py,sha256=74vm-LUW-4sg8mzhAxuiHJgVwO_IxAmddo6d5YJ37m8,2574
-examples/benchmark_cloth_jax.py,sha256=v5u1Bq-GHIJBymOvw-jdNBsoJ6lTkuKuCUsGYlRfndE,2794
-examples/benchmark_cloth_numba.py,sha256=YHLgFjHXx6PRC47R2lSOmwGB090QhKbUGZLWqdP-PsA,4290
-examples/benchmark_cloth_numpy.py,sha256=zFPvrTz_5_f9Pq5-KwMYiB8_d1xK-XdbyBVCHZ13Zd0,2106
-examples/benchmark_cloth_pytorch.py,sha256=6CExU-Da0aqCFudwpwvXfelS4Kb2H1ujzFLzvDJ5up0,2803
-examples/benchmark_cloth_taichi.py,sha256=PIV3lADe6_bKE1H3WhJBeXRlpOdq-wkH_amjqGlS1Z0,3674
-examples/benchmark_cloth_warp.py,sha256=gZQVsJd0qLtqiCCPLUmW44t1YGzZMT15BhyOavQMW48,4187
 examples/benchmark_launches.py,sha256=dlsGCZDeqp9K3p5DDjLK8_d6qv54jgs1aI9_AKDTrVg,6190
 examples/example_dem.py,sha256=dTNH2sl3XBTK6BQMH9W-vvOP7_Vhv5bePqBTyjJ2coI,7941
 examples/example_diffray.py,sha256=eqWg2OPTARDIsCwfy1YlIEVTE4dklOae3o54HaavFx0,17681
@@ -72,7 +64,7 @@ warp/build.py,sha256=P5i_8fqiwd8CImhfDbDeZ3I0CnWU9gCtQXwNnloAh9U,4294
 warp/build_dll.py,sha256=ifOzGKrVYStIe8VLQLQS8tjKzTMmgy8gfm_9HFaRD0M,16844
 warp/builtins.py,sha256=Eb3qSVbAx1LwA67kM7w_gRhpCNTR3PXZRJYumDcIBz4,116613
 warp/codegen.py,sha256=5ws31bglnS-3DgjtUGyobJr2qw8_mZ8oh29rLmKJWkM,97863
-warp/config.py,sha256=Y4BB52qBoOmLkTexXw4F-sk_fWm24Y25ArM8mSsxLus,1751
+warp/config.py,sha256=IZa37rx9TLcTqRkXv3mC6T4a5iQlmKy4Ht3FkZBiJr4,1751
 warp/constants.py,sha256=7kcIJLSp1byeDxqKPHqOSLml_U6DzWe9qTLFMtIIp_E,1138
 warp/context.py,sha256=KSQC55ZWZBCc1eUGcxE7o2IxAY3Kzk-zupEP8sKuRO0,167393
 warp/dlpack.py,sha256=axWuv7Pch-LZeoDrtabhwwq0WRMjNAZZdvjxt_wkjUg,13724
@@ -410,8 +402,8 @@ warp/thirdparty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warp/thirdparty/appdirs.py,sha256=6msNAwCSJ0eRTVmRVF98Uvd3trshrw5RRsVUM_hPPLE,24852
 warp/thirdparty/dlpack.py,sha256=Upx_8E-DR7TQTHUN0bNbfrilzFubRjxWvafV10ZXvqQ,4416
 warp/thirdparty/unittest_parallel.py,sha256=9CmhJlIiDVjWv5CfXuxm0K_CwezSE_YiCRvk9Fa24J0,22676
-warp_lang-1.0.0b5.dist-info/LICENSE.md,sha256=-oj_azPLVWrkvvTDXjtMSiATqx18KpDmmwXsGmpPSEQ,4110
-warp_lang-1.0.0b5.dist-info/METADATA,sha256=GSRLOjdlR_xbhg0loubZafeU-aARVqvlg6_465ECOXY,12412
-warp_lang-1.0.0b5.dist-info/WHEEL,sha256=Vh4XtMfOVuhxoeaWoNYYOVdIKGVLrtk_M0IR9wFFsf4,111
-warp_lang-1.0.0b5.dist-info/top_level.txt,sha256=mO4N6yg9gzmMV87isVqdT7nNNojfOrWjxuH3mIa1gwc,49
-warp_lang-1.0.0b5.dist-info/RECORD,,
+warp_lang-1.0.0b6.dist-info/LICENSE.md,sha256=-oj_azPLVWrkvvTDXjtMSiATqx18KpDmmwXsGmpPSEQ,4110
+warp_lang-1.0.0b6.dist-info/METADATA,sha256=RzZ024mEMol3oZ0v0-GunXydWuTPJV5e-FUqJyiToaU,12412
+warp_lang-1.0.0b6.dist-info/WHEEL,sha256=Vh4XtMfOVuhxoeaWoNYYOVdIKGVLrtk_M0IR9wFFsf4,111
+warp_lang-1.0.0b6.dist-info/top_level.txt,sha256=pGqQ4zb6p2PGWj4LRHmD9iUQdiR7ZJCpvHTYlsIp7BI,44
+warp_lang-1.0.0b6.dist-info/RECORD,,

{warp_lang-1.0.0b5.dist-info → warp_lang-1.0.0b6.dist-info}/top_level.txt

@@ -1,4 +1,3 @@
-deps
 dist
 docs
 examples

examples/benchmark_cloth.py

@@ -1,279 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-# include parent path
-import os
-import sys, getopt
-import numpy as np
-import math
-import ctypes
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from pxr import Usd, UsdGeom, Gf, Sdf
-
-import warp as wp
-
-
-class Cloth:
-    def __init__(
-        self, lower, dx, dy, radius, stretch_stiffness, bend_stiffness, shear_stiffness, mass, fix_corners=True
-    ):
-        self.triangles = []
-
-        self.positions = []
-        self.velocities = []
-        self.inv_masses = []
-
-        self.spring_indices = []
-        self.spring_lengths = []
-        self.spring_stiffness = []
-        self.spring_damping = []
-
-        def grid(x, y, stride):
-            return y * stride + x
-
-        def create_spring(i, j, stiffness, damp=10.0):
-            length = np.linalg.norm(np.array(self.positions[i]) - np.array(self.positions[j]))
-
-            self.spring_indices.append(i)
-            self.spring_indices.append(j)
-            self.spring_lengths.append(length)
-            self.spring_stiffness.append(stiffness)
-            self.spring_damping.append(damp)
-
-        for y in range(dy):
-            for x in range(dx):
-                p = np.array(lower) + radius * np.array((float(x), float(0.0), float(y)))
-
-                self.positions.append(p)
-                self.velocities.append(np.zeros(3))
-
-                if x > 0 and y > 0:
-                    self.triangles.append(grid(x - 1, y - 1, dx))
-                    self.triangles.append(grid(x, y - 1, dx))
-                    self.triangles.append(grid(x, y, dx))
-
-                    self.triangles.append(grid(x - 1, y - 1, dx))
-                    self.triangles.append(grid(x, y, dx))
-                    self.triangles.append(grid(x - 1, y, dx))
-
-                if fix_corners and y == 0 and (x == 0 or x == dx - 1):
-                    w = 0.0
-                else:
-                    w = 1.0 / mass
-
-                self.inv_masses.append(w)
-
-        # horizontal springs
-        for y in range(dy):
-            for x in range(dx):
-                index0 = y * dx + x
-
-                if x > 0:
-                    index1 = y * dx + x - 1
-                    create_spring(index0, index1, stretch_stiffness)
-
-                if x > 1 and bend_stiffness > 0.0:
-                    index2 = y * dx + x - 2
-                    create_spring(index0, index2, bend_stiffness)
-
-                if y > 0 and x < dx - 1 and shear_stiffness > 0.0:
-                    indexDiag = (y - 1) * dx + x + 1
-                    create_spring(index0, indexDiag, shear_stiffness)
-
-                if y > 0 and x > 0 and shear_stiffness > 0.0:
-                    indexDiag = (y - 1) * dx + x - 1
-                    create_spring(index0, indexDiag, shear_stiffness)
-
-        # vertical
-        for x in range(dx):
-            for y in range(dy):
-                index0 = y * dx + x
-
-                if y > 0:
-                    index1 = (y - 1) * dx + x
-                    create_spring(index0, index1, stretch_stiffness)
-
-                if y > 1 and bend_stiffness > 0.0:
-                    index2 = (y - 2) * dx + x
-                    create_spring(index0, index2, bend_stiffness)
-
-        # harden to np arrays
-        self.positions = np.array(self.positions, dtype=np.float32)
-        self.velocities = np.array(self.velocities, dtype=np.float32)
-        self.inv_masses = np.array(self.inv_masses, dtype=np.float32)
-        self.spring_lengths = np.array(self.spring_lengths, dtype=np.float32)
-        self.spring_indices = np.array(self.spring_indices, dtype=np.int32)
-        self.spring_stiffness = np.array(self.spring_stiffness, dtype=np.float32)
-        self.spring_damping = np.array(self.spring_damping, dtype=np.float32)
-
-        self.num_particles = len(self.positions)
-        self.num_springs = len(self.spring_lengths)
-        self.num_tris = int(len(self.triangles) / 3)
-
-
-def run_benchmark(mode, dim, timers, render=False):
-    # params
-    sim_width = dim
-    sim_height = dim
-
-    sim_fps = 60.0
-    sim_substeps = 16
-    sim_duration = 1.0
-    sim_frames = int(sim_duration * sim_fps)
-    sim_dt = 1.0 / sim_fps
-    sim_time = 0.0
-
-    # wave constants
-    k_stretch = 1000.0
-    k_shear = 1000.0
-    k_bend = 1000.0
-    k_damp = 0.0
-
-    cloth = Cloth(
-        lower=(0.0, 0.0, 0.0),
-        dx=sim_width,
-        dy=sim_height,
-        radius=0.1,
-        stretch_stiffness=k_stretch,
-        bend_stiffness=k_bend,
-        shear_stiffness=k_shear,
-        mass=0.1,
-        fix_corners=True,
-    )
-
-    if render:
-        # set up grid for visualization
-        stage = Usd.Stage.CreateNew(os.path.join(os.path.dirname(__file__), "outputs/benchmark.usd"))
-        stage.SetStartTimeCode(0.0)
-        stage.SetEndTimeCode(sim_duration * sim_fps)
-        stage.SetTimeCodesPerSecond(sim_fps)
-
-        grid = UsdGeom.Mesh.Define(stage, "/root")
-        grid.GetPointsAttr().Set(cloth.positions, 0.0)
-        grid.GetFaceVertexIndicesAttr().Set(cloth.triangles, 0.0)
-        grid.GetFaceVertexCountsAttr().Set([3] * cloth.num_tris, 0.0)
-
-    with wp.ScopedTimer("Initialization", dict=timers):
-        if mode == "warp_cpu":
-            import examples.benchmark_cloth_warp
-
-            integrator = examples.benchmark_cloth_warp.WpIntegrator(cloth, "cpu")
-
-        elif mode == "warp_gpu":
-            import examples.benchmark_cloth_warp
-
-            integrator = examples.benchmark_cloth_warp.WpIntegrator(cloth, "cuda")
-
-        elif mode == "taichi_cpu":
-            import examples.benchmark_cloth_taichi
-
-            integrator = examples.benchmark_cloth_taichi.TiIntegrator(cloth, "cpu")
-
-        elif mode == "taichi_gpu":
-            import examples.benchmark_cloth_taichi
-
-            integrator = examples.benchmark_cloth_taichi.TiIntegrator(cloth, "cuda")
-
-        elif mode == "numpy":
-            import examples.benchmark_cloth_numpy
-
-            integrator = examples.benchmark_cloth_numpy.NpIntegrator(cloth)
-
-        elif mode == "cupy":
-            import examples.benchmark_cloth_cupy
-
-            integrator = examples.benchmark_cloth_cupy.CpIntegrator(cloth)
-
-        elif mode == "numba":
-            import examples.benchmark_cloth_numba
-
-            integrator = examples.benchmark_cloth_numba.NbIntegrator(cloth)
-
-        elif mode == "torch_cpu":
-            import examples.benchmark_cloth_pytorch
-
-            integrator = examples.benchmark_cloth_pytorch.TrIntegrator(cloth, "cpu")
-
-        elif mode == "torch_gpu":
-            import examples.benchmark_cloth_pytorch
-
-            integrator = examples.benchmark_cloth_pytorch.TrIntegrator(cloth, "cuda")
-
-        elif mode == "jax_cpu":
-            os.environ["JAX_PLATFORM_NAME"] = "cpu"
-
-            import examples.benchmark_cloth_jax
-
-            integrator = examples.benchmark_cloth_jax.JxIntegrator(cloth)
-
-        elif mode == "jax_gpu":
-            os.environ["JAX_PLATFORM_NAME"] = "gpu"
-
-            import examples.benchmark_cloth_jax
-
-            integrator = examples.benchmark_cloth_jax.JxIntegrator(cloth)
-
-        else:
-            raise RuntimeError("Unknown simulation backend")
-
-            # run one warm-up iteration to accurately measure initialization time (some engines do lazy init)
-            positions = integrator.simulate(sim_dt, sim_substeps)
-
-    label = "Dim ({}^2)".format(dim)
-
-    # run simulation
-    for i in range(sim_frames):
-        # simulate
-        with wp.ScopedTimer(label, dict=timers):
-            positions = integrator.simulate(sim_dt, sim_substeps)
-
-        if render:
-            grid.GetPointsAttr().Set(positions, sim_time * sim_fps)
-
-        sim_time += sim_dt
-
-    if render:
-        stage.Save()
-
-
-# record profiling information
-timers = {}
-
-if len(sys.argv) > 1:
-    mode = sys.argv[1]
-else:
-    mode = "warp_gpu"
-
-run_benchmark(mode, 32, timers, render=False)
-run_benchmark(mode, 64, timers, render=False)
-run_benchmark(mode, 128, timers, render=False)
-
-# write results
-import csv
-
-for k, v in timers.items():
-    print("{:16} min: {:8.2f} max: {:8.2f} avg: {:8.2f}".format(k, np.min(v), np.max(v), np.mean(v)))
-
-report = open(os.path.join(os.path.dirname(__file__), "outputs/benchmark.csv"), "a")
-writer = csv.writer(report, delimiter=",")
-
-if report.tell() == 0:
-    writer.writerow(["Name", "Init", "Dim (32^2)", "Dim (64^2)", "Dim (128^2)"])
-
-writer.writerow(
-    [
-        mode,
-        np.max(timers["Initialization"]),
-        np.mean(timers["Dim (32^2)"]),
-        np.mean(timers["Dim (64^2)"]),
-        np.mean(timers["Dim (128^2)"]),
-    ]
-)
-
-report.close()

examples/benchmark_cloth_cupy.py

@@ -1,88 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import cupy as cp
-import cupyx as cpx
-
-
-def eval_springs(x, v, indices, rest, ke, kd, f):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = cp.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = cp.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    cpx.scatter_add(f, i, -fs.T)
-    cpx.scatter_add(f, j, fs.T)
-
-
-def integrate_particles(x, v, f, w, dt):
-    g = cp.array((0.0, 0.0 - 9.8, 0.0))
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    # clear forces
-    f *= 0.0
-
-
-class CpIntegrator:
-    def __init__(self, cloth):
-        self.cloth = cloth
-
-        self.positions = cp.array(self.cloth.positions)
-        self.velocities = cp.array(self.cloth.velocities)
-        self.inv_mass = cp.array(self.cloth.inv_masses)
-
-        self.spring_indices = cp.array(self.cloth.spring_indices)
-        self.spring_lengths = cp.array(self.cloth.spring_lengths)
-        self.spring_stiffness = cp.array(self.cloth.spring_stiffness)
-        self.spring_damping = cp.array(self.cloth.spring_damping)
-
-        self.forces = cp.zeros((self.cloth.num_particles, 3), dtype=cp.float32)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs(
-                self.positions,
-                self.velocities,
-                self.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.spring_lengths,
-                self.spring_stiffness,
-                self.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles(self.positions, self.velocities, self.forces, self.inv_mass, sim_dt)
-
-        # return np.array(self.positions)
-        return self.positions.get()

examples/benchmark_cloth_jax.py

@@ -1,100 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import numpy as np
-
-import jax.lax
-import jax.numpy as jnp
-
-import os
-
-
-@jax.jit
-def eval_springs(x, v, indices, rest, ke, kd):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = jnp.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = jnp.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    f = jnp.zeros_like(v)
-
-    # f = jax.ops.index_add(f, i, -fs.T, indices_are_sorted=False, unique_indices=False)
-    # f = jax.ops.index_add(f, j, fs.T, indices_are_sorted=False, unique_indices=False)
-
-    f.at[i].add(-fs.T)
-    f.at[j].add(fs.T)
-
-    return f
-
-
-@jax.jit
-def integrate_particles(x, v, f, w, dt):
-    g = jnp.array((0.0, 0.0 - 9.8, 0.0))
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    return (x, v)
-
-
-class JxIntegrator:
-    def __init__(self, cloth):
-        self.cloth = cloth
-
-        self.positions = jnp.array(self.cloth.positions)
-        self.velocities = jnp.array(self.cloth.velocities)
-        self.inv_mass = jnp.array(self.cloth.inv_masses)
-
-        print(self.positions.device_buffer.device())
-
-        self.spring_indices = jnp.array(self.cloth.spring_indices)
-        self.spring_lengths = jnp.array(self.cloth.spring_lengths)
-        self.spring_stiffness = jnp.array(self.cloth.spring_stiffness)
-        self.spring_damping = jnp.array(self.cloth.spring_damping)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            f = eval_springs(
-                self.positions,
-                self.velocities,
-                self.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.spring_lengths,
-                self.spring_stiffness,
-                self.spring_damping,
-            )
-
-            # integrate
-            (self.positions, self.velocities) = integrate_particles(
-                self.positions, self.velocities, f, self.inv_mass, sim_dt
-            )
-
-        return np.array(self.positions)

examples/benchmark_cloth_numba.py

@@ -1,142 +0,0 @@
-from numba import cuda, float32
-import numpy as np
-import cupy as cp
-
-import math
-
-# Notes:
-#
-# Current implementation requires some familarity of writing custom cuda kernels
-# May be improved with cuda ufuncs and/or writing custom numba type extensions.
-
-
-@cuda.jit(device=True)
-def norm(x):
-    s = float32(0.0)
-    for i in range(3):
-        s += x[i] * x[i]
-    return math.sqrt(s)
-
-
-@cuda.jit(device=True)
-def dot(x, y):
-    s = float32(0.0)
-    for i in range(3):
-        s += x[i] * y[i]
-    return s
-
-
-@cuda.jit
-def eval_springs_cuda(
-    num_springs,  # (1,)
-    xs,  # position              (N, 3)
-    vs,  # velocities            (N, 3)
-    indices,  # spring indices        (S, 2)
-    rests,  # spring rest length    (S,)
-    kes,  # stiffness             (S,)
-    kds,  # damping               (S,)
-    fs,
-):  # forces                (N, 3)
-    tidx = cuda.grid(1)
-
-    if tidx < num_springs:
-        i, j = indices[tidx][0], indices[tidx][1]
-        xi, xj = xs[i], xs[j]
-        vi, vj = vs[i], vs[j]
-        rest, ke, kd = rests[tidx], kes[tidx], kds[tidx]
-
-        xij = cuda.local.array(3, dtype=cp.float32)
-        vij = cuda.local.array(3, dtype=cp.float32)
-        for k in range(3):
-            xij[k] = xi[k] - xj[k]
-        for k in range(3):
-            vij[k] = vi[k] - vj[k]
-
-        l = norm(xij)
-
-        l_inv = float32(1.0) / l
-
-        # normalized spring direction
-        xij_unit = cuda.local.array(3, dtype=cp.float32)
-        for k in range(3):
-            xij_unit[k] = xij[k] * l_inv
-        c = l - rest
-        dcdt = dot(xij_unit, vij)
-
-        # mass-spring-damper model
-        fac = ke * c + kd * dcdt
-        df = cuda.local.array(3, dtype=cp.float32)
-        for k in range(3):
-            df[k] = xij_unit[k] * fac
-
-        for k in range(3):
-            cuda.atomic.add(fs[i], k, -df[k])
-            cuda.atomic.add(fs[j], k, df[k])
-
-
-# Support const array with cp array?
-g = np.array([0.0, 0.0 - 9.8, 0.0], dtype=np.float32)
-z = np.array([0.0, 0.0, 0.0], dtype=np.float32)
-
-
-@cuda.jit
-def integrate_particles_cuda(
-    xs, vs, fs, ws, dt  # position  (N, 3)  # velocity  (N, 3)  # force     (N, 3)  # inverse of mass (N,)
-):  # dt        (1,)
-    i = cuda.grid(1)
-
-    if i < xs.shape[0]:
-        w = ws[i]
-        a = cuda.const.array_like(g) if w > 0.0 else cuda.const.array_like(z)
-
-        for j in range(3):
-            # vs[i] += ((f * w) + a) * dt (ideally)
-            vs[i][j] = vs[i][j] + ((fs[i][j] * w) + a[j]) * dt
-            xs[i][j] = xs[i][j] + vs[i][j] * dt
-
-        fs[i] = 0.0
-
-
-class NbIntegrator:
-    def __init__(self, cloth):
-        self.cloth = cloth
-
-        self.positions = cp.array(self.cloth.positions)
-        self.velocities = cp.array(self.cloth.velocities)
-        self.inv_mass = cp.array(self.cloth.inv_masses)
-
-        self.spring_indices = cp.array(self.cloth.spring_indices)
-        self.spring_lengths = cp.array(self.cloth.spring_lengths)
-        self.spring_stiffness = cp.array(self.cloth.spring_stiffness)
-        self.spring_damping = cp.array(self.cloth.spring_damping)
-
-        self.forces = cp.zeros((self.cloth.num_particles, 3), dtype=cp.float32)
-
-        self.num_particles = self.positions.shape[0]
-        self.integrate_tpb = 4
-        self.integrate_nb = self.num_particles // self.integrate_tpb + 1
-
-        self.spring_tpb = 4
-        self.spring_nb = self.cloth.num_springs // self.spring_tpb + 1
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs_cuda[self.spring_nb, self.spring_tpb](
-                self.cloth.num_springs,
-                self.positions,
-                self.velocities,
-                self.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.spring_lengths,
-                self.spring_stiffness,
-                self.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles_cuda[self.integrate_nb, self.integrate_tpb](
-                self.positions, self.velocities, self.forces, self.inv_mass, sim_dt
-            )
-
-        return self.positions.get()

examples/benchmark_cloth_numpy.py

@@ -1,77 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import numpy as np
-
-
-def eval_springs(x, v, indices, rest, ke, kd, f):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = np.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = np.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    np.add.at(f, i, -fs.T)
-    np.add.at(f, j, fs.T)
-
-
-def integrate_particles(x, v, f, w, dt):
-    g = np.array((0.0, 0.0 - 9.8, 0.0))
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    # clear forces
-    f *= 0.0
-
-
-class NpIntegrator:
-    def __init__(self, cloth):
-        self.cloth = cloth
-
-        self.forces = np.zeros((self.cloth.num_particles, 3), dtype=np.float32)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs(
-                self.cloth.positions,
-                self.cloth.velocities,
-                self.cloth.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.cloth.spring_lengths,
-                self.cloth.spring_stiffness,
-                self.cloth.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles(self.cloth.positions, self.cloth.velocities, self.forces, self.cloth.inv_masses, sim_dt)
-
-        return self.cloth.positions

examples/benchmark_cloth_pytorch.py

@@ -1,86 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import torch
-
-
-def eval_springs(x, v, indices, rest, ke, kd, f):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = torch.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = torch.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    f.index_add_(dim=0, index=i, source=-fs.T)
-    f.index_add_(dim=0, index=j, source=fs.T)
-
-
-def integrate_particles(x, v, f, g, w, dt):
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    # clear forces
-    f *= 0.0
-
-
-class TrIntegrator:
-    def __init__(self, cloth, device):
-        self.cloth = cloth
-
-        self.positions = torch.tensor(self.cloth.positions, device=device)
-        self.velocities = torch.tensor(self.cloth.velocities, device=device)
-        self.inv_mass = torch.tensor(self.cloth.inv_masses, device=device)
-
-        self.spring_indices = torch.tensor(self.cloth.spring_indices, device=device, dtype=torch.long)
-        self.spring_lengths = torch.tensor(self.cloth.spring_lengths, device=device)
-        self.spring_stiffness = torch.tensor(self.cloth.spring_stiffness, device=device)
-        self.spring_damping = torch.tensor(self.cloth.spring_damping, device=device)
-
-        self.forces = torch.zeros((self.cloth.num_particles, 3), dtype=torch.float32, device=device)
-        self.gravity = g = torch.tensor((0.0, 0.0 - 9.8, 0.0), dtype=torch.float32, device=device)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs(
-                self.positions,
-                self.velocities,
-                self.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.spring_lengths,
-                self.spring_stiffness,
-                self.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles(self.positions, self.velocities, self.forces, self.gravity, self.inv_mass, sim_dt)
-
-        return self.positions.cpu().numpy()

examples/benchmark_cloth_taichi.py

@@ -1,112 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import taichi as ti
-import numpy as np
-
-
-@ti.func
-def step(x):
-    ret = 0.0
-    if x < 0:
-        ret = 1
-    return ret
-
-
-@ti.data_oriented
-class TiIntegrator:
-    @ti.kernel
-    def eval_springs(self):
-        for tid in range(self.cloth.num_springs):
-            i = self.spring_indices[2 * tid]
-            j = self.spring_indices[2 * tid + 1]
-
-            ke = self.spring_stiffness[tid]
-            kd = self.spring_damping[tid]
-            rest = self.spring_lengths[tid]
-
-            xi = self.positions[i]
-            xj = self.positions[j]
-
-            vi = self.velocities[i]
-            vj = self.velocities[j]
-
-            xij = xi - xj
-            vij = vi - vj
-
-            l = xij.norm()
-            dir = xij.normalized()
-
-            c = l - rest
-            dcdt = dir.dot(vij)
-
-            fs = dir * (ke * c + kd * dcdt)
-
-            self.forces[i] -= fs
-            self.forces[j] += fs
-
-    @ti.kernel
-    def integrate_particles(self, dt: ti.f32):
-        for tid in range(self.cloth.num_particles):
-            x0 = self.positions[tid]
-            v0 = self.velocities[tid]
-            f0 = self.forces[tid]
-            w = self.inv_mass[tid]
-
-            g = ti.Vector([0.0, 0.0, 0.0])
-
-            if w > 0.0:
-                g = ti.Vector([0.0, -9.81, 0.0])
-
-            v1 = v0 + (f0 * w + g) * dt
-            x1 = x0 + v1 * dt
-
-            self.positions[tid] = x1
-            self.velocities[tid] = v1
-            self.forces[tid] = ti.Vector([0.0, 0.0, 0.0])
-
-    def __init__(self, cloth, device):
-        if device == "cpu":
-            ti.init(arch=ti.cpu)
-        elif device == "cuda":
-            ti.init(arch=ti.gpu)
-        else:
-            raise RuntimeError("Unsupported Taichi device")
-
-        self.cloth = cloth
-
-        self.positions = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-        self.velocities = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-        self.inv_mass = ti.field(ti.f32, shape=self.cloth.num_particles)
-
-        self.spring_indices = ti.field(ti.i32, shape=self.cloth.num_springs * 2)
-        self.spring_lengths = ti.field(ti.f32, shape=self.cloth.num_springs)
-        self.spring_stiffness = ti.field(ti.f32, shape=self.cloth.num_springs)
-        self.spring_damping = ti.field(ti.f32, shape=self.cloth.num_springs)
-
-        self.forces = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-
-        # upload data
-        self.positions.from_numpy(cloth.positions)
-        self.velocities.from_numpy(cloth.velocities)
-        self.inv_mass.from_numpy(cloth.inv_masses)
-        self.forces.from_numpy(np.zeros_like(self.cloth.velocities))
-
-        self.spring_indices.from_numpy(cloth.spring_indices)
-        self.spring_lengths.from_numpy(cloth.spring_lengths)
-        self.spring_stiffness.from_numpy(cloth.spring_stiffness)
-        self.spring_damping.from_numpy(cloth.spring_damping)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            self.eval_springs()
-
-            self.integrate_particles(sim_dt)
-
-        return self.positions.to_numpy()

examples/benchmark_cloth_warp.py

@@ -1,146 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import warp as wp
-
-wp.init()
-wp.build.clear_kernel_cache()
-
-
-@wp.kernel
-def eval_springs(
-    x: wp.array(dtype=wp.vec3),
-    v: wp.array(dtype=wp.vec3),
-    spring_indices: wp.array(dtype=int),
-    spring_rest_lengths: wp.array(dtype=float),
-    spring_stiffness: wp.array(dtype=float),
-    spring_damping: wp.array(dtype=float),
-    f: wp.array(dtype=wp.vec3),
-):
-    tid = wp.tid()
-
-    i = spring_indices[tid * 2 + 0]
-    j = spring_indices[tid * 2 + 1]
-
-    ke = spring_stiffness[tid]
-    kd = spring_damping[tid]
-    rest = spring_rest_lengths[tid]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = wp.length(xij)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = xij * l_inv
-
-    c = l - rest
-    dcdt = wp.dot(dir, vij)
-
-    # damping based on relative velocity.
-    fs = dir * (ke * c + kd * dcdt)
-
-    wp.atomic_sub(f, i, fs)
-    wp.atomic_add(f, j, fs)
-
-
-@wp.kernel
-def integrate_particles(
-    x: wp.array(dtype=wp.vec3),
-    v: wp.array(dtype=wp.vec3),
-    f: wp.array(dtype=wp.vec3),
-    w: wp.array(dtype=float),
-    dt: float,
-):
-    tid = wp.tid()
-
-    x0 = x[tid]
-    v0 = v[tid]
-    f0 = f[tid]
-    inv_mass = w[tid]
-
-    g = wp.vec3()
-
-    # treat particles with inv_mass == 0 as kinematic
-    if inv_mass > 0.0:
-        g = wp.vec3(0.0, 0.0 - 9.81, 0.0)
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v1 = v0 + (f0 * inv_mass + g) * dt
-    x1 = x0 + v1 * dt
-
-    x[tid] = x1
-    v[tid] = v1
-
-    # clear forces
-    f[tid] = wp.vec3()
-
-
-class WpIntegrator:
-    def __init__(self, cloth, device):
-        self.device = wp.get_device(device)
-
-        with wp.ScopedDevice(self.device):
-            self.positions = wp.from_numpy(cloth.positions, dtype=wp.vec3)
-            self.positions_host = wp.from_numpy(cloth.positions, dtype=wp.vec3, device="cpu")
-            self.invmass = wp.from_numpy(cloth.inv_masses, dtype=float)
-
-            self.velocities = wp.zeros(cloth.num_particles, dtype=wp.vec3)
-            self.forces = wp.zeros(cloth.num_particles, dtype=wp.vec3)
-
-            self.spring_indices = wp.from_numpy(cloth.spring_indices, dtype=int)
-            self.spring_lengths = wp.from_numpy(cloth.spring_lengths, dtype=float)
-            self.spring_stiffness = wp.from_numpy(cloth.spring_stiffness, dtype=float)
-            self.spring_damping = wp.from_numpy(cloth.spring_damping, dtype=float)
-
-        self.cloth = cloth
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            wp.launch(
-                kernel=eval_springs,
-                dim=self.cloth.num_springs,
-                inputs=[
-                    self.positions,
-                    self.velocities,
-                    self.spring_indices,
-                    self.spring_lengths,
-                    self.spring_stiffness,
-                    self.spring_damping,
-                    self.forces,
-                ],
-                outputs=[],
-                device=self.device,
-            )
-
-            # integrate
-            wp.launch(
-                kernel=integrate_particles,
-                dim=self.cloth.num_particles,
-                inputs=[self.positions, self.velocities, self.forces, self.invmass, sim_dt],
-                outputs=[],
-                device=self.device,
-            )
-
-        # copy data back to host
-        if self.device.is_cuda:
-            wp.copy(self.positions_host, self.positions)
-            wp.synchronize()
-
-            return self.positions_host.numpy()
-
-        else:
-            return self.positions.numpy()