warp-lang 1.7.0__py3-none-manylinux_2_34_aarch64.whl → 1.7.2rc1__py3-none-manylinux_2_34_aarch64.whl

warp/tests/test_quat.py

@@ -1903,89 +1903,6 @@ def test_quat_identity(test, device, dtype, register_kernels=False):
     assert_np_equal(output.numpy(), expected)
 
 
-############################################################
-
-
-def test_quat_assign_inplace(test, device, dtype, register_kernels=False):
-    np_type = np.dtype(dtype)
-    wp_type = wp.types.np_dtype_to_warp_type[np_type]
-
-    quat = wp.types.quaternion(dtype=wp_type)
-
-    def quattest_read_write_store(x: wp.array(dtype=wp_type), a: wp.array(dtype=quat)):
-        tid = wp.tid()
-
-        t = a[tid]
-        t[0] = x[tid]
-        a[tid] = t
-
-    def quattest_in_register(x: wp.array(dtype=wp_type), a: wp.array(dtype=quat)):
-        tid = wp.tid()
-
-        g = wp_type(0.0)
-        q = a[tid]
-        g = q[0] + wp_type(2.0) * q[1] + wp_type(3.0) * q[2] + wp_type(4.0) * q[3]
-        x[tid] = g
-
-    def quattest_component(x: wp.array(dtype=quat), y: wp.array(dtype=wp_type)):
-        i = wp.tid()
-
-        a = quat()
-        a.x = wp_type(1.0) * y[i]
-        a.y = wp_type(2.0) * y[i]
-        a.z = wp_type(3.0) * y[i]
-        a.w = wp_type(4.0) * y[i]
-        x[i] = a
-
-    kernel_read_write_store = getkernel(quattest_read_write_store, suffix=dtype.__name__)
-    kernel_in_register = getkernel(quattest_in_register, suffix=dtype.__name__)
-    kernel_component = getkernel(quattest_component, suffix=dtype.__name__)
-
-    if register_kernels:
-        return
-
-    a = wp.ones(1, dtype=quat, device=device, requires_grad=True)
-    x = wp.full(1, value=2.0, dtype=wp_type, device=device, requires_grad=True)
-
-    tape = wp.Tape()
-    with tape:
-        wp.launch(kernel_read_write_store, dim=1, inputs=[x, a], device=device)
-
-    tape.backward(grads={a: wp.ones_like(a, requires_grad=False)})
-
-    assert_np_equal(a.numpy(), np.array([[2.0, 1.0, 1.0, 1.0]], dtype=np_type))
-    assert_np_equal(x.grad.numpy(), np.array([1.0], dtype=np_type))
-
-    tape.reset()
-
-    a = wp.ones(1, dtype=quat, device=device, requires_grad=True)
-    x = wp.zeros(1, dtype=wp_type, device=device, requires_grad=True)
-
-    with tape:
-        wp.launch(kernel_in_register, dim=1, inputs=[x, a], device=device)
-
-    tape.backward(grads={x: wp.ones_like(x, requires_grad=False)})
-
-    assert_np_equal(x.numpy(), np.array([10.0], dtype=np_type))
-    assert_np_equal(a.grad.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=np_type))
-
-    tape.reset()
-
-    x = wp.zeros(1, dtype=quat, requires_grad=True)
-    y = wp.ones(1, dtype=wp_type, requires_grad=True)
-
-    with tape:
-        wp.launch(kernel_component, dim=1, inputs=[x, y])
-
-    tape.backward(grads={x: wp.ones_like(x, requires_grad=False)})
-
-    assert_np_equal(x.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=np_type))
-    assert_np_equal(y.grad.numpy(), np.array([10.0], dtype=np_type))
-
-
-############################################################
-
-
 def test_quat_euler_conversion(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
     N = 3
@@ -2065,6 +1982,12 @@ def test_constructor_default():
     wp.expect_eq(qeye[2], 0.0)
     wp.expect_eq(qeye[3], 1.0)
 
+    qlit = wp.quaternion(1.0, 2.0, 3.0, 4.0, dtype=float)
+    wp.expect_eq(qlit[0], 1.0)
+    wp.expect_eq(qlit[1], 2.0)
+    wp.expect_eq(qlit[2], 3.0)
+    wp.expect_eq(qlit[3], 4.0)
+
 
 def test_py_arithmetic_ops(test, device, dtype):
     wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
@@ -2116,54 +2039,85 @@ def test_quat_len(test, device):
 
 
 @wp.kernel
-def quat_augassign_kernel(
-    a: wp.array(dtype=wp.quat), b: wp.array(dtype=wp.quat), c: wp.array(dtype=wp.quat), d: wp.array(dtype=wp.quat)
-):
-    i = wp.tid()
+def quat_extract_subscript(x: wp.array(dtype=wp.quat), y: wp.array(dtype=float)):
+    tid = wp.tid()
 
-    q1 = wp.quat()
-    q2 = b[i]
+    a = x[tid]
+    b = a[0] + 2.0 * a[1] + 3.0 * a[2] + 4.0 * a[3]
+    y[tid] = b
 
-    q1[0] += q2[0]
-    q1[1] += q2[1]
-    q1[2] += q2[2]
-    q1[3] += q2[3]
 
-    a[i] = q1
+""" TODO: rhs attribute indexing
+@wp.kernel
+def quat_extract_attribute(x: wp.array(dtype=wp.quat), y: wp.array(dtype=float)):
+    tid = wp.tid()
 
-    q3 = wp.quat()
-    q4 = d[i]
+    a = x[tid]
+    b = a.x + float(2.0) * a.y + 3.0 * a.z + 4.0 * a.w
+    y[tid] = b
+"""
 
-    q3[0] -= q4[0]
-    q3[1] -= q4[1]
-    q3[2] -= q4[2]
-    q3[3] -= q4[3]
 
-    c[i] = q3
+def test_quat_extract(test, device):
+    def run(kernel):
+        x = wp.ones(1, dtype=wp.quat, requires_grad=True, device=device)
+        y = wp.zeros(1, dtype=float, requires_grad=True, device=device)
 
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, 1, inputs=[x], outputs=[y], device=device)
 
