warp-lang 1.10.0__py3-none-macosx_11_0_arm64.whl

warp/tests/test_reload.py

@@ -0,0 +1,303 @@
+# 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 importlib
+import os
+import unittest
+
+import numpy as np
+
+import warp as wp
+
+# dummy modules used for testing reload with dependencies
+import warp.tests.aux_test_dependent as test_dependent
+import warp.tests.aux_test_reference as test_reference
+import warp.tests.aux_test_reference_reference as test_reference_reference
+
+# dummy module used for testing reload
+import warp.tests.aux_test_square as test_square
+from warp.tests.unittest_utils import *
+
+
+def reload_module(module):
+    # Clearing the .pyc file associated with a module is a necessary workaround
+    # for `importlib.reload` to work as expected when run from within Kit.
+    cache_file = importlib.util.cache_from_source(module.__file__)
+    if os.path.exists(cache_file):
+        os.remove(cache_file)
+    importlib.reload(module)
+
+
+def test_redefine(test, device):
+    # --------------------------------------------
+    # first pass
+
+    @wp.kernel
+    def basic(x: wp.array(dtype=float)):
+        tid = wp.tid()
+
+        x[tid] = float(tid) * 1.0
+
+    n = 32
+
+    x = wp.zeros(n, dtype=float, device=device)
+
+    wp.launch(kernel=basic, dim=n, inputs=[x], device=device)
+
+    # --------------------------------------------
+    # redefine kernel, should trigger a recompile
+
+    @wp.kernel
+    def basic(x: wp.array(dtype=float)):
+        tid = wp.tid()
+
+        x[tid] = float(tid) * 2.0
+
+    y = wp.zeros(n, dtype=float, device=device)
+
+    wp.launch(kernel=basic, dim=n, inputs=[y], device=device)
+
+    assert_np_equal(np.arange(0, n, 1), x.numpy())
+    assert_np_equal(np.arange(0, n, 1) * 2.0, y.numpy())
+
+
+def test_redefine_command(test, device):
+    # Test whether executable modules are retained correctly.
+    # A module can have multiple executable versions in use if something
+    # still holds a reference to them.
+
+    @wp.kernel
+    def k(value: int):
+        wp.expect_eq(value, 17)
+
+    # record a command
+    cmd1 = wp.launch(k, dim=1, inputs=[17], device=device, record_cmd=True)
+    cmd1.launch()
+
+    # redefine the kernel, triggering module reload
+    @wp.kernel
+    def k(value: int):
+        wp.expect_eq(value, 42)
+
+    # re-record the command
+    cmd2 = wp.launch(k, dim=1, inputs=[42], device=device, record_cmd=True)
+    cmd2.launch()
+
+    # previous command should still work
+    cmd1.launch()
+
+
+square_two = """import warp as wp
+
+
+@wp.func
+def sqr(x: float):
+    return x * x
+
+
+@wp.kernel
+def kern(expect: float):
+    wp.expect_eq(sqr(2.0), expect)
+
+
+def run(expect, device):
+    wp.launch(kern, dim=1, inputs=[expect], device=device)
+    wp.synchronize_device(device)
+"""
+
+square_four = """import warp as wp
+
+
+@wp.func
+def multiply(x: float):
+    return x * x
+
+
+@wp.kernel
+def kern(expect: float):
+    wp.expect_eq(multiply(4.0), expect)
+
+
+def run(expect, device):
+    wp.launch(kern, dim=1, inputs=[expect], device=device)
+    wp.synchronize_device(device)
+"""
+
+
+def test_reload(test, device):
+    # write out the module python and import it
+    f = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "aux_test_square.py")), "w")
+    f.writelines(square_two)
+    f.flush()
+    f.close()
+
+    reload_module(test_square)
+    test_square.run(expect=4.0, device=device)  # 2*2=4
+
+    f = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "aux_test_square.py")), "w")
+    f.writelines(square_four)
+    f.flush()
+    f.close()
+
+    # reload module, this should trigger all of the funcs / kernels to be updated
+    reload_module(test_square)
+    test_square.run(expect=16.0, device=device)  # 4*4 = 16
+
+
+def test_reload_class(test, device):
+    def test_func():
+        import importlib as imp
+
+        import warp.tests.aux_test_class_kernel
+        from warp.tests.aux_test_class_kernel import ClassKernelTest
+
+        imp.reload(warp.tests.aux_test_class_kernel)
+
+        ctest = ClassKernelTest(device)
+        expected = np.zeros((10, 3, 3), dtype=np.float32)
+        expected[:] = np.eye(3)
+        assert_np_equal(expected, ctest.identities.numpy())
+
+    test_func()
+    test_func()
+
+
+template_ref = """# This file is used to test reloading module references.
+
+import warp as wp
+import warp.tests.aux_test_reference_reference as refref
+
+
+@wp.func
+def magic():
+    return {} * refref.more_magic()
+"""
+
+template_refref = """# This file is used to test reloading module references.
+
+import warp as wp
+
+
+@wp.func
+def more_magic():
+    return {}
+"""
+
+
+def test_reload_references(test, device):
+    path_ref = os.path.abspath(os.path.join(os.path.dirname(__file__), "aux_test_reference.py"))
+    path_refref = os.path.abspath(os.path.join(os.path.dirname(__file__), "aux_test_reference_reference.py"))
+
+    # rewrite both dependency modules and reload them
+    with open(path_ref, "w") as f:
+        f.writelines(template_ref.format(1.0))
+    importlib.reload(test_reference)
+
+    with open(path_refref, "w") as f:
+        f.writelines(template_refref.format(1.0))
+    importlib.reload(test_reference_reference)
+
+    test_dependent.run(expect=1.0, device=device)  # 1 * 1 = 1
+
+    # rewrite and reload the first dependency module
+    with open(path_ref, "w") as f:
+        f.writelines(template_ref.format(2.0))
+    importlib.reload(test_reference)
+
+    test_dependent.run(expect=2.0, device=device)  # 2 * 1 = 1
+
+    # rewrite and reload the second dependency module
+    with open(path_refref, "w") as f:
+        f.writelines(template_refref.format(2.0))
+    importlib.reload(test_reference_reference)
+
+    test_dependent.run(expect=4.0, device=device)  # 2 * 2 = 4
+
+
+def test_graph_launch_after_module_reload(test, device):
+    @wp.kernel
+    def foo(a: wp.array(dtype=int)):
+        a[0] = 42
+
+    with wp.ScopedDevice(device):
+        a = wp.zeros(1, dtype=int)
+
+        # preload module before graph capture
+        wp.load_module(device=device)
+
+        # capture a launch
+        with wp.ScopedCapture(force_module_load=False) as capture:
+            wp.launch(foo, dim=1, inputs=[a])
+
+        # unload the module
+        foo.module.unload()
+
+        # launch previously captured graph
+        wp.capture_launch(capture.graph)
+
+        test.assertEqual(a.numpy()[0], 42)
+
+
+def test_module_unload_during_graph_capture(test, device):
+    @wp.kernel
+    def foo(a: wp.array(dtype=int)):
+        a[0] = 42
+
+    # preload module before graph capture
+    wp.load_module(device=device)
+
+    # load another module to test unloading during graph capture
+    other_module = wp.get_module("warp.tests.aux_test_module_unload")
+    other_module.load(device)
+
+    with wp.ScopedDevice(device):
+        a = wp.zeros(1, dtype=int)
+
+        with wp.ScopedCapture(force_module_load=False) as capture:
+            wp.launch(foo, dim=1, inputs=[a])
+
+            # unloading a module during graph capture should be fine (deferred until capture completes)
+            other_module.unload()
+
+        wp.capture_launch(capture.graph)
+
+        test.assertEqual(a.numpy()[0], 42)
+
+
+devices = get_test_devices()
+cuda_devices = get_cuda_test_devices()
+
+
+class TestReload(unittest.TestCase):
+    pass
+
+
+add_function_test(TestReload, "test_redefine", test_redefine, devices=devices)
+add_function_test(TestReload, "test_redefine_command", test_redefine_command, devices=devices)
+add_function_test(TestReload, "test_reload", test_reload, devices=devices)
+add_function_test(TestReload, "test_reload_class", test_reload_class, devices=devices)
+# TODO: test_reload_references sometimes has issues running on cuda:1
+add_function_test(TestReload, "test_reload_references", test_reload_references, devices=get_test_devices("basic"))
+add_function_test(
+    TestReload, "test_graph_launch_after_module_reload", test_graph_launch_after_module_reload, devices=cuda_devices
+)
+add_function_test(
+    TestReload, "test_module_unload_during_graph_capture", test_module_unload_during_graph_capture, devices=cuda_devices
+)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2, failfast=False)

