warp-lang 0.11.0__py3-none-manylinux2014_x86_64.whl → 1.0.0__py3-none-manylinux2014_x86_64.whl

warp/examples/benchmarks/benchmark_cloth_cupy.py

@@ -0,0 +1,88 @@
+# 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()

warp/examples/benchmarks/benchmark_cloth_jax.py

@@ -0,0 +1,100 @@
+# 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)

warp/examples/benchmarks/benchmark_cloth_numba.py

@@ -0,0 +1,142 @@
+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()

warp/examples/benchmarks/benchmark_cloth_numpy.py

@@ -0,0 +1,77 @@
+# 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

warp/examples/benchmarks/benchmark_cloth_pytorch.py

@@ -0,0 +1,86 @@
+# 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()

warp/examples/benchmarks/benchmark_cloth_taichi.py

@@ -0,0 +1,112 @@
+# 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()