-def test_quat_augassign(test, device):
-    N = 3
+        y.grad = wp.ones_like(y)
+        tape.backward()
 
-    a = wp.zeros(N, dtype=wp.quat, requires_grad=True, device=device)
-    b = wp.ones(N, dtype=wp.quat, requires_grad=True, device=device)
+        assert_np_equal(y.numpy(), np.array([10.0], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=float))
 
-    c = wp.zeros(N, dtype=wp.quat, requires_grad=True, device=device)
-    d = wp.ones(N, dtype=wp.quat, requires_grad=True, device=device)
+    run(quat_extract_subscript)
+    # run(quat_extract_attribute)
 
-    tape = wp.Tape()
-    with tape:
-        wp.launch(quat_augassign_kernel, N, inputs=[a, b, c, d], device=device)
 
-    tape.backward(grads={a: wp.ones_like(a), c: wp.ones_like(c)})
+@wp.kernel
+def quat_assign_subscript(x: wp.array(dtype=float), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    a[0] = 1.0 * x[i]
+    a[1] = 2.0 * x[i]
+    a[2] = 3.0 * x[i]
+    a[3] = 4.0 * x[i]
+    y[i] = a
+
+
+@wp.kernel
+def quat_assign_attribute(x: wp.array(dtype=float), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    a.x = 1.0 * x[i]
+    a.y = 2.0 * x[i]
+    a.z = 3.0 * x[i]
+    a.w = 4.0 * x[i]
+    y[i] = a
+
+
+def test_quat_assign(test, device):
+    def run(kernel):
+        x = wp.ones(1, dtype=float, requires_grad=True, device=device)
+        y = wp.zeros(1, dtype=wp.quat, requires_grad=True, device=device)
+
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, 1, inputs=[x], outputs=[y], device=device)
+
+        y.grad = wp.ones_like(y)
+        tape.backward()
 
-    assert_np_equal(a.numpy(), wp.ones_like(a).numpy())
-    assert_np_equal(a.grad.numpy(), wp.ones_like(a).numpy())
-    assert_np_equal(b.grad.numpy(), wp.ones_like(a).numpy())
+        assert_np_equal(y.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([10.0], dtype=float))
 
-    assert_np_equal(c.numpy(), -wp.ones_like(c).numpy())
-    assert_np_equal(c.grad.numpy(), wp.ones_like(c).numpy())
-    assert_np_equal(d.grad.numpy(), -wp.ones_like(d).numpy())
+    run(quat_assign_subscript)
+    run(quat_assign_attribute)
 
 
 def test_quat_assign_copy(test, device):
@@ -2172,32 +2126,261 @@ def test_quat_assign_copy(test, device):
         wp.config.enable_vector_component_overwrites = True
 
         @wp.kernel
-        def quat_in_register_overwrite(x: wp.array(dtype=wp.quat), a: wp.array(dtype=wp.quat)):
+        def quat_assign_overwrite(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
             tid = wp.tid()
 
-            f = wp.quat()
-            a_quat = a[tid]
-            f = a_quat
-            f[1] = 3.0
+            a = wp.quat()
+            b = x[tid]
+            a = b
+            a[1] = 3.0
 
-            x[tid] = f
+            y[tid] = a
 
-        x = wp.zeros(1, dtype=wp.quat, device=device, requires_grad=True)
-        a = wp.ones(1, dtype=wp.quat, device=device, requires_grad=True)
+        x = wp.ones(1, dtype=wp.quat, device=device, requires_grad=True)
+        y = wp.zeros(1, dtype=wp.quat, device=device, requires_grad=True)
 
         tape = wp.Tape()
         with tape:
-            wp.launch(quat_in_register_overwrite, dim=1, inputs=[x, a], device=device)
+            wp.launch(quat_assign_overwrite, dim=1, inputs=[x, y], device=device)
 
-        tape.backward(grads={x: wp.ones_like(x, requires_grad=False)})
+        y.grad = wp.ones_like(y, requires_grad=False)
+        tape.backward()
 
-        assert_np_equal(x.numpy(), np.array([[1.0, 3.0, 1.0, 1.0]], dtype=float))
-        assert_np_equal(a.grad.numpy(), np.array([[1.0, 0.0, 1.0, 1.0]], dtype=float))
+        assert_np_equal(y.numpy(), np.array([[1.0, 3.0, 1.0, 1.0]], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([[1.0, 0.0, 1.0, 1.0]], dtype=float))
 
     finally:
         wp.config.enable_vector_component_overwrites = saved_enable_vector_component_overwrites_setting
 
 
+@wp.kernel
+def quat_array_extract_subscript(x: wp.array2d(dtype=wp.quat), y: wp.array2d(dtype=float)):
+    i, j = wp.tid()
+    a = x[i, j][0]
+    b = x[i, j][1]
+    c = x[i, j][2]
+    d = x[i, j][3]
+    y[i, j] = 1.0 * a + 2.0 * b + 3.0 * c + 4.0 * d
+
+
+""" TODO: rhs attribute indexing
+@wp.kernel
+def quat_array_extract_attribute(x: wp.array2d(dtype=wp.quat), y: wp.array2d(dtype=float)):
+    i, j = wp.tid()
+    a = x[i, j].x
+    b = x[i, j].y
+    c = x[i, j].z
+    d = x[i, j].w
+    y[i, j] = 1.0 * a + 2.0 * b + 3.0 * c + 4.0 * d
+"""
+
+
+def test_quat_array_extract(test, device):
+    def run(kernel):
+        x = wp.ones((1, 1), dtype=wp.quat, requires_grad=True, device=device)
+        y = wp.zeros((1, 1), dtype=float, requires_grad=True, device=device)
+
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, (1, 1), inputs=[x], outputs=[y], device=device)
+
+        y.grad = wp.ones_like(y)
+        tape.backward()
+
+        assert_np_equal(y.numpy(), np.array([[10.0]], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([[[1.0, 2.0, 3.0, 4.0]]], dtype=float))
+
+    run(quat_array_extract_subscript)
+    # run(quat_array_extract_attribute)
+
+
+@wp.kernel
+def quat_array_assign_subscript(x: wp.array2d(dtype=float), y: wp.array2d(dtype=wp.quat)):
+    i, j = wp.tid()
+
+    y[i, j][0] = 1.0 * x[i, j]
+    y[i, j][1] = 2.0 * x[i, j]
+    y[i, j][2] = 3.0 * x[i, j]
+    y[i, j][3] = 4.0 * x[i, j]
+
+
+@wp.kernel
+def quat_array_assign_attribute(x: wp.array2d(dtype=float), y: wp.array2d(dtype=wp.quat)):
+    i, j = wp.tid()
+
+    y[i, j].x = 1.0 * x[i, j]
+    y[i, j].y = 2.0 * x[i, j]
+    y[i, j].z = 3.0 * x[i, j]
+    y[i, j].w = 4.0 * x[i, j]
+
+
+def test_quat_array_assign(test, device):
+    def run(kernel):
+        x = wp.ones((1, 1), dtype=float, requires_grad=True, device=device)
+        y = wp.zeros((1, 1), dtype=wp.quat, requires_grad=True, device=device)
+
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, (1, 1), inputs=[x], outputs=[y], device=device)
+
+        y.grad = wp.ones_like(y)
+        tape.backward()
+
+        assert_np_equal(y.numpy(), np.array([[[1.0, 2.0, 3.0, 4.0]]], dtype=float))
+        # TODO: gradient propagation for in-place array assignment
+        # assert_np_equal(x.grad.numpy(), np.array([[10.0]], dtype=float))
+
+    run(quat_array_assign_subscript)
+    run(quat_array_assign_attribute)
+
+
+@wp.kernel
+def quat_add_inplace_subscript(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    b = x[i]
+
+    a[0] += 1.0 * b[0]
+    a[1] += 2.0 * b[1]
+    a[2] += 3.0 * b[2]
+    a[3] += 4.0 * b[3]
+
+    y[i] = a
+
+
+""" TODO: rhs attribute indexing
+@wp.kernel
+def quat_add_inplace_attribute(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    b = x[i]
+
+    a.x += 1.0 * b.x
+    a.y += 2.0 * b.y
+    a.z += 3.0 * b.z
+    a.w += 4.0 * b.w
+
+    y[i] = a
+"""
+
+
+def test_quat_add_inplace(test, device):
+    def run(kernel):
+        x = wp.ones(1, dtype=wp.quat, requires_grad=True, device=device)
+        y = wp.zeros(1, dtype=wp.quat, requires_grad=True, device=device)
+
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, 1, inputs=[x], outputs=[y], device=device)
+
+        y.grad = wp.ones_like(y)
+        tape.backward()
+
+        assert_np_equal(y.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([[1.0, 2.0, 3.0, 4.0]], dtype=float))
+
+    run(quat_add_inplace_subscript)
+    # run(quat_add_inplace_attribute)
+
+
+@wp.kernel
+def quat_sub_inplace_subscript(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    b = x[i]
+
+    a[0] -= 1.0 * b[0]
+    a[1] -= 2.0 * b[1]
+    a[2] -= 3.0 * b[2]
+    a[3] -= 4.0 * b[3]
+
+    y[i] = a
+
+
+""" TODO: rhs attribute indexing
+@wp.kernel
+def quat_sub_inplace_attribute(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    a = wp.quat()
+    b = x[i]
+
+    a.x -= 1.0 * b.x
+    a.y -= 2.0 * b.y
+    a.z -= 3.0 * b.z
+    a.w -= 4.0 * b.w
+
+    y[i] = a
+"""
+
+
+def test_quat_sub_inplace(test, device):
+    def run(kernel):
+        x = wp.ones(1, dtype=wp.quat, requires_grad=True, device=device)
+        y = wp.zeros(1, dtype=wp.quat, requires_grad=True, device=device)
+
+        tape = wp.Tape()
+        with tape:
+            wp.launch(kernel, 1, inputs=[x], outputs=[y], device=device)
+
+        y.grad = wp.ones_like(y)
+        tape.backward()
+
+        assert_np_equal(y.numpy(), np.array([[-1.0, -2.0, -3.0, -4.0]], dtype=float))
+        assert_np_equal(x.grad.numpy(), np.array([[-1.0, -2.0, -3.0, -4.0]], dtype=float))
+
+    run(quat_sub_inplace_subscript)
+    # run(quat_sub_inplace_attribute)
+
+
+@wp.kernel
+def quat_array_add_inplace(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    y[i] += x[i]
+
+
+def test_quat_array_add_inplace(test, device):
+    x = wp.ones(1, dtype=wp.quat, requires_grad=True, device=device)
+    y = wp.zeros(1, dtype=wp.quat, requires_grad=True, device=device)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(quat_array_add_inplace, 1, inputs=[x], outputs=[y], device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    assert_np_equal(y.numpy(), np.array([[1.0, 1.0, 1.0, 1.0]], dtype=float))
+    assert_np_equal(x.grad.numpy(), np.array([[1.0, 1.0, 1.0, 1.0]], dtype=float))
+
+
+""" TODO: quat negation operator
+@wp.kernel
+def quat_array_sub_inplace(x: wp.array(dtype=wp.quat), y: wp.array(dtype=wp.quat)):
+    i = wp.tid()
+
+    y[i] -= x[i]
+
+
+def test_quat_array_sub_inplace(test, device):
+    x = wp.ones(1, dtype=wp.quat, requires_grad=True, device=device)
+    y = wp.zeros(1, dtype=wp.quat, requires_grad=True, device=device)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(quat_array_sub_inplace, 1, inputs=[x], outputs=[y], device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    assert_np_equal(y.numpy(), np.array([[-1.0, -1.0, -1.0, -1.0]], dtype=float))
+    assert_np_equal(x.grad.numpy(), np.array([[-1.0, -1.0, -1.0, -1.0]], dtype=float))
+"""
+
 devices = get_test_devices()
 
 
@@ -2295,20 +2478,21 @@ for dtype in np_float_types:
         devices=devices,
         dtype=dtype,
     )
-    add_function_test_register_kernel(
-        TestQuat,
-        f"test_quat_assign_inplace_{dtype.__name__}",
-        test_quat_assign_inplace,
-        devices=devices,
-        dtype=dtype,
-    )
     add_function_test(
         TestQuat, f"test_py_arithmetic_ops_{dtype.__name__}", test_py_arithmetic_ops, devices=None, dtype=dtype
     )
 
 add_function_test(TestQuat, "test_quat_len", test_quat_len, devices=devices)
-add_function_test(TestQuat, "test_quat_augassign", test_quat_augassign, devices=devices)
+add_function_test(TestQuat, "test_quat_extract", test_quat_extract, devices=devices)
+add_function_test(TestQuat, "test_quat_assign", test_quat_assign, devices=devices)
 add_function_test(TestQuat, "test_quat_assign_copy", test_quat_assign_copy, devices=devices)
+add_function_test(TestQuat, "test_quat_array_extract", test_quat_array_extract, devices=devices)
+add_function_test(TestQuat, "test_quat_array_assign", test_quat_array_assign, devices=devices)
+add_function_test(TestQuat, "test_quat_add_inplace", test_quat_add_inplace, devices=devices)
+add_function_test(TestQuat, "test_quat_sub_inplace", test_quat_sub_inplace, devices=devices)
+add_function_test(TestQuat, "test_quat_array_add_inplace", test_quat_array_add_inplace, devices=devices)
+# add_function_test(TestQuat, "test_quat_array_sub_inplace", test_quat_array_sub_inplace, devices=devices)
+
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

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__":