warp-lang 1.10.0__py3-none-macosx_11_0_arm64.whl

warp/tests/test_intersect.py

@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import numpy as np
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def intersect_tri(
+    v0: wp.vec3,
+    v1: wp.vec3,
+    v2: wp.vec3,
+    u0: wp.vec3,
+    u1: wp.vec3,
+    u2: wp.vec3,
+    result_single_precision: wp.array(dtype=int),
+    result_double_precision: wp.array(dtype=int),
+):
+    tid = wp.tid()
+
+    result_single_precision[0] = wp.intersect_tri_tri(v0, v1, v2, u0, u1, u2)
+
+    u0_d = wp.vec3d(u0)
+    u1_d = wp.vec3d(u1)
+    u2_d = wp.vec3d(u2)
+
+    v0_d = wp.vec3d(v0)
+    v1_d = wp.vec3d(v1)
+    v2_d = wp.vec3d(v2)
+
+    result_double_precision[0] = wp.intersect_tri_tri(v0_d, v1_d, v2_d, u0_d, u1_d, u2_d)
+
+
+def test_intersect_tri(test, device):
+    points_intersect = [
+        wp.vec3(0.0, 0.0, 0.0),
+        wp.vec3(1.0, 0.0, 0.0),
+        wp.vec3(0.0, 0.0, 1.0),
+        wp.vec3(0.5, -0.5, 0.0),
+        wp.vec3(0.5, -0.5, 1.0),
+        wp.vec3(0.5, 0.5, 0.0),
+    ]
+
+    points_separated = [
+        wp.vec3(0.0, 0.0, 0.0),
+        wp.vec3(1.0, 0.0, 0.0),
+        wp.vec3(0.0, 0.0, 1.0),
+        wp.vec3(-0.5, -0.5, 0.0),
+        wp.vec3(-0.5, -0.5, 1.0),
+        wp.vec3(-0.5, 0.5, 0.0),
+    ]
+
+    result_single_precision = wp.zeros(1, dtype=int, device=device)
+    result_double_precision = wp.zeros(1, dtype=int, device=device)
+
+    wp.launch(
+        intersect_tri,
+        dim=1,
+        inputs=[*points_intersect, result_single_precision, result_double_precision],
+        device=device,
+    )
+    assert_np_equal(result_single_precision.numpy(), np.array([1]))
+    assert_np_equal(result_double_precision.numpy(), np.array([1]))
+
+    wp.launch(
+        intersect_tri,
+        dim=1,
+        inputs=[*points_separated, result_single_precision, result_double_precision],
+        device=device,
+    )
+    assert_np_equal(result_single_precision.numpy(), np.array([0]))
+    assert_np_equal(result_double_precision.numpy(), np.array([0]))
+
+
+devices = get_test_devices()
+
+
+class TestIntersect(unittest.TestCase):
+    pass
+
+
+add_function_test(TestIntersect, "test_intersect_tri", test_intersect_tri, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2, failfast=False)

warp/tests/test_iter.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def reversed_kernel(
+    start: wp.int32,
+    end: wp.int32,
+    step: wp.int32,
+    out_count: wp.array(dtype=wp.int32),
+    out_values: wp.array(dtype=wp.int32),
+):
+    count = wp.int32(0)
+    for i in reversed(range(start, end, step)):
+        out_values[count] = i
+        count += 1
+
+    out_count[0] = count
+
+
+def test_reversed(test, device):
+    count = wp.empty(1, dtype=wp.int32)
+    values = wp.empty(32, dtype=wp.int32)
+
+    start, end, step = (-2, 8, 3)
+    wp.launch(
+        reversed_kernel,
+        dim=1,
+        inputs=(start, end, step),
+        outputs=(count, values),
+    )
+    expected = tuple(reversed(range(start, end, step)))
+    assert count.numpy()[0] == len(expected)
+    assert_np_equal(values.numpy()[: len(expected)], expected)
+
+    start, end, step = (9, -3, -2)
+    wp.launch(
+        reversed_kernel,
+        dim=1,
+        inputs=(start, end, step),
+        outputs=(count, values),
+    )
+    expected = tuple(reversed(range(start, end, step)))
+    assert count.numpy()[0] == len(expected)
+    assert_np_equal(values.numpy()[: len(expected)], expected)
+
+
+devices = get_test_devices()
+
+
+class TestIter(unittest.TestCase):
+    pass
+
+
+add_function_test(TestIter, "test_reversed", test_reversed, devices=devices)
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_large.py

