warp-lang 0.10.1__py3-none-win_amd64.whl → 0.11.0__py3-none-win_amd64.whl

warp/tests/test_bvh.py

@@ -5,13 +5,12 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
+import unittest
+
 import numpy as np
 
 import warp as wp
-from warp.tests.test_base import *
-
-np.random.seed(42)
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -71,9 +70,11 @@ def intersect_ray_aabb(start, dir, lower, upper):
 
 
 def test_bvh(test, type, device):
+    rng = np.random.default_rng(123)
+
     num_bounds = 100
-    lowers = np.random.rand(num_bounds, 3) * 5.0
-    uppers = lowers + np.random.rand(num_bounds, 3) * 5.0
+    lowers = rng.random(size=(num_bounds, 3)) * 5.0
+    uppers = lowers + rng.random(size=(num_bounds, 3)) * 5.0
 
     device_lowers = wp.array(lowers, dtype=wp.vec3, device=device)
     device_uppers = wp.array(uppers, dtype=wp.vec3, device=device)
@@ -114,10 +115,10 @@ def test_bvh(test, type, device):
             test.assertEqual(host_intersected, device_intersected[i])
 
         if test_case == 0:
-            lowers = np.random.rand(num_bounds, 3) * 5.0
-            uppers = lowers + np.random.rand(num_bounds, 3) * 5.0
-            wp.copy(device_lowers, wp.array(lowers, dtype=wp.vec3))
-            wp.copy(device_uppers, wp.array(uppers, dtype=wp.vec3))
+            lowers = rng.random(size=(num_bounds, 3)) * 5.0
+            uppers = lowers + rng.random(size=(num_bounds, 3)) * 5.0
+            wp.copy(device_lowers, wp.array(lowers, dtype=wp.vec3, device=device))
+            wp.copy(device_uppers, wp.array(uppers, dtype=wp.vec3, device=device))
             bvh.refit()
             bounds_intersected.zero_()
 
@@ -130,18 +131,41 @@ def test_bvh_query_ray(test, device):
     test_bvh(test, "ray", device)
 
 
-def register(parent):
-    devices = get_test_devices()
+def test_bvh_codegen_adjoints_with_select(test, device):
+    def kernel_fn(
+        bvh: wp.uint64,
+    ):
+        v = wp.vec3(0.0, 0.0, 0.0)
+        bounds_nr = int(0)
+
+        if True:
+            query_1 = wp.bvh_query_aabb(bvh, v, v)
+            query_2 = wp.bvh_query_ray(bvh, v, v)
+
+            wp.bvh_query_next(query_1, bounds_nr)
+            wp.bvh_query_next(query_2, bounds_nr)
+        else:
+            query_1 = wp.bvh_query_aabb(bvh, v, v)
+            query_2 = wp.bvh_query_ray(bvh, v, v)
+
+            wp.bvh_query_next(query_1, bounds_nr)
+            wp.bvh_query_next(query_2, bounds_nr)
+
+    wp.Kernel(func=kernel_fn)
+
+
+devices = get_test_devices()
+
 
-    class TestBvh(parent):
-        pass
+class TestBvh(unittest.TestCase):
+    pass
 
-    add_function_test(TestBvh, "test_bvh_aabb", test_bvh_query_aabb, devices=devices)
-    add_function_test(TestBvh, "test_bvh_ray", test_bvh_query_ray, devices=devices)
 
