warp-lang 1.2.2__py3-none-macosx_10_13_universal2.whl → 1.3.1__py3-none-macosx_10_13_universal2.whl

warp/tape.py

@@ -165,7 +165,7 @@ class Tape:
 
         Args:
             backward (Callable): A callable Python object (can be any function) that will be executed in the backward pass.
-            arrays (list): A list of arrays that are used by the function for gradient tracking.
+            arrays (list): A list of arrays that are used by the backward function. The tape keeps track of these to be able to zero their gradients in Tape.zero()
         """
         self.launches.append(backward)
 
@@ -197,6 +197,24 @@ class Tape:
         else:
             self.scopes.append((len(self.launches), None, None))
 
+    def _check_kernel_array_access(self, kernel, args):
+        """Detect illegal inter-kernel write after read access patterns during launch capture"""
+        adj = kernel.adj
+        kernel_name = adj.fun_name
+        filename = adj.filename
+        lineno = adj.fun_lineno
+
+        for i, arg in enumerate(args):
+            if isinstance(arg, wp.array):
+                arg_name = adj.args[i].label
+
+                # we check write condition first because we allow (write --> read) within the same kernel
+                if adj.args[i].is_write:
+                    arg.mark_write(arg_name=arg_name, kernel_name=kernel_name, filename=filename, lineno=lineno)
+
+                if adj.args[i].is_read:
+                    arg.mark_read()
+
     # returns the adjoint of a kernel parameter
     def get_adjoint(self, a):
         if not wp.types.is_array(a) and not isinstance(a, wp.codegen.StructInstance):
@@ -237,6 +255,8 @@ class Tape:
         self.launches = []
         self.scopes = []
         self.zero()
+        if wp.config.verify_autograd_array_access:
+            self._reset_array_read_flags()
 
     def zero(self):
         """
@@ -251,6 +271,14 @@ class Tape:
                 else:
                     g.zero_()
 