warp/tests/test_rounding.py

@@ -0,0 +1,157 @@
+# 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 *
+
+compare_to_numpy = False
+print_results = False
+
+
+@wp.kernel
+def test_kernel(
+    x: wp.array(dtype=float),
+    x_round: wp.array(dtype=float),
+    x_rint: wp.array(dtype=float),
+    x_trunc: wp.array(dtype=float),
+    x_cast: wp.array(dtype=float),
+    x_floor: wp.array(dtype=float),
+    x_ceil: wp.array(dtype=float),
+    x_frac: wp.array(dtype=float),
+):
+    tid = wp.tid()
+
+    x_round[tid] = wp.round(x[tid])
+    x_rint[tid] = wp.rint(x[tid])
+    x_trunc[tid] = wp.trunc(x[tid])
+    x_cast[tid] = float(int(x[tid]))
+    x_floor[tid] = wp.floor(x[tid])
+    x_ceil[tid] = wp.ceil(x[tid])
+    x_frac[tid] = wp.frac(x[tid])
+
+
+def test_rounding(test, device):
+    # fmt: off
+    nx = np.array([
+        4.9,  4.5,  4.1,  3.9,  3.5,  3.1,  2.9,  2.5,  2.1,  1.9,
+        1.5,  1.1,  0.9,  0.5,  0.1, -0.1, -0.5, -0.9, -1.1, -1.5,
+       -1.9, -2.1, -2.5, -2.9, -3.1, -3.5, -3.9, -4.1, -4.5, -4.9
+    ], dtype=np.float32)
+    # fmt: on
+
+    x = wp.array(nx, device=device)
+    N = len(x)
+
+    x_round = wp.empty(N, dtype=float, device=device)
+    x_rint = wp.empty(N, dtype=float, device=device)
+    x_trunc = wp.empty(N, dtype=float, device=device)
+    x_cast = wp.empty(N, dtype=float, device=device)
+    x_floor = wp.empty(N, dtype=float, device=device)
+    x_ceil = wp.empty(N, dtype=float, device=device)
+    x_frac = wp.empty(N, dtype=float, device=device)
+
+    wp.launch(
+        kernel=test_kernel, dim=N, inputs=[x, x_round, x_rint, x_trunc, x_cast, x_floor, x_ceil, x_frac], device=device
+    )
+
+    wp.synchronize()
+
+    nx_round = x_round.numpy().reshape(N)
+    nx_rint = x_rint.numpy().reshape(N)
+    nx_trunc = x_trunc.numpy().reshape(N)
+    nx_cast = x_cast.numpy().reshape(N)
+    nx_floor = x_floor.numpy().reshape(N)
+    nx_ceil = x_ceil.numpy().reshape(N)
+    nx_frac = x_frac.numpy().reshape(N)
+
+    tab = np.stack([nx, nx_round, nx_rint, nx_trunc, nx_cast, nx_floor, nx_ceil, nx_frac], axis=1)
+
+    golden = np.array(
+        [
+            [4.9, 5.0, 5.0, 4.0, 4.0, 4.0, 5.0, 0.9],
+            [4.5, 5.0, 4.0, 4.0, 4.0, 4.0, 5.0, 0.5],
+            [4.1, 4.0, 4.0, 4.0, 4.0, 4.0, 5.0, 0.1],
+            [3.9, 4.0, 4.0, 3.0, 3.0, 3.0, 4.0, 0.9],
+            [3.5, 4.0, 4.0, 3.0, 3.0, 3.0, 4.0, 0.5],
+            [3.1, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 0.1],
+            [2.9, 3.0, 3.0, 2.0, 2.0, 2.0, 3.0, 0.9],
+            [2.5, 3.0, 2.0, 2.0, 2.0, 2.0, 3.0, 0.5],
+            [2.1, 2.0, 2.0, 2.0, 2.0, 2.0, 3.0, 0.1],
+            [1.9, 2.0, 2.0, 1.0, 1.0, 1.0, 2.0, 0.9],
+            [1.5, 2.0, 2.0, 1.0, 1.0, 1.0, 2.0, 0.5],
+            [1.1, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 0.1],
+            [0.9, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.9],
+            [0.5, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.5],
+            [0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.1],
+            [-0.1, -0.0, -0.0, -0.0, 0.0, -1.0, -0.0, -0.1],
+            [-0.5, -1.0, -0.0, -0.0, 0.0, -1.0, -0.0, -0.5],
+            [-0.9, -1.0, -1.0, -0.0, 0.0, -1.0, -0.0, -0.9],
+            [-1.1, -1.0, -1.0, -1.0, -1.0, -2.0, -1.0, -0.1],
+            [-1.5, -2.0, -2.0, -1.0, -1.0, -2.0, -1.0, -0.5],
+            [-1.9, -2.0, -2.0, -1.0, -1.0, -2.0, -1.0, -0.9],
+            [-2.1, -2.0, -2.0, -2.0, -2.0, -3.0, -2.0, -0.1],
+            [-2.5, -3.0, -2.0, -2.0, -2.0, -3.0, -2.0, -0.5],
+            [-2.9, -3.0, -3.0, -2.0, -2.0, -3.0, -2.0, -0.9],
+            [-3.1, -3.0, -3.0, -3.0, -3.0, -4.0, -3.0, -0.1],
+            [-3.5, -4.0, -4.0, -3.0, -3.0, -4.0, -3.0, -0.5],
+            [-3.9, -4.0, -4.0, -3.0, -3.0, -4.0, -3.0, -0.9],
+            [-4.1, -4.0, -4.0, -4.0, -4.0, -5.0, -4.0, -0.1],
+            [-4.5, -5.0, -4.0, -4.0, -4.0, -5.0, -4.0, -0.5],
+            [-4.9, -5.0, -5.0, -4.0, -4.0, -5.0, -4.0, -0.9],
+        ],
+        dtype=np.float32,
+    )
+
+    assert_np_equal(tab, golden, tol=1e-6)
+
+    if print_results:
+        np.set_printoptions(formatter={"float": lambda x: f"{x:6.1f}".replace(".0", ".")})
+
+        print("----------------------------------------------")
+        print(f"   {'x ':>5s} {'round':>5s} {'rint':>5s} {'trunc':>5s} {'cast':>5s} {'floor':>5s} {'ceil':>5s}")
+        print(tab)
+        print("----------------------------------------------")
+
+    if compare_to_numpy:
+        nx_round = np.round(nx)
+        nx_rint = np.rint(nx)
+        nx_trunc = np.trunc(nx)
+        nx_fix = np.fix(nx)
+        nx_floor = np.floor(nx)
+        nx_ceil = np.ceil(nx)
+        nx_frac = np.modf(nx)[0]
+
+        tab = np.stack([nx, nx_round, nx_rint, nx_trunc, nx_fix, nx_floor, nx_ceil, nx_frac], axis=1)
+        print(f"   {'x ':>5s} {'round':>5s} {'rint':>5s} {'trunc':>5s} {'fix':>5s} {'floor':>5s} {'ceil':>5s}")
+        print(tab)
+        print("----------------------------------------------")
+
+
+class TestRounding(unittest.TestCase):
+    pass
+
+
+devices = get_test_devices()
+
+add_function_test(TestRounding, "test_rounding", test_rounding, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_runlength_encode.py

@@ -0,0 +1,196 @@
+# 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 unittest
+from functools import partial
+
+import numpy as np
+
+import warp as wp
+from warp._src.utils import runlength_encode
+from warp.tests.unittest_utils import *
+
+
+def test_runlength_encode_int(test, device, n):
+    rng = np.random.default_rng(123)
+
+    values_np = np.sort(rng.integers(-10, high=10, size=n, dtype=int))
+
+    unique_values_np, unique_counts_np = np.unique(values_np, return_counts=True)
+
+    values = wp.array(values_np, device=device, dtype=int)
+
+    unique_values = wp.empty_like(values)
+    unique_counts = wp.empty_like(values)
+
+    run_count = runlength_encode(values, unique_values, unique_counts)
+
+    test.assertEqual(run_count, len(unique_values_np))
+    assert_np_equal(unique_values.numpy()[:run_count], unique_values_np[:run_count])
+    assert_np_equal(unique_counts.numpy()[:run_count], unique_counts_np[:run_count])
+
+
+def test_runlength_encode_error_insufficient_storage(test, device):
+    values = wp.zeros(123, dtype=int, device=device)
+    run_values = wp.empty(1, dtype=int, device=device)
+    run_lengths = wp.empty(123, dtype=int, device=device)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Output array storage sizes must be at least equal to value_count \(123\)$",
+    ):
+        runlength_encode(values, run_values, run_lengths)
+
+    values = wp.zeros(123, dtype=int, device="cpu")
+    run_values = wp.empty(123, dtype=int, device="cpu")
+    run_lengths = wp.empty(1, dtype=int, device="cpu")
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Output array storage sizes must be at least equal to value_count \(123\)$",
+    ):
+        runlength_encode(values, run_values, run_lengths)
+
+
+def test_runlength_encode_error_dtypes_mismatch(test, device):
+    values = wp.zeros(123, dtype=int, device=device)
+    run_values = wp.empty(123, dtype=float, device=device)
+    run_lengths = wp.empty_like(values, device=device)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"values and run_values data types do not match \(int32 vs float32\)$",
+    ):
+        runlength_encode(values, run_values, run_lengths)
+
+
+def test_runlength_encode_error_run_length_unsupported_dtype(test, device):
+    values = wp.zeros(123, dtype=int, device=device)
+    run_values = wp.empty(123, dtype=int, device=device)
+    run_lengths = wp.empty(123, dtype=float, device=device)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"run_lengths array must be of type int32$",
+    ):
+        runlength_encode(values, run_values, run_lengths)
+
+
+def test_runlength_encode_error_run_count_unsupported_dtype(test, device):
+    values = wp.zeros(123, dtype=int, device=device)
+    run_values = wp.empty_like(values, device=device)
+    run_lengths = wp.empty_like(values, device=device)
+    run_count = wp.empty(shape=(1,), dtype=float, device=device)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"run_count array must be of type int32$",
+    ):
+        runlength_encode(values, run_values, run_lengths, run_count=run_count)
+
+
+def test_runlength_encode_error_unsupported_dtype(test, device):
+    values = wp.zeros(123, dtype=float, device=device)
+    run_values = wp.empty(123, dtype=float, device=device)
+    run_lengths = wp.empty(123, dtype=int, device=device)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Unsupported data type: float32$",
+    ):
+        runlength_encode(values, run_values, run_lengths)
+
+
+devices = get_test_devices()
+
+
+class TestRunlengthEncode(unittest.TestCase):
+    @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
+    def test_runlength_encode_error_devices_mismatch(self):
+        values = wp.zeros(123, dtype=int, device="cpu")
+        run_values = wp.empty_like(values, device="cuda:0")
+        run_lengths = wp.empty_like(values, device="cuda:0")
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"run_values, run_lengths and values storage devices do not match$",
+        ):
+            runlength_encode(values, run_values, run_lengths)
+
+        values = wp.zeros(123, dtype=int, device="cpu")
+        run_values = wp.empty_like(values, device="cpu")
+        run_lengths = wp.empty_like(values, device="cuda:0")
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"run_values, run_lengths and values storage devices do not match$",
+        ):
+            runlength_encode(values, run_values, run_lengths)
+
+        values = wp.zeros(123, dtype=int, device="cpu")
+        run_values = wp.empty_like(values, device="cuda:0")
+        run_lengths = wp.empty_like(values, device="cpu")
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"run_values, run_lengths and values storage devices do not match$",
+        ):
+            runlength_encode(values, run_values, run_lengths)
+
+    @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
+    def test_runlength_encode_error_run_count_device_mismatch(self):
+        values = wp.zeros(123, dtype=int, device="cpu")
+        run_values = wp.empty_like(values, device="cpu")
+        run_lengths = wp.empty_like(values, device="cpu")
+        run_count = wp.empty(shape=(1,), dtype=int, device="cuda:0")
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"run_count storage device does not match other arrays$",
+        ):
+            runlength_encode(values, run_values, run_lengths, run_count=run_count)
+
+
+add_function_test(
+    TestRunlengthEncode, "test_runlength_encode_int", partial(test_runlength_encode_int, n=100), devices=devices
+)
+add_function_test(
+    TestRunlengthEncode, "test_runlength_encode_empty", partial(test_runlength_encode_int, n=0), devices=devices
+)
+add_function_test(
+    TestRunlengthEncode,
+    "test_runlength_encode_error_insufficient_storage",
+    test_runlength_encode_error_insufficient_storage,
+    devices=devices,
+)
+add_function_test(
+    TestRunlengthEncode,
+    "test_runlength_encode_error_dtypes_mismatch",
+    test_runlength_encode_error_dtypes_mismatch,
+    devices=devices,
+)
+add_function_test(
+    TestRunlengthEncode,
+    "test_runlength_encode_error_run_length_unsupported_dtype",
+    test_runlength_encode_error_run_length_unsupported_dtype,
+    devices=devices,
+)
+add_function_test(
+    TestRunlengthEncode,
+    "test_runlength_encode_error_run_count_unsupported_dtype",
+    test_runlength_encode_error_run_count_unsupported_dtype,
+    devices=devices,
+)
+add_function_test(
+    TestRunlengthEncode,
+    "test_runlength_encode_error_unsupported_dtype",
+    test_runlength_encode_error_unsupported_dtype,
+    devices=devices,
+)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)