-    return TestBvh
+add_function_test(TestBvh, "test_bvh_aabb", test_bvh_query_aabb, devices=devices)
+add_function_test(TestBvh, "test_bvh_ray", test_bvh_query_ray, devices=devices)
+add_function_test(TestBvh, "test_bvh_codegen_adjoints_with_select", test_bvh_codegen_adjoints_with_select, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_closest_point_edge_edge.py

@@ -5,12 +5,12 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-import numpy as np
-
 import unittest
 
+import numpy as np
+
 import warp as wp
-from warp.tests.test_base import *
+from warp.tests.unittest_utils import *
 
 wp.init()
 epsilon = 0.00001
@@ -171,61 +171,58 @@ def test_edge_edge_perpendicular_s0_t1(test, device):
     test.assertAlmostEqual(st0[1], 1.0)  # t value
 
 
-def register(parent):
-    devices = get_test_devices()
-
-    class TestClosestPointEdgeEdgeMethods(parent):
-        pass
-
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_middle_crossing",
-        test_edge_edge_middle_crossing,
-        devices=devices,
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel_s1_t0", test_edge_edge_parallel_s1_t0, devices=devices
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel_s0_t1", test_edge_edge_parallel_s0_t1, devices=devices
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_both_degenerate_case",
-        test_edge_edge_both_degenerate_case,
-        devices=devices,
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_degenerate_first_edge",
-        test_edge_edge_degenerate_first_edge,
-        devices=devices,
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_degenerate_second_edge",
-        test_edge_edge_degenerate_second_edge,
-        devices=devices,
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel", test_edge_edge_parallel, devices=devices
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_perpendicular_s1_t0",
-        test_edge_edge_perpendicular_s1_t0,
-        devices=devices,
-    )
-    add_function_test(
-        TestClosestPointEdgeEdgeMethods,
-        "test_edge_edge_perpendicular_s0_t1",
-        test_edge_edge_perpendicular_s0_t1,
-        devices=devices,
-    )
-
-    return TestClosestPointEdgeEdgeMethods
+devices = get_test_devices()
+
+
+class TestClosestPointEdgeEdgeMethods(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_middle_crossing",
+    test_edge_edge_middle_crossing,
+    devices=devices,
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel_s1_t0", test_edge_edge_parallel_s1_t0, devices=devices
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel_s0_t1", test_edge_edge_parallel_s0_t1, devices=devices
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_both_degenerate_case",
+    test_edge_edge_both_degenerate_case,
+    devices=devices,
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_degenerate_first_edge",
+    test_edge_edge_degenerate_first_edge,
+    devices=devices,
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_degenerate_second_edge",
+    test_edge_edge_degenerate_second_edge,
+    devices=devices,
+)
+add_function_test(TestClosestPointEdgeEdgeMethods, "test_edge_edge_parallel", test_edge_edge_parallel, devices=devices)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_perpendicular_s1_t0",
+    test_edge_edge_perpendicular_s1_t0,
+    devices=devices,
+)
+add_function_test(
+    TestClosestPointEdgeEdgeMethods,
+    "test_edge_edge_perpendicular_s0_t1",
+    test_edge_edge_perpendicular_s0_t1,
+    devices=devices,
+)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_codegen.py

@@ -5,12 +5,11 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
 import sys
 import unittest
 
 import warp as wp
-from warp.tests.test_base import *
+from warp.tests.unittest_utils import *
 
 # wp.config.mode = "debug"
 
@@ -317,9 +316,36 @@ def test_range_constant_dynamic_nested(m: int):
     wp.expect_eq(s, N * m * N)
 
 
+@wp.kernel
+def test_range_expression():
+    idx = 1
+    batch_size = 100
+
+    a = wp.float(0.0)
+    c = wp.float(1.0)
+
+    # constant expression with a function
+    for i in range(4 * idx, wp.min(4 * idx + 4, batch_size)):
+        a += c
+
+    for i in range(4 * idx, min(4 * idx + 4, batch_size)):
+        a += c
+
+    tid = wp.tid()
+
+    # dynamic expression with a function
+    for i in range(4 * idx, wp.min(4 * idx, tid + 1000)):
+        a += c
+
+    for i in range(4 * idx, min(4 * idx, tid + 1000)):
+        a += c
+
+    wp.expect_eq(a, 8.0)
+
+
 def test_unresolved_func(test, device):
     # kernel with unresolved function must be in a separate module, otherwise the current module would fail to load
-    from warp.tests.test_unresolved_func import unresolved_func_kernel
+    from warp.tests.aux_test_unresolved_func import unresolved_func_kernel
 
     # ensure that an appropriate exception is raised when the bad module gets loaded
     with test.assertRaisesRegex(RuntimeError, "Could not find function wp.missing_func"):
@@ -327,13 +353,13 @@ def test_unresolved_func(test, device):
 
     # remove all references to the bad module so that subsequent calls to wp.force_load()
     # won't try to load it unless we explicitly re-import it again
