warp-lang 1.7.0__py3-none-manylinux_2_34_aarch64.whl

warp/tests/test_modules_lite.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+devices = get_test_devices()
+
+
+class TestModuleLite(unittest.TestCase):
+    def test_module_lite_load(self):
+        # Load current module
+        wp.load_module()
+
+        # Load named module
+        wp.load_module(wp.config)
+
+        # Load named module (string)
+        wp.load_module(wp.config, recursive=True)
+
+    def test_module_lite_options(self):
+        wp.set_module_options({"max_unroll": 8})
+        module_options = wp.get_module_options()
+        self.assertIsInstance(module_options, dict)
+        self.assertEqual(module_options["max_unroll"], 8)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_noise.py

@@ -0,0 +1,252 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import numpy as np
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def pnoise(
+    kernel_seed: int, W: int, px: int, py: int, noise_values: wp.array(dtype=float), pixel_values: wp.array(dtype=float)
+):
+    tid = wp.tid()
+
+    state = wp.rand_init(kernel_seed)
+
+    x = (float(tid % W) + 0.5) * 0.2
+    y = (float(tid / W) + 0.5) * 0.2
+    p = wp.vec2(x, y)
+
+    n = wp.pnoise(state, p, px, py)
+    noise_values[tid] = n
+
+    g = ((n + 1.0) / 2.0) * 255.0
+    pixel_values[tid] = g
+
+
+@wp.kernel
+def curlnoise(kernel_seed: int, W: int, noise_coords: wp.array(dtype=wp.vec2), noise_vectors: wp.array(dtype=wp.vec2)):
+    tid = wp.tid()
+
+    state = wp.rand_init(kernel_seed)
+
+    x = (float(tid % W) + 0.5) * 0.2
+    y = (float(tid / W) + 0.5) * 0.2
+
+    p = wp.vec2(x, y)
+    v = wp.curlnoise(state, p)
+
+    noise_coords[tid] = p
+    noise_vectors[tid] = v
+
+
+def test_pnoise(test, device):
+    # image dim
+    W = 256
+    H = 256
+    N = W * H
+    seed = 42
+
+    # periodic perlin noise test
+    px = 16
+    py = 16
+
+    noise_values = wp.zeros(N, dtype=float, device=device)
+    pixel_values = wp.zeros(N, dtype=float, device=device)
+
+    wp.launch(kernel=pnoise, dim=N, inputs=[seed, W, px, py, noise_values, pixel_values], outputs=[], device=device)
+
+    # Perlin theoretical range is [-0.5*sqrt(n), 0.5*sqrt(n)] for n dimensions
+    n = noise_values.numpy()
+    # max = np.max(n)
+    # min = np.min(n)
+
+    img = pixel_values.numpy()
+    img = np.reshape(img, (W, H))
+
+    ### Figure viewing ###
+    # img = img.astype(np.uint8)
+    # imgplot = plt.imshow(img, 'gray')
+    # plt.savefig("pnoise_test.png")
+
+    ### Generating pnoise_test_result_true.npy ###
+    # np.save(os.path.join(os.path.dirname(__file__), "assets/pnoise_golden.npy"), img)
+
+    ### Golden image comparison ###
+    img_true = np.load(os.path.join(os.path.dirname(__file__), "assets/pnoise_golden.npy"))
+    test.assertTrue(img.shape == img_true.shape)
+    err = np.max(np.abs(img - img_true))
+    tolerance = 1.5e-3
+    test.assertTrue(err < tolerance, f"err is {err} which is >= {tolerance}")
+
+
+def test_curlnoise(test, device):
+    # image dim
+    W = 128
+    H = 128
+    N = W * H
+    seed = 42
+
+    # curl noise test
+    quiver_coords_host = wp.zeros(N, dtype=wp.vec2, device="cpu")
+    quiver_coords = wp.zeros(N, dtype=wp.vec2, device=device)
+
+    quiver_arrows_host = wp.zeros(N, dtype=wp.vec2, device="cpu")
+    quiver_arrows = wp.zeros(N, dtype=wp.vec2, device=device)
+
+    wp.launch(kernel=curlnoise, dim=N, inputs=[seed, W, quiver_coords, quiver_arrows], outputs=[], device=device)
+
+    wp.copy(quiver_coords_host, quiver_coords)
+    wp.copy(quiver_arrows_host, quiver_arrows)
+
+    wp.synchronize()
+
+    xy_coords = quiver_coords_host.numpy()
+    uv_coords = quiver_arrows_host.numpy()
+
+    # normalize
+    norms = uv_coords[:, 0] * uv_coords[:, 0] + uv_coords[:, 1] * uv_coords[:, 1]
+    uv_coords = uv_coords / np.sqrt(np.max(norms))
+
+    X = xy_coords[:, 0]
+    Y = xy_coords[:, 1]
+    U = uv_coords[:, 0]
+    V = uv_coords[:, 1]
+
+    ### Figure viewing ###
+    # fig, ax = plt.subplots(figsize=(25,25))
+    # ax.quiver(X, Y, U, V)
+    # ax.axis([0.0, 25.0, 0.0, 25.0])
+    # ax.set_aspect('equal')
+    # plt.savefig("curlnoise_test.png")
+
+    ### Generating curlnoise_test_result_true.npy ###
+    result = np.stack((xy_coords, uv_coords))
+    # np.save(os.path.join(os.path.dirname(__file__), "assets/curlnoise_golden.npy"), result)
+
+    ### Golden image comparison ###
+    result_true = np.load(os.path.join(os.path.dirname(__file__), "assets/curlnoise_golden.npy"))
+    test.assertTrue(result.shape, result_true.shape)
+    err = np.max(np.abs(result - result_true))
+    test.assertTrue(err < 1e-04)
+
+
+@wp.kernel
+def noise_loss_kernel(
+    kernel_seed: int,
+    query_positions: wp.array(dtype=wp.vec2),
+    noise_values: wp.array(dtype=float),
+    noise_loss: wp.array(dtype=float),
+):
+    tid = wp.tid()
+    state = wp.rand_init(kernel_seed)
+
+    p = query_positions[tid]
+
+    n = wp.noise(state, p)
+    noise_values[tid] = n
+
+    wp.atomic_add(noise_loss, 0, n)
+
+
+@wp.kernel
+def noise_cd(kernel_seed: int, query_positions: wp.array(dtype=wp.vec2), gradients: wp.array(dtype=wp.vec2)):
+    tid = wp.tid()
+    state = wp.rand_init(kernel_seed)
+    p = query_positions[tid]
+
+    eps = 1.0e-3
+
+    pl = wp.vec2(p[0] - eps, p[1])
+    pr = wp.vec2(p[0] + eps, p[1])
+    pd = wp.vec2(p[0], p[1] - eps)
+    pu = wp.vec2(p[0], p[1] + eps)
+
+    nl = wp.noise(state, pl)
+    nr = wp.noise(state, pr)
+    nd = wp.noise(state, pd)
+    nu = wp.noise(state, pu)
+
+    gx = (nr - nl) / (2.0 * eps)
+    gy = (nu - nd) / (2.0 * eps)
+
+    gradients[tid] = wp.vec2(gx, gy)
+
+
+def test_adj_noise(test, device):
+    # grid dim
+    N = 9
+    seed = 42
+
+    tape = wp.Tape()
+
+    positions = np.array(
+        [
+            [-0.1, -0.1],
+            [0.0, -0.1],
+            [0.1, -0.1],
+            [-0.1, 0.0],
+            [0.0, 0.0],
+            [0.1, 0.0],
+            [-0.1, 0.1],
+            [0.0, 0.1],
+            [0.1, 0.1],
+        ]
+    )
+
+    with tape:
+        query_positions = wp.array(positions, dtype=wp.vec2, device=device, requires_grad=True)
+        noise_values = wp.zeros(N, dtype=float, device=device)
+        noise_loss = wp.zeros(n=1, dtype=float, device=device, requires_grad=True)
+
+        wp.launch(
+            kernel=noise_loss_kernel, dim=N, inputs=[seed, query_positions, noise_values, noise_loss], device=device
+        )
+
+    # analytic
+    tape.backward(loss=noise_loss)
+    analytic = tape.gradients[query_positions].numpy().reshape((3, 3, 2))
+
+    # central difference
+    gradients = wp.zeros(N, dtype=wp.vec2, device=device)
+    wp.launch(kernel=noise_cd, dim=N, inputs=[seed, query_positions, gradients], device=device)
+
+    gradients_host = gradients.numpy().reshape((3, 3, 2))
+    diff = analytic - gradients_host
+    result = np.sum(diff * diff, axis=2)
+
+    err = np.where(result > 1.0e-3, result, 0).sum()
+    test.assertTrue(err < 1.0e-8)
+
+
+devices = get_test_devices()
+
+
+class TestNoise(unittest.TestCase):
+    pass
+
+
+add_function_test(TestNoise, "test_pnoise", test_pnoise, devices=devices)
+add_function_test(TestNoise, "test_curlnoise", test_curlnoise, devices=devices)
+add_function_test(TestNoise, "test_adj_noise", test_adj_noise, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_operators.py

@@ -0,0 +1,299 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def test_operators_scalar_float():
+    a = 1.0
+    b = 2.0
+
+    c = a * b
+    d = a + b
+    e = a / b
+    f = a - b
+    g = b**8.0
+    h = 10.0 // 3.0
+
+    expect_eq(c, 2.0)
+    expect_eq(d, 3.0)
+    expect_eq(e, 0.5)
+    expect_eq(f, -1.0)
+    expect_eq(g, 256.0)
+    expect_eq(h, 3.0)
+
+
+@wp.kernel
+def test_operators_scalar_int():
+    a = 1
+    b = 2
+
+    c = a * b
+    d = a + b
+    e = a / b
+    f = a - b
+    # g = b**8    # integer pow not implemented
+    h = 10 // 3
+    i = 10 % 3
+    j = 2 << 3
+    k = 16 >> 1
+
+    expect_eq(c, 2)
+    expect_eq(d, 3)
+    expect_eq(e, 0)
+    expect_eq(f, -1)
+    # expect_eq(g, 256)
+    expect_eq(h, 3)
+    expect_eq(i, 1)
+    expect_eq(j, 16)
+    expect_eq(k, 8)
+
+    f0 = wp.uint32(1 << 0)
+    f1 = wp.uint32(1 << 3)
+    expect_eq(f0 | f1, f0 + f1)
+    expect_eq(f0 & f1, wp.uint32(0))
+
+    l = wp.uint8(0)
+    for n in range(8):
+        l |= wp.uint8(1 << n)
+    expect_eq(l, ~wp.uint8(0))
+
+
+@wp.kernel
+def test_operators_vector_index():
+    v = wp.vec4(1.0, 2.0, 3.0, 4.0)
+
+    expect_eq(v[0], 1.0)
+    expect_eq(v[1], 2.0)
+    expect_eq(v[2], 3.0)
+    expect_eq(v[3], 4.0)
+
+
+@wp.kernel
+def test_operators_matrix_index():
+    m22 = wp.mat22(1.0, 2.0, 3.0, 4.0)
+
+    expect_eq(m22[0, 0], 1.0)
+    expect_eq(m22[0, 1], 2.0)
+    expect_eq(m22[1, 0], 3.0)
+    expect_eq(m22[1, 1], 4.0)
+
+
+@wp.kernel
+def test_operators_vec3():
+    v = vec3(1.0, 2.0, 3.0)
+
+    r0 = v * 3.0
+    r1 = 3.0 * v
+
+    expect_eq(r0, vec3(3.0, 6.0, 9.0))
+    expect_eq(r1, vec3(3.0, 6.0, 9.0))
+
+    col0 = vec3(1.0, 0.0, 0.0)
+    col1 = vec3(0.0, 2.0, 0.0)
+    col2 = vec3(0.0, 0.0, 3.0)
+
+    m = mat33(col0, col1, col2)
+
+    expect_eq(m * vec3(1.0, 0.0, 0.0), col0)
+    expect_eq(m * vec3(0.0, 1.0, 0.0), col1)
+    expect_eq(m * vec3(0.0, 0.0, 1.0), col2)
+
+    two = vec3(1.0) * 2.0
+    expect_eq(two, vec3(2.0, 2.0, 2.0))
+
+
+@wp.kernel
+def test_operators_vec4():
+    v = vec4(1.0, 2.0, 3.0, 4.0)
+
+    r0 = v * 3.0
+    r1 = 3.0 * v
+
+    expect_eq(r0, vec4(3.0, 6.0, 9.0, 12.0))
+    expect_eq(r1, vec4(3.0, 6.0, 9.0, 12.0))
+
+    col0 = vec4(1.0, 0.0, 0.0, 0.0)
+    col1 = vec4(0.0, 2.0, 0.0, 0.0)
+    col2 = vec4(0.0, 0.0, 3.0, 0.0)
+    col3 = vec4(0.0, 0.0, 0.0, 4.0)
+
+    m = mat44(col0, col1, col2, col3)
+
+    expect_eq(m * vec4(1.0, 0.0, 0.0, 0.0), col0)
+    expect_eq(m * vec4(0.0, 1.0, 0.0, 0.0), col1)
+    expect_eq(m * vec4(0.0, 0.0, 1.0, 0.0), col2)
+    expect_eq(m * vec4(0.0, 0.0, 0.0, 1.0), col3)
+
+    two = vec4(1.0) * 2.0
+    expect_eq(two, vec4(2.0, 2.0, 2.0, 2.0))
+
+
+@wp.kernel
+def test_operators_mat22():
+    m = mat22(1.0, 2.0, 3.0, 4.0)
+    r = mat22(3.0, 6.0, 9.0, 12.0)
+
+    r0 = m * 3.0
+    r1 = 3.0 * m
+
+    expect_eq(r0, r)
+    expect_eq(r1, r)
+
+    expect_eq(r0[0, 0], 3.0)
+    expect_eq(r0[0, 1], 6.0)
+    expect_eq(r0[1, 0], 9.0)
+    expect_eq(r0[1, 1], 12.0)
+
+    expect_eq(r0[0], wp.vec2(3.0, 6.0))
+    expect_eq(r0[1], wp.vec2(9.0, 12.0))
+
+
+@wp.kernel
+def test_operators_mat33():
+    m = mat33(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)
+
+    r = mat33(3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0)
+
+    r0 = m * 3.0
+    r1 = 3.0 * m
+
+    expect_eq(r0, r)
+    expect_eq(r1, r)
+
+    expect_eq(r0[0, 0], 3.0)
+    expect_eq(r0[0, 1], 6.0)
+    expect_eq(r0[0, 2], 9.0)
+
+    expect_eq(r0[1, 0], 12.0)
+    expect_eq(r0[1, 1], 15.0)
+    expect_eq(r0[1, 2], 18.0)
+
+    expect_eq(r0[2, 0], 21.0)
+    expect_eq(r0[2, 1], 24.0)
+    expect_eq(r0[2, 2], 27.0)
+
+    expect_eq(r0[0], wp.vec3(3.0, 6.0, 9.0))
+    expect_eq(r0[1], wp.vec3(12.0, 15.0, 18.0))
+    expect_eq(r0[2], wp.vec3(21.0, 24.0, 27.0))
+
+
+@wp.kernel
+def test_operators_mat44():
+    m = mat44(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0)
+
+    r = mat44(3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0, 30.0, 33.0, 36.0, 39.0, 42.0, 45.0, 48.0)
+
+    r0 = m * 3.0
+    r1 = 3.0 * m
+
+    expect_eq(r0, r)
+    expect_eq(r1, r)
+
+    expect_eq(r0[0, 0], 3.0)
+    expect_eq(r0[0, 1], 6.0)
+    expect_eq(r0[0, 2], 9.0)
+    expect_eq(r0[0, 3], 12.0)
+
+    expect_eq(r0[1, 0], 15.0)
+    expect_eq(r0[1, 1], 18.0)
+    expect_eq(r0[1, 2], 21.0)
+    expect_eq(r0[1, 3], 24.0)
+
+    expect_eq(r0[2, 0], 27.0)
+    expect_eq(r0[2, 1], 30.0)
+    expect_eq(r0[2, 2], 33.0)
+    expect_eq(r0[2, 3], 36.0)
+
+    expect_eq(r0[3, 0], 39.0)
+    expect_eq(r0[3, 1], 42.0)
+    expect_eq(r0[3, 2], 45.0)
+    expect_eq(r0[3, 3], 48.0)
+
+    expect_eq(r0[0], wp.vec4(3.0, 6.0, 9.0, 12.0))
+    expect_eq(r0[1], wp.vec4(15.0, 18.0, 21.0, 24.0))
+    expect_eq(r0[2], wp.vec4(27.0, 30.0, 33.0, 36.0))
+    expect_eq(r0[3], wp.vec4(39.0, 42.0, 45.0, 48.0))
+
+
+@wp.struct
+class Complex:
+    real: float
+    imag: float
+
+
+@wp.func
+def add(
+    a: Complex,
+    b: Complex,
+) -> Complex:
+    return Complex(
+        a.real + b.real,
+        a.imag + b.imag,
+    )
+
+
+@wp.func
+def mul(
+    a: Complex,
+    b: Complex,
+) -> Complex:
+    return Complex(
+        a.real * b.real - a.imag * b.imag,
+        a.real * b.imag + a.imag * b.real,
+    )
+
+
+@wp.kernel
+def test_operators_overload():
+    a = Complex(1.0, 2.0)
+    b = Complex(3.0, 4.0)
+
+    c = a + b
+    expect_eq(c.real, 4.0)
+    expect_eq(c.imag, 6.0)
+
+    d = a * b
+    expect_eq(d.real, -5.0)
+    expect_eq(d.imag, 10.0)
+
+
+devices = get_test_devices()
+
+
+class TestOperators(unittest.TestCase):
+    pass
+
+
+add_kernel_test(TestOperators, test_operators_scalar_float, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_scalar_int, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_matrix_index, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_vector_index, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_vec3, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_vec4, dim=1, devices=devices)
+
+add_kernel_test(TestOperators, test_operators_mat22, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_mat33, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_mat44, dim=1, devices=devices)
+add_kernel_test(TestOperators, test_operators_overload, dim=1, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_options.py

@@ -0,0 +1,129 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import io
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def scale(
+    x: wp.array(dtype=float),
+    y: wp.array(dtype=float),
+):
+    y[0] = x[0] ** 2.0
+
+
+@wp.kernel(enable_backward=True)
+def scale_1(
+    x: wp.array(dtype=float),
+    y: wp.array(dtype=float),
+):
+    y[0] = x[0] ** 2.0
+
+
+@wp.kernel(enable_backward=False)
+def scale_2(
+    x: wp.array(dtype=float),
+    y: wp.array(dtype=float),
+):
+    y[0] = x[0] ** 2.0
+
+
+def test_options_1(test, device):
+    x = wp.array([3.0], dtype=float, requires_grad=True, device=device)
+    y = wp.zeros_like(x)
+
+    wp.set_module_options({"enable_backward": False})
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(scale, dim=1, inputs=[x, y], device=device)
+
+    with contextlib.redirect_stdout(io.StringIO()) as f:
+        tape.backward(y)
+
+    expected = f"Warp UserWarning: Running the tape backwards may produce incorrect gradients because recorded kernel {scale.key} is defined in a module with the option 'enable_backward=False' set.\n"
+
+    assert f.getvalue() == expected
+    assert_np_equal(tape.gradients[x].numpy(), np.array(0.0))
+
+
+def test_options_2(test, device):
+    x = wp.array([3.0], dtype=float, requires_grad=True, device=device)
+    y = wp.zeros_like(x)
+
+    wp.set_module_options({"enable_backward": True})
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(scale, dim=1, inputs=[x, y], device=device)
+
+    tape.backward(y)
+    assert_np_equal(tape.gradients[x].numpy(), np.array(6.0))
+
+
+def test_options_3(test, device):
+    x = wp.array([3.0], dtype=float, requires_grad=True, device=device)
+    y = wp.zeros_like(x)
+
+    wp.set_module_options({"enable_backward": False})
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(scale_1, dim=1, inputs=[x, y], device=device)
+
+    tape.backward(y)
+    assert_np_equal(tape.gradients[x].numpy(), np.array(6.0))
+
+
+def test_options_4(test, device):
+    x = wp.array([3.0], dtype=float, requires_grad=True, device=device)
+    y = wp.zeros_like(x)
+
+    wp.set_module_options({"enable_backward": True})
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(scale_2, dim=1, inputs=[x, y], device=device)
+
+    with contextlib.redirect_stdout(io.StringIO()) as f:
+        tape.backward(y)
+
+    expected = f"Warp UserWarning: Running the tape backwards may produce incorrect gradients because recorded kernel {scale_2.key} is configured with the option 'enable_backward=False'.\n"
+
+    assert f.getvalue() == expected
+    assert_np_equal(tape.gradients[x].numpy(), np.array(0.0))
+
+
+devices = get_test_devices()
+
+
+class TestOptions(unittest.TestCase):
+    pass
+
+
+add_function_test(TestOptions, "test_options_1", test_options_1, devices=devices)
+add_function_test(TestOptions, "test_options_2", test_options_2, devices=devices)
+add_function_test(TestOptions, "test_options_3", test_options_3, devices=devices)
+add_function_test(TestOptions, "test_options_4", test_options_4, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)