@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+import unittest
+from typing import Any
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def conditional_sum(result: wp.array(dtype=wp.uint64)):
+    i, j, k = wp.tid()
+
+    if i == 0:
+        wp.atomic_add(result, 0, wp.uint64(1))
+
+
+def test_large_launch_large_kernel(test, device):
+    """Test tid() on kernel launch of 2**33 threads.
+
+    The function conditional sum will add 1 to result for every thread that has an i index of 0.
+    Due to the size of the grid, this test is not run on CPUs
+    """
+    test_result = wp.zeros(shape=(1,), dtype=wp.uint64, device=device)
+
+    large_dim_length = 2**16
+    half_result = large_dim_length * large_dim_length
+
+    wp.launch(kernel=conditional_sum, dim=[2, large_dim_length, large_dim_length], inputs=[test_result], device=device)
+    test.assertEqual(test_result.numpy()[0], half_result)
+
+
+@wp.kernel
+def count_elements(result: wp.array(dtype=wp.uint64)):
+    wp.atomic_add(result, 0, wp.uint64(1))
+
+
+def test_large_launch_max_blocks(test, device):
+    # Loop over 1000x1x1 elements using a grid of 256 threads
+    test_result = wp.zeros(shape=(1,), dtype=wp.uint64, device=device)
+    wp.launch(count_elements, (1000,), inputs=[test_result], max_blocks=1, device=device)
+    test.assertEqual(test_result.numpy()[0], 1000)
+
+    # Loop over 2x10x10 elements using a grid of 256 threads, using the tid() index to count half the elements
+    test_result.zero_()
+    wp.launch(
+        conditional_sum,
+        (
+            2,
+            50,
+            10,
+        ),
+        inputs=[test_result],
+        max_blocks=1,
+        device=device,
+    )
+    test.assertEqual(test_result.numpy()[0], 500)
+
+
+def test_large_launch_very_large_kernel(test, device):
+    """Due to the size of the grid, this test is not run on CPUs"""
+
+    # Dim is chosen to be larger than the maximum CUDA one-dimensional grid size (total threads)
+    dim = (2**31 - 1) * 256 + 1
+    test_result = wp.zeros(shape=(1,), dtype=wp.uint64, device=device)
+    wp.launch(count_elements, (dim,), inputs=[test_result], device=device)
+    test.assertEqual(test_result.numpy()[0], dim)
+
+
+def test_large_arrays_slow(test, device):
+    # The goal of this test is to use arrays just large enough to know
+    # if there's a flaw in handling arrays with more than 2**31-1 elements
+    # Unfortunately, it takes a long time to run so it won't be run automatically
+    # without changes to support how frequently a test may be run
+    total_elements = 2**31 + 8
+
+    # 2-D to 4-D arrays: test zero_, fill_, then zero_ for scalar data types:
+    for total_dims in range(2, 5):
+        dim_x = math.ceil(total_elements ** (1 / total_dims))
+        shape_tuple = tuple([dim_x] * total_dims)
+
+        for wptype in wp._src.types.scalar_types:
+            a1 = wp.zeros(shape_tuple, dtype=wptype, device=device)
+            assert_np_equal(a1.numpy(), np.zeros_like(a1.numpy()))
+
+            a1.fill_(127)
+            assert_np_equal(a1.numpy(), 127 * np.ones_like(a1.numpy()))
+
+            a1.zero_()
+            assert_np_equal(a1.numpy(), np.zeros_like(a1.numpy()))
+
+
+@wp.kernel
+def check_array_equal_value(data: wp.array2d(dtype=Any), expect: Any):
+    i, j = wp.tid()
+    wp.expect_eq(data[i, j], expect)
+
+
+def test_large_arrays_fast(test, device):
+    # A truncated version of test_large_arrays_slow meant to catch basic errors
+
+    # Make is so that a (dim_x, dim_x) array has more than 2**31 elements
+    dim_x = math.ceil(math.sqrt(2**31))
+
+    a1 = wp.zeros((dim_x, dim_x), dtype=wp.int8, device=device)
+    a1.fill_(127)
+
+    wp.launch(check_array_equal_value, a1.shape, inputs=[a1, wp.int8(127)], device=device)
+
+    a1.zero_()
+    wp.launch(check_array_equal_value, a1.shape, inputs=[a1, wp.int8(0)], device=device)
+
+
+def test_large_array_excessive_zeros(test, device):
+    # Tests the allocation of an array with length exceeding 2**31-1 in a dimension
+
+    with test.assertRaisesRegex(
+        ValueError, "Array shapes must not exceed the maximum representable value of a signed 32-bit integer"
+    ):
+        _ = wp.zeros((2**31), dtype=int, device=device)
+
+
+def test_large_array_excessive_numpy(test, device):
+    # Tests the allocation of an array from a numpy array with length exceeding 2**31-1 in a dimension
+
+    large_np_array = np.empty((2**31), dtype=int)
+
+    with test.assertRaisesRegex(
+        ValueError, "Array shapes must not exceed the maximum representable value of a signed 32-bit integer"
+    ):
+        _ = wp.array(large_np_array, device=device)
+
+
+devices = get_test_devices()
+
+
+class TestLarge(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestLarge,
+    "test_large_launch_large_kernel",
+    test_large_launch_large_kernel,
+    devices=get_selected_cuda_test_devices(),
+)
+
+add_function_test(TestLarge, "test_large_launch_max_blocks", test_large_launch_max_blocks, devices=devices)
+add_function_test(
+    TestLarge,
+    "test_large_launch_very_large_kernel",
+    test_large_launch_very_large_kernel,
+    devices=get_selected_cuda_test_devices(),
+)
+
+add_function_test(TestLarge, "test_large_arrays_fast", test_large_arrays_fast, devices=devices)
+add_function_test(TestLarge, "test_large_array_excessive_zeros", test_large_array_excessive_zeros, devices=devices)
+add_function_test(TestLarge, "test_large_array_excessive_numpy", test_large_array_excessive_numpy, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)