-    del wp.context.user_modules["warp.tests.test_unresolved_func"]
-    del sys.modules["warp.tests.test_unresolved_func"]
+    del wp.context.user_modules["warp.tests.aux_test_unresolved_func"]
+    del sys.modules["warp.tests.aux_test_unresolved_func"]
 
 
 def test_unresolved_symbol(test, device):
     # kernel with unresolved symbol must be in a separate module, otherwise the current module would fail to load
-    from warp.tests.test_unresolved_symbol import unresolved_symbol_kernel
+    from warp.tests.aux_test_unresolved_symbol import unresolved_symbol_kernel
 
     # ensure that an appropriate exception is raised when the bad module gets loaded
     with test.assertRaisesRegex(KeyError, "Referencing undefined symbol: missing_symbol"):
@@ -341,135 +367,187 @@ def test_unresolved_symbol(test, device):
 
     # remove all references to the bad module so that subsequent calls to wp.force_load()
     # won't try to load it unless we explicitly re-import it again
-    del wp.context.user_modules["warp.tests.test_unresolved_symbol"]
-    del sys.modules["warp.tests.test_unresolved_symbol"]
-
-
-def register(parent):
-    class TestCodeGen(parent):
-        pass
+    del wp.context.user_modules["warp.tests.aux_test_unresolved_symbol"]
+    del sys.modules["warp.tests.aux_test_unresolved_symbol"]
 
-    devices = get_test_devices()
 
