warp-lang 1.9.1__py3-none-manylinux_2_34_aarch64.whl → 1.10.0rc2__py3-none-manylinux_2_34_aarch64.whl

warp/tests/test_codegen.py

@@ -385,7 +385,7 @@ 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.aux_test_unresolved_func"]
+    del wp._src.context.user_modules["warp.tests.aux_test_unresolved_func"]
     del sys.modules["warp.tests.aux_test_unresolved_func"]
 
 
@@ -399,7 +399,7 @@ 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.aux_test_unresolved_symbol"]
+    del wp._src.context.user_modules["warp.tests.aux_test_unresolved_symbol"]
     del sys.modules["warp.tests.aux_test_unresolved_symbol"]
 
 
@@ -418,15 +418,15 @@ def test_error_global_var(test, device):
     out = wp.empty_like(arr)
 
     kernel = wp.Kernel(func=kernel_1_fn)
-    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp.types.array'>"):
+    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp._src.types.array'>"):
         wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,), device=device)
 
     kernel = wp.Kernel(func=kernel_2_fn)
-    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp.types.array'>"):
+    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp._src.types.array'>"):
         wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,), device=device)
 
     kernel = wp.Kernel(func=kernel_3_fn)
-    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp.types.array'>"):
+    with test.assertRaisesRegex(TypeError, r"Invalid external reference type: <class 'warp._src.types.array'>"):
         wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,), device=device)
 
 
@@ -477,7 +477,7 @@ def test_error_mutating_constant_in_dynamic_loop(test, device):
 
     inputs = wp.array([1.0, 2.0, 3.0], dtype=float, device=device)
     with test.assertRaisesRegex(
-        wp.codegen.WarpCodegenError,
+        wp._src.codegen.WarpCodegenError,
         r"Error mutating a constant my_constant inside a dynamic loop, use the following syntax\: pi = float\(3\.141\) to declare a dynamic variable",
     ):
         wp.launch(dynamic_loop_kernel, dim=1, inputs=[3, inputs], device=device)
@@ -584,28 +584,28 @@ def test_error_return_annotation_mismatch(test, device):
 
     kernel = wp.Kernel(func=kernel_1_fn)
     with test.assertRaisesRegex(
-        wp.codegen.WarpCodegenError,
+        wp._src.codegen.WarpCodegenError,
         r"The function `foo_1` has its return type annotated as `int16` but the code returns a value of type `int8`.",
     ):
         wp.launch(kernel, dim=1, device=device)
 
     kernel = wp.Kernel(func=kernel_2_fn)
     with test.assertRaisesRegex(
-        wp.codegen.WarpCodegenError,
+        wp._src.codegen.WarpCodegenError,
         r"The function `foo_2` has its return type annotated as `int` but the code returns 2 values.",
     ):
         wp.launch(kernel, dim=1, device=device)
 
     kernel = wp.Kernel(func=kernel_3_fn)
     with test.assertRaisesRegex(
-        wp.codegen.WarpCodegenError,
+        wp._src.codegen.WarpCodegenError,
         r"The function `foo_3` has its return type annotated as `Tuple\[int, int\]` but the code returns a tuple with types `\(int32, float32\)`.",
     ):
         wp.launch(kernel, dim=1, device=device)
 
     kernel = wp.Kernel(func=kernel_4_fn)
     with test.assertRaisesRegex(
-        wp.codegen.WarpCodegenError,
+        wp._src.codegen.WarpCodegenError,
         r"The function `foo_4` has its return type annotated as a tuple of 3 elements but the code returns 2 values.",
     ):
         wp.launch(kernel, dim=1, device=device)
@@ -623,10 +623,9 @@ def test_call_syntax():
     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)
+    wp.expect_eq(wp.transform_compose(pos, rot, scale), expected_matrix)
+    wp.expect_eq(wp.transform_compose(position=pos, rotation=rot, scale=scale), expected_matrix)
+    wp.expect_eq(wp.transform_compose(rotation=rot, position=pos, scale=scale), expected_matrix)
 
 
 # test shadowing builtin functions
@@ -807,6 +806,25 @@ def test_multiple_return_values(test, device):
     )
 
 