+    def _reset_array_read_flags(self):
+        """
+        Reset all recorded array read flags to False
+        """
+        for a in self.gradients:
+            if isinstance(a, wp.array):
+                a.mark_init()
+
     def visualize(
         self,
         filename: str = None,

warp/tests/disabled_kinematics.py

@@ -233,5 +233,5 @@ add_function_test(
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_adam.py

@@ -151,5 +151,5 @@ add_function_test(TestAdam, "test_adam_solve_two_inputs", test_adam_solve_two_in
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_arithmetic.py

@@ -1084,5 +1084,5 @@ for dtype in np_scalar_types:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_array.py

@@ -2328,6 +2328,60 @@ def test_array_from_cai(test, device):
     assert_np_equal(arr_warp.numpy(), np.array([[2, 1, 1], [1, 0, 0], [1, 0, 0]]))
 
 
+@wp.kernel
+def inc_scalar(a: wp.array(dtype=float)):
+    tid = wp.tid()
+    a[tid] = a[tid] + 1.0
+
+
+@wp.kernel
+def inc_vector(a: wp.array(dtype=wp.vec3f)):
+    tid = wp.tid()
+    a[tid] = a[tid] + wp.vec3f(1.0)
+
+
+@wp.kernel
+def inc_matrix(a: wp.array(dtype=wp.mat22f)):
+    tid = wp.tid()
+    a[tid] = a[tid] + wp.mat22f(1.0)
+
+
+def test_direct_from_numpy(test, device):
+    """Pass NumPy arrays to Warp kernels directly"""
+
+    n = 12
+
+    s = np.arange(n, dtype=np.float32)
+    v = np.arange(n, dtype=np.float32).reshape((n // 3, 3))
+    m = np.arange(n, dtype=np.float32).reshape((n // 4, 2, 2))
+
+    wp.launch(inc_scalar, dim=n, inputs=[s], device=device)
+    wp.launch(inc_vector, dim=n // 3, inputs=[v], device=device)
+    wp.launch(inc_matrix, dim=n // 4, inputs=[m], device=device)
+
+    expected = np.arange(1, n + 1, dtype=np.float32)
+
+    assert_np_equal(s, expected)
+    assert_np_equal(v.reshape(n), expected)
+    assert_np_equal(m.reshape(n), expected)
+
+
+@wp.kernel
+def kernel_array_from_ptr(
+    ptr: wp.uint64,
+):
+    arr = wp.array(ptr=ptr, shape=(2, 3), dtype=wp.float32)
+    arr[0, 0] = 1.0
+    arr[0, 1] = 2.0
+    arr[0, 2] = 3.0
+
+
+def test_kernel_array_from_ptr(test, device):
+    arr = wp.zeros(shape=(2, 3), dtype=wp.float32, device=device)
+    wp.launch(kernel_array_from_ptr, dim=(1,), inputs=(arr.ptr,), device=device)
+    assert_np_equal(arr.numpy(), np.array(((1.0, 2.0, 3.0), (0.0, 0.0, 0.0))))
+
+
 devices = get_test_devices()
 
 
@@ -2386,6 +2440,9 @@ add_function_test(TestArray, "test_array_of_structs_from_numpy", test_array_of_s
 add_function_test(TestArray, "test_array_of_structs_roundtrip", test_array_of_structs_roundtrip, devices=devices)
 add_function_test(TestArray, "test_array_from_numpy", test_array_from_numpy, devices=devices)
 
+add_function_test(TestArray, "test_direct_from_numpy", test_direct_from_numpy, devices=["cpu"])
+add_function_test(TestArray, "test_kernel_array_from_ptr", test_kernel_array_from_ptr, devices=devices)
+
 try:
     import torch
 
@@ -2411,5 +2468,5 @@ except Exception as e:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_array_reduce.py

@@ -144,5 +144,5 @@ add_function_test(TestArrayReduce, "test_array_inner_empty", test_array_inner_em
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_async.py

@@ -662,5 +662,5 @@ for src_type, src_ctor in array_constructors.items():
 #                     value_offset=0))
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_atomic.py

@@ -135,5 +135,5 @@ add_function_test(TestAtomic, "test_atomic_mat44", test_atomic_mat44, devices=de
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_bool.py

@@ -208,5 +208,5 @@ add_function_test(TestBool, "test_bool_mat_typing", test_bool_mat_typing, device
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_builtins_resolution.py

@@ -1286,5 +1286,5 @@ for dtype in wp.types.float_types:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_bvh.py

@@ -153,10 +153,15 @@ class TestBvh(unittest.TestCase):
 
         wp.Kernel(func=kernel_fn)
 
+    def test_bvh_new_del(self):
+        # test the scenario in which a bvh is created but not initialized before gc
+        instance = wp.Bvh.__new__(wp.Bvh)
+        instance.__del__()
+
 
 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)
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_closest_point_edge_edge.py

@@ -223,5 +223,5 @@ add_function_test(
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_codegen.py

@@ -425,6 +425,88 @@ def test_error_global_var(test, device):
         wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
 
 
+def test_error_collection_construct(test, device):
+    def kernel_1_fn():
+        x = [1.0, 2.0, 3.0]
+
+    def kernel_2_fn():
+        x = (1.0, 2.0, 3.0)
+
+    def kernel_3_fn():
+        x = {"a": 1.0, "b": 2.0, "c": 3.0}
+
+    def kernel_4_fn():
+        wp.length((1.0, 2.0, 3.0))
+
+    kernel = wp.Kernel(func=kernel_1_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"List constructs are not supported in kernels. Use vectors like `wp.vec3\(\)` for small collections instead.",
+    ):
+        wp.launch(kernel, dim=1)
+
+    kernel = wp.Kernel(func=kernel_2_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Tuple constructs are not supported in kernels. Use vectors like `wp.vec3\(\)` for small collections instead.",
+    ):
+        wp.launch(kernel, dim=1)
+
+    kernel = wp.Kernel(func=kernel_3_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Construct `ast.Dict` not supported in kernels.",
+    ):
+        wp.launch(kernel, dim=1)
+
+    kernel = wp.Kernel(func=kernel_4_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Tuple constructs are not supported in kernels. Use vectors like `wp.vec3\(\)` instead.",
+    ):
+        wp.launch(kernel, dim=1)
+
+
+def test_error_unmatched_arguments(test, device):
+    def kernel_1_fn():
+        a = 1 * 1.0
+
+    def kernel_2_fn():
+        x = wp.dot(wp.vec2(1.0, 2.0), wp.vec2h(wp.float16(1.0), wp.float16(2.0)))
+
+    kernel = wp.Kernel(func=kernel_1_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Input types must be the same, got \['int32', 'float32'\]",
+    ):
+        wp.launch(kernel, dim=1)
+
+    kernel = wp.Kernel(func=kernel_2_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Input types must be exactly the same, got \[\"vector\(length=2, dtype=<class 'warp.types.float32'>\)\", \"vector\(length=2, dtype=<class 'warp.types.float16'>\)\"\]",
+    ):
+        wp.launch(kernel, dim=1)
+
+
+@wp.kernel
+def test_call_syntax():
+    expected_pow = 16.0
+    wp.expect_eq(wp.pow(2.0, 4.0), expected_pow)
+    wp.expect_eq(wp.pow(x=2.0, y=4.0), expected_pow)
+    wp.expect_eq(wp.pow(2.0, y=4.0), expected_pow)
+    wp.expect_eq(wp.pow(y=4.0, x=2.0), expected_pow)
+
+    expected_matrix = wp.mat44(2.0, 0.0, 0.0, 1.0, 0.0, 3.0, 0.0, 2.0, 0.0, 0.0, 4.0, 3.0, 0.0, 0.0, 0.0, 1.0)
+    pos = wp.vec3(1.0, 2.0, 3.0)
+    rot = wp.quat(0.0, 0.0, 0.0, 1.0)
+    scale = wp.vec3(2.0, 3.0, 4.0)
+    wp.expect_eq(wp.matrix(pos, rot, scale, wp.float32), expected_matrix)
+    wp.expect_eq(wp.matrix(pos=pos, rot=rot, scale=scale, dtype=wp.float32), expected_matrix)
+    wp.expect_eq(wp.matrix(pos, rot, scale, dtype=wp.float32), expected_matrix)
+    wp.expect_eq(wp.matrix(rot=rot, pos=pos, dtype=wp.float32, scale=scale), expected_matrix)
+
+
 class TestCodeGen(unittest.TestCase):
     pass
 
@@ -555,8 +637,16 @@ add_kernel_test(TestCodeGen, name="test_continue_unroll", kernel=test_continue_u
 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)
+add_function_test(
+    TestCodeGen, func=test_error_collection_construct, name="test_error_collection_construct", devices=devices
+)
+add_function_test(
+    TestCodeGen, func=test_error_unmatched_arguments, name="test_error_unmatched_arguments", devices=devices
+)
+
+add_kernel_test(TestCodeGen, name="test_call_syntax", kernel=test_call_syntax, dim=1, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_compile_consts.py

@@ -213,5 +213,5 @@ add_function_test(TestConstants, "test_hash_shadowed_var", test_hash_shadowed_va
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_conditional.py

@@ -240,5 +240,5 @@ add_function_test(TestConditional, "test_conditional_unequal_types", test_condit
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_copy.py

@@ -226,5 +226,5 @@ add_function_test(TestCopy, "test_copy_adjoint", test_copy_adjoint, devices=devi
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_ctypes.py

@@ -626,5 +626,5 @@ add_function_test(TestCTypes, "test_vector_array", test_vector_array, devices=de
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_dense.py

@@ -61,5 +61,5 @@ add_function_test(TestDense, "test_dense_compilation", test_dense_compilation, d
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_devices.py

@@ -85,5 +85,5 @@ add_function_test(TestDevices, "test_devices_can_access_self", test_devices_can_
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_dlpack.py

@@ -524,5 +524,5 @@ except Exception as e:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -148,9 +148,12 @@ def add_example_test(
 
         command.extend(_build_command_line_options(options))
 
+        # Set the test timeout in seconds
+        test_timeout = options.pop("test_timeout", 300)
+
         # with wp.ScopedTimer(f"{name}_{sanitize_identifier(device)}"):
         # Run the script as a subprocess
-        result = subprocess.run(command, capture_output=True, text=True, env=env_vars)
+        result = subprocess.run(command, capture_output=True, text=True, env=env_vars, timeout=test_timeout)
 
         # Check the return code (0 is standard for success)
         test.assertEqual(
@@ -223,6 +226,7 @@ add_example_test(
     name="core.example_torch",
     devices=test_devices,
     test_options={"headless": True, "num_frames": 1000, "torch_required": True},
+    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(TestCoreExamples, name="core.example_wave", devices=test_devices)
 
@@ -232,7 +236,11 @@ class TestOptimExamples(unittest.TestCase):
 
 
 add_example_test(
-    TestOptimExamples, name="optim.example_bounce", devices=test_devices, test_options_cpu={"train_iters": 3}
+    TestOptimExamples,
+    name="optim.example_bounce",
+    devices=test_devices,
+    test_options_cpu={"train_iters": 3},
+    test_options_cuda={"test_timeout": 600},
 )
 add_example_test(
     TestOptimExamples,
@@ -283,7 +291,9 @@ class TestSimExamples(unittest.TestCase):
     pass
 
 
-add_example_test(TestSimExamples, name="sim.example_cartpole", devices=test_devices)
+add_example_test(
+    TestSimExamples, name="sim.example_cartpole", devices=test_devices, test_options_cuda={"test_timeout": 600}
+)
 add_example_test(
     TestSimExamples,
     name="sim.example_cloth",
@@ -373,6 +383,7 @@ add_example_test(
     name="fem.example_convection_diffusion_dg",
     devices=test_devices,
     test_options={"resolution": 20, "num_frames": 25, "mesh": "quad", "headless": True},
+    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
@@ -395,9 +406,27 @@ add_example_test(
     devices=test_devices,
     test_options={"num_frames": 101, "resolution": 10, "tri_mesh": True, "headless": True},
 )
+add_example_test(
+    TestFemExamples,
+    name="fem.example_streamlines",
+    devices=test_devices,
+    test_options={"headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_magnetostatics",
+    devices=test_devices,
+    test_options={"headless": True, "resolution": 16},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_nonconforming_contact",
+    devices=test_devices,
+    test_options={"headless": True, "resolution": 16, "num_steps": 2},
+)
 
 if __name__ == "__main__":
     # force rebuild of all kernels
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
 
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_fabricarray.py

@@ -931,7 +931,10 @@ devices = get_test_devices()
 
 
 class TestFabricArray(unittest.TestCase):
-    pass
+    def test_fabricarray_new_del(self):
+        # test the scenario in which a fabricarray is created but not initialized before gc
+        instance = wp.fabricarray.__new__(wp.fabricarray)
+        instance.__del__()
 
 
 # fabric arrays
@@ -948,5 +951,5 @@ add_function_test(TestFabricArray, "test_fabricarrayarray", test_fabricarrayarra
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_fast_math.py

@@ -56,5 +56,5 @@ add_function_test(TestFastMath, "test_fast_math_disabled", test_fast_math_disabl
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)