-    add_kernel_test(TestCodeGen, name="test_inplace", kernel=test_inplace, dim=1, devices=devices)
-    add_kernel_test(TestCodeGen, name="test_rename", kernel=test_rename, dim=1, devices=devices)
-    add_kernel_test(TestCodeGen, name="test_constant", kernel=test_constant, inputs=[1.0], dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_dynamic_for_rename", kernel=test_dynamic_for_rename, inputs=[10], dim=1, devices=devices
+def test_error_global_var(test, device):
+    arr = wp.array(
+        (1.0, 2.0, 3.0),
+        dtype=float,
+        device=device,
     )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_dynamic_for_inplace",
-        kernel=test_dynamic_for_inplace,
-        inputs=[10],
-        dim=1,
-        devices=devices,
-    )
-    add_kernel_test(TestCodeGen, name="test_reassign", kernel=test_reassign, dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_dynamic_reassign", kernel=test_dynamic_reassign, inputs=[2], dim=1, devices=devices
-    )
-
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_forward",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[0, 4, 1],
-        expect=[0, 1, 2, 3],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_reverse",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[4, 0, -1],
-        expect=[4, 3, 2, 1],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_foward_step",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[0, 8, 2],
-        expect=[0, 2, 4, 6],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_reverse_step",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[8, 0, -2],
-        expect=[8, 6, 4, 2],
-        devices=devices,
-    )
-
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_static_sum",
-        kernel=test_range_static_sum,
-        dim=1,
-        expect=[10, 10, 10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_sum",
-        kernel=test_range_dynamic_sum,
-        dim=1,
-        inputs=[0, 10, 2],
-        expect=[10, 10, 10, 10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_sum_zero",
-        kernel=test_range_dynamic_sum,
-        dim=1,
-        inputs=[0, 0, 1],
-        expect=[0, 0, 0, 0],
-        devices=devices,
-    )
-    add_kernel_test(TestCodeGen, name="test_range_constant", kernel=test_range_constant, dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_constant_dynamic_nested",
-        kernel=test_range_constant_dynamic_nested,
-        dim=1,
-        inputs=[10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_nested",
-        kernel=test_range_dynamic_nested,
-        dim=1,
-        inputs=[4],
-        devices=devices,
-    )
-
-    add_kernel_test(TestCodeGen, name="test_while_zero", kernel=test_while, dim=1, inputs=[0], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_while_positive", kernel=test_while, dim=1, inputs=[16], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_pass", kernel=test_pass, dim=1, inputs=[16], devices=devices)
-
-    add_kernel_test(TestCodeGen, name="test_break", kernel=test_break, dim=1, inputs=[10], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_break_early", kernel=test_break_early, dim=1, inputs=[10], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_break_unroll", kernel=test_break_unroll, dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_break_multiple", kernel=test_break_multiple, dim=1, inputs=[10], devices=devices
-    )
-    add_kernel_test(TestCodeGen, name="test_continue", kernel=test_continue, dim=1, inputs=[10], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_continue_unroll", kernel=test_continue_unroll, dim=1, devices=devices)
-
-    add_function_test(TestCodeGen, func=test_unresolved_func, name="test_unresolved_func", devices=devices)
-    add_function_test(TestCodeGen, func=test_unresolved_symbol, name="test_unresolved_symbol", devices=devices)
 
-    return TestCodeGen
+    def kernel_1_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = arr[0]
+
+    def kernel_2_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = arr
+
+    def kernel_3_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = wp.lower_bound(arr, 2.0)
+
+    out = wp.empty_like(arr)
+
+    kernel = wp.Kernel(func=kernel_1_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+    kernel = wp.Kernel(func=kernel_2_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+    kernel = wp.Kernel(func=kernel_3_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+
+class TestCodeGen(unittest.TestCase):
+    pass
+
+
+devices = get_test_devices()
+
+add_kernel_test(TestCodeGen, name="test_inplace", kernel=test_inplace, dim=1, devices=devices)
+add_kernel_test(TestCodeGen, name="test_rename", kernel=test_rename, dim=1, devices=devices)
+add_kernel_test(TestCodeGen, name="test_constant", kernel=test_constant, inputs=[1.0], dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_dynamic_for_rename", kernel=test_dynamic_for_rename, inputs=[10], dim=1, devices=devices
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_dynamic_for_inplace",
+    kernel=test_dynamic_for_inplace,
+    inputs=[10],
+    dim=1,
+    devices=devices,
+)
+add_kernel_test(TestCodeGen, name="test_reassign", kernel=test_reassign, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_dynamic_reassign", kernel=test_dynamic_reassign, inputs=[2], dim=1, devices=devices
+)
+
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_forward",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[0, 4, 1],
+    expect=[0, 1, 2, 3],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_reverse",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[4, 0, -1],
+    expect=[4, 3, 2, 1],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_forward_step",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[0, 8, 2],
+    expect=[0, 2, 4, 6],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_reverse_step",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[8, 0, -2],
+    expect=[8, 6, 4, 2],
+    devices=devices,
+)
+
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_static_sum",
+    kernel=test_range_static_sum,
+    dim=1,
+    expect=[10, 10, 10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_sum",
+    kernel=test_range_dynamic_sum,
+    dim=1,
+    inputs=[0, 10, 2],
+    expect=[10, 10, 10, 10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_sum_zero",
+    kernel=test_range_dynamic_sum,
+    dim=1,
+    inputs=[0, 0, 1],
+    expect=[0, 0, 0, 0],
+    devices=devices,
+)
+add_kernel_test(TestCodeGen, name="test_range_constant", kernel=test_range_constant, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_constant_dynamic_nested",
+    kernel=test_range_constant_dynamic_nested,
+    dim=1,
+    inputs=[10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_nested",
+    kernel=test_range_dynamic_nested,
+    dim=1,
+    inputs=[4],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_expression",
+    kernel=test_range_expression,
+    dim=1,
+    devices=devices,
+)
+
+add_kernel_test(TestCodeGen, name="test_while_zero", kernel=test_while, dim=1, inputs=[0], devices=devices)
+add_kernel_test(TestCodeGen, name="test_while_positive", kernel=test_while, dim=1, inputs=[16], devices=devices)
+add_kernel_test(TestCodeGen, name="test_pass", kernel=test_pass, dim=1, inputs=[16], devices=devices)
+
+add_kernel_test(TestCodeGen, name="test_break", kernel=test_break, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_break_early", kernel=test_break_early, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_break_unroll", kernel=test_break_unroll, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_break_multiple", kernel=test_break_multiple, dim=1, inputs=[10], devices=devices
+)
+add_kernel_test(TestCodeGen, name="test_continue", kernel=test_continue, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_continue_unroll", kernel=test_continue_unroll, dim=1, devices=devices)
+
+add_function_test(TestCodeGen, func=test_unresolved_func, name="test_unresolved_func", devices=devices)
+add_function_test(TestCodeGen, func=test_unresolved_symbol, name="test_unresolved_symbol", devices=devices)
+add_function_test(TestCodeGen, func=test_error_global_var, name="test_error_global_var", devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)