+@wp.struct
+class Pun:
+    f: wp.float16
+    i: wp.int16
+
+
+@wp.kernel
+def test_cast():
+    x = wp.int32(0x3FA00000)
+    x_casted = wp.cast(x, wp.float32)
+    wp.expect_eq(x_casted, 1.25)
+
+    p = Pun()
+    p.f = wp.float16(2.0)
+    p.i = wp.int16(123)
+    p_casted = wp.cast(p, wp.int32)
+    wp.expect_eq(p_casted, 0x007B4000)
+
+
 class TestCodeGen(unittest.TestCase):
     pass
 
@@ -948,6 +966,7 @@ add_function_test(
     name="test_multiple_return_values",
     devices=devices,
 )
+add_kernel_test(TestCodeGen, name="test_cast", kernel=test_cast, dim=1, devices=devices)
 
 
 if __name__ == "__main__":

warp/tests/test_conditional.py

@@ -260,7 +260,7 @@ def test_conditional_unequal_types(test: unittest.TestCase, 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.aux_test_conditional_unequal_types_kernels"]
+    del wp._src.context.user_modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
     del sys.modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
 
 

warp/tests/test_context.py

@@ -21,13 +21,13 @@ import warp as wp
 
 class TestContext(unittest.TestCase):
     def test_context_type_str(self):
-        self.assertEqual(wp.context.type_str(List[int]), "List[int]")
-        self.assertEqual(wp.context.type_str(List[float]), "List[float]")
+        self.assertEqual(wp._src.context.type_str(List[int]), "List[int]")
+        self.assertEqual(wp._src.context.type_str(List[float]), "List[float]")
 
-        self.assertEqual(wp.context.type_str(Tuple[int]), "Tuple[int]")
-        self.assertEqual(wp.context.type_str(Tuple[float]), "Tuple[float]")
-        self.assertEqual(wp.context.type_str(Tuple[int, float]), "Tuple[int, float]")
-        self.assertEqual(wp.context.type_str(Tuple[int, ...]), "Tuple[int, ...]")
+        self.assertEqual(wp._src.context.type_str(Tuple[int]), "Tuple[int]")
+        self.assertEqual(wp._src.context.type_str(Tuple[float]), "Tuple[float]")
+        self.assertEqual(wp._src.context.type_str(Tuple[int, float]), "Tuple[int, float]")
+        self.assertEqual(wp._src.context.type_str(Tuple[int, ...]), "Tuple[int, ...]")
 
 
 if __name__ == "__main__":

warp/tests/test_copy.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import gc
+import importlib
 import unittest
 
 import numpy as np
@@ -45,164 +47,217 @@ def mul_4d(a: wp.array4d(dtype=float), s: float):
     a[i, j, k, l] = a[i, j, k, l] * s
 
 
-def test_copy_strided(test, device):
-    with wp.ScopedDevice(device):
-        np_data1 = np.arange(10, dtype=np.float32)
-        np_data2 = np.arange(100, dtype=np.float32).reshape((10, 10))
-        np_data3 = np.arange(1000, dtype=np.float32).reshape((10, 10, 10))
-        np_data4 = np.arange(10000, dtype=np.float32).reshape((10, 10, 10, 10))
-
-        wp_data1 = wp.array(data=np_data1, copy=True)
-        wp_data2 = wp.array(data=np_data2, copy=True)
-        wp_data3 = wp.array(data=np_data3, copy=True)
-        wp_data4 = wp.array(data=np_data4, copy=True)
-
-        expected1 = np_data1[1::2]
-        expected2 = np_data2[1::2, 1::2]
-        expected3 = np_data3[1::2, 1::2, 1::2]
-        expected4 = np_data4[1::2, 1::2, 1::2, 1::2]
-
-        a1 = wp_data1[1::2]
-        a2 = wp_data2[1::2, 1::2]
-        a3 = wp_data3[1::2, 1::2, 1::2]
-        a4 = wp_data4[1::2, 1::2, 1::2, 1::2]
-
-        assert_np_equal(a1.numpy(), expected1)
-        assert_np_equal(a2.numpy(), expected2)
-        assert_np_equal(a3.numpy(), expected3)
-        assert_np_equal(a4.numpy(), expected4)
-
-        b1 = wp.zeros_like(a1)
-        b2 = wp.zeros_like(a2)
-        b3 = wp.zeros_like(a3)
-        b4 = wp.zeros_like(a4)
-
-        test.assertFalse(a1.is_contiguous)
-        test.assertFalse(a2.is_contiguous)
-        test.assertFalse(a3.is_contiguous)
-        test.assertFalse(a4.is_contiguous)
-
-        test.assertTrue(b1.is_contiguous)
-        test.assertTrue(b2.is_contiguous)
-        test.assertTrue(b3.is_contiguous)
-        test.assertTrue(b4.is_contiguous)
-
-        # copy non-contiguous to contiguous
-        wp.copy(b1, a1)
-        wp.copy(b2, a2)
-        wp.copy(b3, a3)
-        wp.copy(b4, a4)
-
-        assert_np_equal(a1.numpy(), b1.numpy())
-        assert_np_equal(a2.numpy(), b2.numpy())
-        assert_np_equal(a3.numpy(), b3.numpy())
-        assert_np_equal(a4.numpy(), b4.numpy())
-
-        s = 2.0
-
-        wp.launch(mul_1d, dim=b1.shape, inputs=[b1, s])
-        wp.launch(mul_2d, dim=b2.shape, inputs=[b2, s])
-        wp.launch(mul_3d, dim=b3.shape, inputs=[b3, s])
-        wp.launch(mul_4d, dim=b4.shape, inputs=[b4, s])
-
-        # copy contiguous to non-contiguous
-        wp.copy(a1, b1)
-        wp.copy(a2, b2)
-        wp.copy(a3, b3)
-        wp.copy(a4, b4)
-
-        assert_np_equal(a1.numpy(), b1.numpy())
-        assert_np_equal(a2.numpy(), b2.numpy())
-        assert_np_equal(a3.numpy(), b3.numpy())
-        assert_np_equal(a4.numpy(), b4.numpy())
-
-        assert_np_equal(a1.numpy(), expected1 * s)
-        assert_np_equal(a2.numpy(), expected2 * s)
-        assert_np_equal(a3.numpy(), expected3 * s)
-        assert_np_equal(a4.numpy(), expected4 * s)
-
-
-def test_copy_indexed(test, device):
-    with wp.ScopedDevice(device):
-        np_data1 = np.arange(10, dtype=np.float32)
-        np_data2 = np.arange(100, dtype=np.float32).reshape((10, 10))
-        np_data3 = np.arange(1000, dtype=np.float32).reshape((10, 10, 10))
-        np_data4 = np.arange(10000, dtype=np.float32).reshape((10, 10, 10, 10))
-
-        wp_data1 = wp.array(data=np_data1, copy=True)
-        wp_data2 = wp.array(data=np_data2, copy=True)
-        wp_data3 = wp.array(data=np_data3, copy=True)
-        wp_data4 = wp.array(data=np_data4, copy=True)
-
-        np_indices = np.array([1, 5, 8, 9])
-        wp_indices = wp.array(data=np_indices, dtype=wp.int32)
-
-        # Note: Indexing using multiple index arrays works differently
-        #       in Numpy and Warp, so the syntax is different.
-
-        expected1 = np_data1[np_indices]
-        expected2 = np_data2[np_indices][:, np_indices]
-        expected3 = np_data3[np_indices][:, np_indices][:, :, np_indices]
-        expected4 = np_data4[np_indices][:, np_indices][:, :, np_indices][:, :, :, np_indices]
-
-        a1 = wp_data1[wp_indices]
-        a2 = wp_data2[wp_indices, wp_indices]
-        a3 = wp_data3[wp_indices, wp_indices, wp_indices]
-        a4 = wp_data4[wp_indices, wp_indices, wp_indices, wp_indices]
-
-        assert_np_equal(a1.numpy(), expected1)
-        assert_np_equal(a2.numpy(), expected2)
-        assert_np_equal(a3.numpy(), expected3)
-        assert_np_equal(a4.numpy(), expected4)
-
-        b1 = wp.zeros_like(a1)
-        b2 = wp.zeros_like(a2)
-        b3 = wp.zeros_like(a3)
-        b4 = wp.zeros_like(a4)
-
-        test.assertFalse(a1.is_contiguous)
-        test.assertFalse(a2.is_contiguous)
-        test.assertFalse(a3.is_contiguous)
-        test.assertFalse(a4.is_contiguous)
-
-        test.assertTrue(b1.is_contiguous)
-        test.assertTrue(b2.is_contiguous)
-        test.assertTrue(b3.is_contiguous)
-        test.assertTrue(b4.is_contiguous)
-
-        # copy non-contiguous to contiguous
-        wp.copy(b1, a1)
-        wp.copy(b2, a2)
-        wp.copy(b3, a3)
-        wp.copy(b4, a4)
-
-        assert_np_equal(a1.numpy(), b1.numpy())
-        assert_np_equal(a2.numpy(), b2.numpy())
-        assert_np_equal(a3.numpy(), b3.numpy())
-        assert_np_equal(a4.numpy(), b4.numpy())
-
-        s = 2.0
-
-        wp.launch(mul_1d, dim=b1.shape, inputs=[b1, s])
-        wp.launch(mul_2d, dim=b2.shape, inputs=[b2, s])
-        wp.launch(mul_3d, dim=b3.shape, inputs=[b3, s])
-        wp.launch(mul_4d, dim=b4.shape, inputs=[b4, s])
-
-        # copy contiguous to non-contiguous
-        wp.copy(a1, b1)
-        wp.copy(a2, b2)
-        wp.copy(a3, b3)
-        wp.copy(a4, b4)
-
-        assert_np_equal(a1.numpy(), b1.numpy())
-        assert_np_equal(a2.numpy(), b2.numpy())
-        assert_np_equal(a3.numpy(), b3.numpy())
-        assert_np_equal(a4.numpy(), b4.numpy())
-
-        assert_np_equal(a1.numpy(), expected1 * s)
-        assert_np_equal(a2.numpy(), expected2 * s)
-        assert_np_equal(a3.numpy(), expected3 * s)
-        assert_np_equal(a4.numpy(), expected4 * s)
+@wp.kernel
+def all_equal_kernel(a: wp.array(dtype=float), value: float, result: wp.array(dtype=int)):
+    tid = wp.tid()
+    wp.atomic_min(result, 0, int(a[tid] == value))
+
+
+def assert_all_equal(a: wp.array(dtype=float), value: float):
+    result = wp.ones(1, dtype=int, device=a.device)
+    wp.launch(all_equal_kernel, dim=a.shape, inputs=[a, value, result], device=a.device)
+    assert result.numpy()[0] == 1
+
+
+def test_copy_strided(test, _, device1, device2):
+    np_data1 = np.arange(10, dtype=np.float32)
+    np_data2 = np.arange(100, dtype=np.float32).reshape((10, 10))
+    np_data3 = np.arange(1000, dtype=np.float32).reshape((10, 10, 10))
+    np_data4 = np.arange(10000, dtype=np.float32).reshape((10, 10, 10, 10))
+
+    wp_data1 = wp.array(data=np_data1, copy=True, device=device1)
+    wp_data2 = wp.array(data=np_data2, copy=True, device=device1)
+    wp_data3 = wp.array(data=np_data3, copy=True, device=device1)
+    wp_data4 = wp.array(data=np_data4, copy=True, device=device1)
+
+    expected1 = np_data1[1::2]
+    expected2 = np_data2[1::2, 1::2]
+    expected3 = np_data3[1::2, 1::2, 1::2]
+    expected4 = np_data4[1::2, 1::2, 1::2, 1::2]
+
+    a1 = wp_data1[1::2]
+    a2 = wp_data2[1::2, 1::2]
+    a3 = wp_data3[1::2, 1::2, 1::2]
+    a4 = wp_data4[1::2, 1::2, 1::2, 1::2]
+
+    assert_np_equal(a1.numpy(), expected1)
+    assert_np_equal(a2.numpy(), expected2)
+    assert_np_equal(a3.numpy(), expected3)
+    assert_np_equal(a4.numpy(), expected4)
+
+    b1 = wp.zeros_like(a1, device=device2)
+    b2 = wp.zeros_like(a2, device=device2)
+    b3 = wp.zeros_like(a3, device=device2)
+    b4 = wp.zeros_like(a4, device=device2)
+
+    test.assertFalse(a1.is_contiguous)
+    test.assertFalse(a2.is_contiguous)
+    test.assertFalse(a3.is_contiguous)
+    test.assertFalse(a4.is_contiguous)
+
+    test.assertTrue(b1.is_contiguous)
+    test.assertTrue(b2.is_contiguous)
+    test.assertTrue(b3.is_contiguous)
+    test.assertTrue(b4.is_contiguous)
+
+    # copy non-contiguous to contiguous
+    wp.synchronize_device(device1)
+    wp.copy(b1, a1)
+    wp.copy(b2, a2)
+    wp.copy(b3, a3)
+    wp.copy(b4, a4)
+
+    assert_np_equal(a1.numpy(), b1.numpy())
+    assert_np_equal(a2.numpy(), b2.numpy())
+    assert_np_equal(a3.numpy(), b3.numpy())
+    assert_np_equal(a4.numpy(), b4.numpy())
+
+    s = 2.0
+
+    wp.launch(mul_1d, dim=b1.shape, inputs=[b1, s], device=device2)
+    wp.launch(mul_2d, dim=b2.shape, inputs=[b2, s], device=device2)
+    wp.launch(mul_3d, dim=b3.shape, inputs=[b3, s], device=device2)
+    wp.launch(mul_4d, dim=b4.shape, inputs=[b4, s], device=device2)
+
+    # copy contiguous to non-contiguous
+    wp.synchronize_device(device2)
+    wp.copy(a1, b1)
+    wp.copy(a2, b2)
+    wp.copy(a3, b3)
+    wp.copy(a4, b4)
+
+    assert_np_equal(a1.numpy(), b1.numpy())
+    assert_np_equal(a2.numpy(), b2.numpy())
+    assert_np_equal(a3.numpy(), b3.numpy())
+    assert_np_equal(a4.numpy(), b4.numpy())
+
+    assert_np_equal(a1.numpy(), expected1 * s)
+    assert_np_equal(a2.numpy(), expected2 * s)
+    assert_np_equal(a3.numpy(), expected3 * s)
+    assert_np_equal(a4.numpy(), expected4 * s)
+
+
+def test_copy_indexed(test, _, device1, device2):
+    np_data1 = np.arange(10, dtype=np.float32)
+    np_data2 = np.arange(100, dtype=np.float32).reshape((10, 10))
+    np_data3 = np.arange(1000, dtype=np.float32).reshape((10, 10, 10))
+    np_data4 = np.arange(10000, dtype=np.float32).reshape((10, 10, 10, 10))
+
+    wp_data1 = wp.array(data=np_data1, copy=True, device=device1)
+    wp_data2 = wp.array(data=np_data2, copy=True, device=device1)
+    wp_data3 = wp.array(data=np_data3, copy=True, device=device1)
+    wp_data4 = wp.array(data=np_data4, copy=True, device=device1)
+
+    np_indices = np.array([1, 5, 8, 9])
+    wp_indices = wp.array(data=np_indices, dtype=wp.int32, device=device1)
+
+    # Note: Indexing using multiple index arrays works differently
+    #       in Numpy and Warp, so the syntax is different.
+
+    expected1 = np_data1[np_indices]
+    expected2 = np_data2[np_indices][:, np_indices]
+    expected3 = np_data3[np_indices][:, np_indices][:, :, np_indices]
+    expected4 = np_data4[np_indices][:, np_indices][:, :, np_indices][:, :, :, np_indices]
+
+    a1 = wp_data1[wp_indices]
+    a2 = wp_data2[wp_indices, wp_indices]
+    a3 = wp_data3[wp_indices, wp_indices, wp_indices]
+    a4 = wp_data4[wp_indices, wp_indices, wp_indices, wp_indices]
+
+    assert_np_equal(a1.numpy(), expected1)
+    assert_np_equal(a2.numpy(), expected2)
+    assert_np_equal(a3.numpy(), expected3)
+    assert_np_equal(a4.numpy(), expected4)
+
+    b1 = wp.zeros_like(a1, device=device2)
+    b2 = wp.zeros_like(a2, device=device2)
+    b3 = wp.zeros_like(a3, device=device2)
+    b4 = wp.zeros_like(a4, device=device2)
+
+    test.assertFalse(a1.is_contiguous)
+    test.assertFalse(a2.is_contiguous)
+    test.assertFalse(a3.is_contiguous)
+    test.assertFalse(a4.is_contiguous)
+
+    test.assertTrue(b1.is_contiguous)
+    test.assertTrue(b2.is_contiguous)
+    test.assertTrue(b3.is_contiguous)
+    test.assertTrue(b4.is_contiguous)
+
+    # copy non-contiguous to contiguous
+    wp.synchronize_device(device1)
+    wp.copy(b1, a1)
+    wp.copy(b2, a2)
+    wp.copy(b3, a3)
+    wp.copy(b4, a4)
+
+    assert_np_equal(a1.numpy(), b1.numpy())
+    assert_np_equal(a2.numpy(), b2.numpy())
+    assert_np_equal(a3.numpy(), b3.numpy())
+    assert_np_equal(a4.numpy(), b4.numpy())
+
+    s = 2.0
+
+    wp.launch(mul_1d, dim=b1.shape, inputs=[b1, s], device=device2)
+    wp.launch(mul_2d, dim=b2.shape, inputs=[b2, s], device=device2)
+    wp.launch(mul_3d, dim=b3.shape, inputs=[b3, s], device=device2)
+    wp.launch(mul_4d, dim=b4.shape, inputs=[b4, s], device=device2)
+
+    # copy contiguous to non-contiguous
+    wp.synchronize_device(device2)
+    wp.copy(a1, b1)
+    wp.copy(a2, b2)
+    wp.copy(a3, b3)
+    wp.copy(a4, b4)
+
+    assert_np_equal(a1.numpy(), b1.numpy())
+    assert_np_equal(a2.numpy(), b2.numpy())
+    assert_np_equal(a3.numpy(), b3.numpy())
+    assert_np_equal(a4.numpy(), b4.numpy())
+
+    assert_np_equal(a1.numpy(), expected1 * s)
+    assert_np_equal(a2.numpy(), expected2 * s)
+    assert_np_equal(a3.numpy(), expected3 * s)
+    assert_np_equal(a4.numpy(), expected4 * s)
+
+
+def test_copy_large_stride(test, _, device1, device2):
+    # NOTE: This test can use ~8GB of memory. To prevent errors, we skip if there is insufficient memory.
+
+    gc.collect()
+
+    if device1.is_cpu or device2.is_cpu:
+        if importlib.util.find_spec("psutil") is None:
+            test.skipTest("The 'psutil' package is required to check available memory")
+
+    if device1.free_memory < 12e9 or device2.free_memory < 12e9:
+        test.skipTest("Insufficient free memory")
+
+    N = 500_000_000
+
+    a_data = wp.empty((N, 2), dtype=wp.float32, device=device1)
+    a = a_data[:, 0]  # array with a large stride (offsets > 32 bits)
+
+    b = wp.empty_like(a, device=device2)
+
+    a.fill_(1)
+    b.fill_(2)
+
+    # NOTE: use a memory-efficient check to avoid running out of memory
+    assert_all_equal(a, 1)
+    assert_all_equal(b, 2)
+
+    # copy to large-strided array
+    wp.synchronize_device(device2)
+    wp.copy(a, b)
+    assert_all_equal(a, 2)
+
+    a.fill_(1)
+
+    # copy from large-strided array
+    wp.synchronize_device(device1)
+    wp.copy(b, a)
+    assert_all_equal(b, 1)
 
 
 def test_copy_adjoint(test, device):
@@ -228,10 +283,36 @@ class TestCopy(unittest.TestCase):
     pass
 
 
-add_function_test(TestCopy, "test_copy_strided", test_copy_strided, devices=devices)
-add_function_test(TestCopy, "test_copy_indexed", test_copy_indexed, devices=devices)
-add_function_test(TestCopy, "test_copy_adjoint", test_copy_adjoint, devices=devices)
+for src_device in devices:
+    src_name = "cpu" if src_device.is_cpu else f"cuda{src_device.ordinal}"
+    for dst_device in devices:
+        dst_name = "cpu" if dst_device.is_cpu else f"cuda{dst_device.ordinal}"
+        add_function_test(
+            TestCopy,
+            f"test_copy_strided_{src_name}_{dst_name}",
+            test_copy_strided,
+            devices=None,
+            device1=src_device,
+            device2=dst_device,
+        )
+        add_function_test(
+            TestCopy,
+            f"test_copy_indexed_{src_name}_{dst_name}",
+            test_copy_indexed,
+            devices=None,
+            device1=src_device,
+            device2=dst_device,
+        )
+        add_function_test(
+            TestCopy,
+            f"test_copy_large_stride_{src_name}_{dst_name}",
+            test_copy_large_stride,
+            devices=None,
+            device1=src_device,
+            device2=dst_device,
+        )
 
+add_function_test(TestCopy, "test_copy_adjoint", test_copy_adjoint, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

warp/tests/test_ctypes.py

@@ -107,7 +107,7 @@ def test_transform_multiply(test, device, n):
     wp.launch(transform_multiply, dim=n, inputs=[xforms, a], device=device)
 
 
-transformf = wp.types.transformation(dtype=wp.float32)
+transformf = wp._src.types.transformation(dtype=wp.float32)
 
 
 @wp.kernel
@@ -117,7 +117,7 @@ def test_transformation_constructor():
     c = wp.transform_identity(dtype=wp.float64)
 
 
-spatial_vector = wp.types.vector(length=6, dtype=wp.float32)
+spatial_vector = wp._src.types.vector(length=6, dtype=wp.float32)
 
 
 @wp.kernel
@@ -327,7 +327,7 @@ def test_scalar_array_types_store(
 def test_type_conversions():
     # below tests auto-generated by the following snippet:
 
-    # scalar_types_all = [*wp.types.scalar_types, int, float]
+    # scalar_types_all = [*wp._src.types.scalar_types, int, float]
     # for t in scalar_types_all:
     #     for u in scalar_types_all:
 

warp/tests/test_devices.py

@@ -44,7 +44,7 @@ def test_devices_map_cuda_device(test, device):
         # Map alias twice to check code path
         wp.map_cuda_device("new_alias")
         wp.map_cuda_device("new_alias")
-        wp.context.runtime.rename_device(device, saved_alias)
+        wp._src.context.runtime.rename_device(device, saved_alias)
 
 
 def test_devices_verify_cuda_device(test, device):
@@ -52,7 +52,7 @@ def test_devices_verify_cuda_device(test, device):
 
     wp.config.verify_cuda = True
 
-    wp.context.runtime.verify_cuda_device(device)
+    wp._src.context.runtime.verify_cuda_device(device)
 
     wp.config.verify_cuda = verify_cuda_saved
 
@@ -85,6 +85,28 @@ class TestDevices(unittest.TestCase):
         with self.assertRaises(RuntimeError):
             wp.unmap_cuda_device("imaginary_device:0")
 
+    def test_devices_get_cuda_supported_archs(self):
+        if not wp.is_cuda_available():
+            self.assertEqual(wp.get_cuda_supported_archs(), [], "Should return empty list when CUDA is not available")
+        else:
+            archs = wp.get_cuda_supported_archs()
+            self.assertTrue(len(archs) > 0, "No CUDA supported architectures found")
+
+            # Check all elements are integers
+            for arch in archs:
+                self.assertIsInstance(arch, int, f"Architecture value {arch} should be an integer")
+
+            # Check the list is sorted
+            self.assertEqual(archs, sorted(archs), "Architecture list should be sorted")
+
+            # Check for no duplicates
+            self.assertEqual(len(archs), len(set(archs)), "Architecture list should not contain duplicates")
+
+            # Check values are reasonable (modern CUDA architectures are >= 50)
+            for arch in archs:
+                self.assertGreaterEqual(arch, 50, f"Architecture {arch} should be >= 50 (e.g., sm_50)")
+                self.assertLessEqual(arch, 150, f"Architecture {arch} seems unreasonably high")
+
 
 add_function_test(
     TestDevices,