warp-lang 1.7.1__py3-none-manylinux_2_34_aarch64.whl → 1.7.2__py3-none-manylinux_2_34_aarch64.whl

warp/tests/test_builtins_resolution.py

@@ -84,25 +84,25 @@ def test_int_int_args_support(test, device, dtype):
     else:
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{dtype.__name__}, int'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments '{dtype.__name__}, int'$",
         ):
             wp.mul(dtype(value), value)
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments '{np_type.__name__}, int'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments '{np_type.__name__}, int'$",
         ):
             wp.mul(nps(np_type, value), value)
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {dtype.__name__}'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments 'int, {dtype.__name__}'$",
         ):
             wp.mul(value, dtype(value))
 
         with test.assertRaisesRegex(
             RuntimeError,
-            rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'int, {np_type.__name__}'$",
+            rf"Couldn't find a function 'mul' compatible with the arguments 'int, {np_type.__name__}'$",
         ):
             wp.mul(value, nps(np_type, value))
 
@@ -189,73 +189,73 @@ def test_mat_mat_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'mat_t, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'mat_t, tuple'$",
             ):
                 wp.ddot(mat_cls(*a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(wpv(dtype, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(wpm(dtype, 3, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(npv(np_type, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(npm(np_type, 3, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'ndarray, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'ndarray, tuple'$",
             ):
                 wp.ddot(np.array(npv(np_type, a_values)), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, mat_t'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, mat_t'$",
             ):
                 wp.ddot(a_values, mat_cls(*b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, wpv(dtype, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, wpm(dtype, 3, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, npv(np_type, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.ddot(a_values, npm(np_type, 3, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'ddot' compatible with " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'ddot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.ddot(a_values, np.array(npv(np_type, b_values)))
 
@@ -300,49 +300,49 @@ def test_mat_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'mat_t, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'mat_t, float'$",
             ):
                 wp.mul(mat_cls(*a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpv(dtype, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpm(dtype, 3, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npv(np_type, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npm(np_type, 3, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'ndarray, float'$",
             ):
                 wp.mul(np.array(npv(np_type, a_values)), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {dtype.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {dtype.__name__}'$",
             ):
                 wp.mul(a_values, dtype(b_value))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {np_type.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {np_type.__name__}'$",
             ):
                 wp.mul(a_values, nps(np_type, b_value))
 
@@ -401,49 +401,49 @@ def test_vec_vec_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'vec_t, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'vec_t, tuple'$",
             ):
                 wp.dot(vec_cls(*a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(wpv(dtype, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(npv(np_type, a_values), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'ndarray, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'ndarray, tuple'$",
             ):
                 wp.dot(np.array(npv(np_type, a_values)), b_values)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, vec_t'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, vec_t'$",
             ):
                 wp.dot(a_values, vec_cls(*b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(a_values, wpv(dtype, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, tuple'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, tuple'$",
             ):
                 wp.dot(a_values, npv(np_type, b_values))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'dot' compatible with " r"the arguments 'tuple, ndarray'$",
+                r"Couldn't find a function 'dot' compatible with the arguments 'tuple, ndarray'$",
             ):
                 wp.dot(a_values, np.array(npv(np_type, b_values)))
 
@@ -480,37 +480,37 @@ def test_vec_float_args_support(test, device, dtype):
         else:
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'vec_t, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'vec_t, float'$",
             ):
                 wp.mul(vec_cls(*a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(wpv(dtype, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'tuple, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'tuple, float'$",
             ):
                 wp.mul(npv(np_type, a_values), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                r"Couldn't find a function 'mul' compatible with " r"the arguments 'ndarray, float'$",
+                r"Couldn't find a function 'mul' compatible with the arguments 'ndarray, float'$",
             ):
                 wp.mul(np.array(npv(np_type, a_values)), b_value)
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {dtype.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {dtype.__name__}'$",
             ):
                 wp.mul(a_values, dtype(b_value))
 
             with test.assertRaisesRegex(
                 RuntimeError,
-                rf"Couldn't find a function 'mul' compatible with " rf"the arguments 'tuple, {np_type.__name__}'$",
+                rf"Couldn't find a function 'mul' compatible with the arguments 'tuple, {np_type.__name__}'$",
             ):
                 wp.mul(a_values, nps(np_type, b_value))
 

warp/tests/test_fem.py

@@ -818,15 +818,15 @@ def _rigid_deformation_field(s: Sample, domain: Domain, translation: wp.vec3, ro
 def test_deformed_geometry(test, device):
     N = 3
 
+    translation = [1.0, 2.0, 3.0]
+    rotation = [0.0, math.pi / 4.0, 0.0]
+    scale = 2.0
+
     with wp.ScopedDevice(device):
         positions, tet_vidx = _gen_tetmesh(N, N, N)
 
         geo = fem.Tetmesh(tet_vertex_indices=tet_vidx, positions=positions)
 
-        translation = [1.0, 2.0, 3.0]
-        rotation = [0.0, math.pi / 4.0, 0.0]
-        scale = 2.0
-
         vector_space = fem.make_polynomial_space(geo, dtype=wp.vec3, degree=2)
         pos_field = vector_space.make_field()
         fem.interpolate(
@@ -878,6 +878,15 @@ def test_deformed_geometry(test, device):
             ],
         )
 
+
+def test_deformed_geometry_codimensional(test, device):
+    N = 3
+
+    translation = [1.0, 2.0, 3.0]
+    rotation = [0.0, math.pi / 4.0, 0.0]
+    scale = 2.0
+
+    with wp.ScopedDevice(device):
         # Test with Trimesh3d (different space and cell dimensions)
         positions, tri_vidx = _gen_trimesh(N, N)
         positions = positions.numpy()
@@ -897,7 +906,9 @@ def test_deformed_geometry(test, device):
         deformed_geo = pos_field.make_deformed_geometry()
 
         @wp.kernel
-        def _test_deformed_geometry_normal(geo_arg: geo.CellArg, def_arg: deformed_geo.CellArg, rotation: wp.vec3):
+        def _test_deformed_geometry_normal_codimensional(
+            geo_arg: geo.CellArg, def_arg: deformed_geo.CellArg, rotation: wp.vec3
+        ):
             i = wp.tid()
 
             s = make_free_sample(i, Coords(0.5, 0.5, 0.0))
@@ -908,7 +919,7 @@ def test_deformed_geometry(test, device):
             wp.expect_near(wp.quat_rotate(q, geo_n), def_n, 0.001)
 
         wp.launch(
-            _test_deformed_geometry_normal,
+            _test_deformed_geometry_normal_codimensional,
             dim=geo.cell_count(),
             inputs=[
                 geo.cell_arg_value(wp.get_device()),
@@ -2035,6 +2046,9 @@ add_function_test(TestFem, "test_hex_mesh", test_hex_mesh, devices=devices)
 add_function_test(TestFem, "test_nanogrid", test_nanogrid, devices=cuda_devices)
 add_function_test(TestFem, "test_adaptive_nanogrid", test_adaptive_nanogrid, devices=cuda_devices)
 add_function_test(TestFem, "test_deformed_geometry", test_deformed_geometry, devices=devices)
+add_function_test(
+    TestFem, "test_deformed_geometry_codimensional", test_deformed_geometry_codimensional, devices=devices
+)
 add_function_test(TestFem, "test_vector_spaces", test_vector_spaces, devices=devices)
 add_function_test(TestFem, "test_dof_mapper", test_dof_mapper)
 add_function_test(TestFem, "test_point_basis", test_point_basis)

warp/tests/test_func.py

@@ -421,7 +421,7 @@ class TestFunc(unittest.TestCase):
         b = wp.mat22d(1.0, 2.0, 3.0, 4.0)
         with self.assertRaisesRegex(
             RuntimeError,
-            r"^Couldn't find a function 'mul' compatible with " r"the arguments 'mat22f, mat22d'$",
+            r"^Couldn't find a function 'mul' compatible with the arguments 'mat22f, mat22d'$",
         ):
             a * b
 

warp/tests/test_mat.py

@@ -1078,15 +1078,21 @@ def test_svd_2D(test, device, dtype, register_kernels=False):
         Vout: wp.array(dtype=mat22),
         outcomponents: wp.array(dtype=wptype),
     ):
+        tid = wp.tid()
+
         U = mat22()
         sigma = vec2()
         V = mat22()
 
-        wp.svd2(m2[0], U, sigma, V)  # Assuming there's a 2D SVD kernel
+        wp.svd2(m2[tid], U, sigma, V)  # Assuming there's a 2D SVD kernel
 
-        Uout[0] = U
-        sigmaout[0] = sigma
-        Vout[0] = V
+        Uout[tid] = U
+        sigmaout[tid] = sigma
+        Vout[tid] = V
+
+        # backprop test only for first input
+        if tid > 0:
+            return
 
         # multiply outputs by 2 so we've got something to backpropagate:
         idx = 0
@@ -1111,22 +1117,46 @@ def test_svd_2D(test, device, dtype, register_kernels=False):
     if register_kernels:
         return
 
-    m2 = wp.array(randvals(rng, [1, 2, 2], dtype) + np.eye(2), dtype=mat22, requires_grad=True, device=device)
+    mats = np.concatenate(
+        (
+            randvals(rng, [24, 2, 2], dtype) + np.eye(2),
+            # rng unlikely to hit edge cases, build them manually
+            [
+                np.zeros((2, 2)),
+                np.eye(2),
+                5.0 * np.eye(2),
+                np.array([[1.0, 0.0], [0.0, 0.0]]),
+                np.array([[0.0, 0.0], [0.0, 2.0]]),
+                np.array([[1.0, 1.0], [-1.0, -1.0]]),
+                np.array([[3.0, 0.0], [4.0, 5.0]]),
+                np.eye(2) + tol * np.array([[1.0, 1.0], [-1.0, -1.0]]),
+            ],
+        ),
+        axis=0,
+    )
+    M = len(mats)
+    m2 = wp.array(mats, dtype=mat22, requires_grad=True, device=device)
 
     outcomponents = wp.zeros(2 * 2 * 2 + 2, dtype=wptype, requires_grad=True, device=device)
-    Uout = wp.zeros(1, dtype=mat22, requires_grad=True, device=device)
-    sigmaout = wp.zeros(1, dtype=vec2, requires_grad=True, device=device)
-    Vout = wp.zeros(1, dtype=mat22, requires_grad=True, device=device)
+    Uout = wp.zeros(M, dtype=mat22, requires_grad=True, device=device)
+    sigmaout = wp.zeros(M, dtype=vec2, requires_grad=True, device=device)
+    Vout = wp.zeros(M, dtype=mat22, requires_grad=True, device=device)
 
-    wp.launch(kernel, dim=1, inputs=[m2], outputs=[Uout, sigmaout, Vout, outcomponents], device=device)
+    wp.launch(kernel, dim=M, inputs=[m2], outputs=[Uout, sigmaout, Vout, outcomponents], device=device)
 
-    Uout_np = Uout.numpy()[0].astype(np.float64)
-    sigmaout_np = np.diag(sigmaout.numpy()[0].astype(np.float64))
-    Vout_np = Vout.numpy()[0].astype(np.float64)
+    Uout_np = Uout.numpy().astype(np.float64)
+    sigmaout_np = sigmaout.numpy().astype(np.float64)
+    Vout_np = Vout.numpy().astype(np.float64)
+
+    USVt_np = Uout_np @ (sigmaout_np[..., None] * np.transpose(Vout_np, axes=(0, 2, 1)))
 
     assert_np_equal(
-        np.matmul(Uout_np, np.matmul(sigmaout_np, Vout_np.T)), m2.numpy()[0].astype(np.float64), tol=30 * tol
+        Uout_np @ np.transpose(Uout_np, axes=(0, 2, 1)), np.broadcast_to(np.eye(2), shape=(M, 2, 2)), tol=30 * tol
     )
+    assert_np_equal(
+        Vout_np @ np.transpose(Vout_np, axes=(0, 2, 1)), np.broadcast_to(np.eye(2), shape=(M, 2, 2)), tol=30 * tol
+    )
+    assert_np_equal(USVt_np, m2.numpy().astype(np.float64), tol=30 * tol)
 
     if dtype == np.float16:
         # Skip gradient check for float16 due to rounding errors
@@ -1145,7 +1175,7 @@ def test_svd_2D(test, device, dtype, register_kernels=False):
 
         tape.zero()
 
-        dx = 0.0001
+        dx = 0.001
         fdtol = 5.0e-4 if dtype == np.float64 else 2.0e-2
         for ii in range(2):
             for jj in range(2):
@@ -1180,9 +1210,9 @@ def test_qr(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
 
     tol = {
-        np.float16: 2.0e-3,
+        np.float16: 2.5e-3,
         np.float32: 1.0e-6,
-        np.float64: 1.0e-6,
+        np.float64: 1.0e-12,
     }.get(dtype, 0)
 
     wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]

warp/tests/test_struct.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import gc  # Added for garbage collection tests
 import unittest
 from typing import Any
 
@@ -221,6 +222,11 @@ def test_nested_struct(test, device):
     foo.bar.y = 1.23
     foo.x = 123
 
+    # verify that struct attributes are instances of their original class
+    assert isinstance(foo, Foo.cls)
+    assert isinstance(foo.bar, Bar.cls)
+    assert isinstance(foo.bar.baz, Baz.cls)
+
     wp.launch(kernel_nested_struct, dim=dim, inputs=[foo], device=device)
 
     assert_array_equal(
@@ -243,6 +249,18 @@ def test_struct_attribute_error(test, device):
         )
 
 
+def test_struct_inheritance_error(test, device):
+    with test.assertRaisesRegex(RuntimeError, r"Warp structs must be defined as base classes$"):
+
+        @wp.struct
+        class Parent:
+            x: int
+
+        @wp.struct
+        class Child(Parent):
+            y: int
+
+
 @wp.kernel
 def test_struct_instantiate(data: wp.array(dtype=int)):
     baz = Baz(data, wp.vec3(0.0, 0.0, 26.0))
@@ -643,6 +661,96 @@ def test_struct_array_hash(test, device):
     )
 
 
+# Tests for garbage collection behavior with arrays in structs
+@wp.struct
+class StructWithArray:
+    data: wp.array(dtype=float)
+    some_value: int
+
+
+@wp.kernel
+def access_array_kernel(s: StructWithArray, out: wp.array(dtype=float)):
+    # This kernel is used to verify data integrity by reading the first element.
+    # Assumes s.data has at least 1 element for this test.
+    out[0] = s.data[0]
+
+
+@wp.kernel
+def compute_loss_from_struct_array_kernel(s_in: StructWithArray, loss_val: wp.array(dtype=float)):
+    # Compute a simple scalar loss from the array elements for grad testing.
+    # Assumes s_in.data has at least 2 elements for this test.
+    res = 0.0
+    res += s_in.data[0] * 2.0  # Example weight
+    res += s_in.data[1] * 3.0  # Example weight
+    loss_val[0] = res
+
+
+def test_struct_array_gc_direct_assignment(test, device):
+    """
+    Tests that an array assigned to a struct (with no other direct Python
+    references) is not garbage collected prematurely.
+    """
+    wp.init()
+
+    s = StructWithArray()
+    s.some_value = 20
+
+    # Create an array, then assign it to the struct.
+    # After this assignment, 's.data' is the primary way to access it from
+    # Python's perspective, though Warp's context should also hold a reference.
+    local_array = wp.array([4.0, 5.0, 6.0], dtype=float, device=device)
+    s.data = local_array
+    del local_array  # Remove the direct Python reference
+
+    # Force garbage collection
+    gc.collect()
+
+    # Attempt to access the array in a kernel
+    out_wp = wp.zeros(1, dtype=float, device=device)
+    try:
+        wp.launch(kernel=access_array_kernel, dim=1, inputs=[s, out_wp], device=device)
+
+        # We expect to read 4.0 if the array is still valid
+        assert out_wp.numpy()[0] == 4.0, "Array data was not accessible or incorrect after GC with direct assignment."
+    except Exception as e:
+        test.fail(f"Kernel execution failed after GC with direct assignment: {e}")
+
+
+def test_struct_array_gc_requires_grad_toggle(test, device):
+    """
+    Tests that an array within a struct is not garbage collected prematurely
+    when its requires_grad flag is toggled, and that backward pass works.
+    """
+    wp.init()
+
+    s = StructWithArray()
+    s.some_value = 10
+    # Initialize array with requires_grad=True. Content: [1.0, 2.0, 3.0]
+    s.data = wp.array([1.0, 2.0, 3.0], dtype=float, device=device, requires_grad=True)
+
+    loss_wp = wp.zeros(1, dtype=float, device=device, requires_grad=True)
+
+    tape = wp.Tape()
+    with tape:
+        # Launch kernel that uses s.data to compute a loss
+        wp.launch(
+            kernel=compute_loss_from_struct_array_kernel,
+            dim=1,
+            inputs=[s, loss_wp],
+            device=device,
+        )
+
+    # Expected loss = 1.0*2.0 + 2.0*3.0 = 2.0 + 6.0 = 8.0
+
+    # After the forward pass is recorded, toggle requires_grad and run GC
+    s.data.requires_grad = False
+    gc.collect()
+
+    # will cause a memory access violation if grad array has been garbage collected
+    # or struct is not updated correctly
+    tape.backward(loss=loss_wp)
+
+
 devices = get_test_devices()
 
 
@@ -677,6 +785,8 @@ add_kernel_test(
 )
 add_kernel_test(TestStruct, kernel=test_return, name="test_return", dim=1, inputs=[], devices=devices)
 add_function_test(TestStruct, "test_nested_struct", test_nested_struct, devices=devices)
+add_function_test(TestStruct, "test_struct_attribute_error", test_struct_attribute_error, devices=devices)
+add_function_test(TestStruct, "test_struct_inheritance_error", test_struct_inheritance_error, devices=devices)
 add_function_test(TestStruct, "test_nested_array_struct", test_nested_array_struct, devices=devices)
 add_function_test(TestStruct, "test_convert_to_device", test_convert_to_device, devices=devices)
 add_function_test(TestStruct, "test_nested_empty_struct", test_nested_empty_struct, devices=devices)
@@ -727,6 +837,12 @@ add_kernel_test(
 )
 
 add_function_test(TestStruct, "test_struct_array_hash", test_struct_array_hash, devices=None)
+add_function_test(
+    TestStruct, "test_struct_array_gc_requires_grad_toggle", test_struct_array_gc_requires_grad_toggle, devices=devices
+)
+add_function_test(
+    TestStruct, "test_struct_array_gc_direct_assignment", test_struct_array_gc_direct_assignment, devices=devices
+)
 
 
 if __name__ == "__main__":

warp/tests/tile/test_tile.py

@@ -531,6 +531,32 @@ def test_tile_extract_repeated(test, device):
     assert_np_equal(a.grad.numpy(), expected_grad)
 
 
+@wp.kernel
+def test_tile_assign_kernel(x: wp.array(dtype=float), y: wp.array(dtype=float)):
+    i, j = wp.tid()
+
+    a = wp.tile_zeros(shape=(TILE_M,), dtype=float)
+
+    a[j] = x[j]
+
+    wp.tile_atomic_add(y, a, offset=(0,))
+
+
+def test_tile_assign(test, device):
+    x = wp.full(TILE_M, 2.0, dtype=float, device=device, requires_grad=True)
+    y = wp.zeros(TILE_M, dtype=float, device=device, requires_grad=True)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(test_tile_assign_kernel, dim=[1, TILE_M], inputs=[x], outputs=[y], block_dim=64, device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    assert_np_equal(y.numpy(), np.full(TILE_M, 2.0, dtype=np.float32))
+    assert_np_equal(x.grad.numpy(), np.full(TILE_M, 1.0, dtype=np.float32))
+
+
 @wp.kernel
 def test_tile_transpose_kernel(input: wp.array2d(dtype=float), output: wp.array2d(dtype=float)):
     x = wp.tile_load(input, shape=(TILE_M, TILE_N))
@@ -767,6 +793,7 @@ add_function_test(TestTile, "test_tile_sum", test_tile_sum, devices=devices, che
 add_function_test(TestTile, "test_tile_sum_launch", test_tile_sum_launch, devices=devices)
 add_function_test(TestTile, "test_tile_extract", test_tile_extract, devices=devices)
 add_function_test(TestTile, "test_tile_extract_repeated", test_tile_extract_repeated, devices=devices)
+add_function_test(TestTile, "test_tile_assign", test_tile_assign, devices=devices)
 add_function_test(TestTile, "test_tile_broadcast_add_1d", test_tile_broadcast_add_1d, devices=devices)
 add_function_test(TestTile, "test_tile_broadcast_add_2d", test_tile_broadcast_add_2d, devices=devices)
 add_function_test(TestTile, "test_tile_broadcast_add_3d", test_tile_broadcast_add_3d, devices=devices)