warp-lang 1.10.0__py3-none-macosx_11_0_arm64.whl

warp/tests/cuda/test_ipc.py

@@ -0,0 +1,124 @@
+# 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 multiprocessing as mp
+import unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+def test_ipc_get_memory_handle(test, device):
+    if device.is_ipc_supported is False:
+        test.skipTest(f"IPC is not supported on {device}")
+
+    with wp.ScopedMempool(device, False):
+        test_array = wp.full(10, value=42.0, dtype=wp.float32, device=device)
+        ipc_handle = test_array.ipc_handle()
+
+    test.assertNotEqual(ipc_handle, bytes(64), "IPC memory handle appears to be invalid")
+
+
+def test_ipc_get_event_handle(test, device):
+    if device.is_ipc_supported is False:
+        test.skipTest(f"IPC is not supported on {device}")
+
+    e1 = wp.Event(device, interprocess=True)
+
+    ipc_handle = e1.ipc_handle()
+
+    test.assertNotEqual(ipc_handle, bytes(64), "IPC event handle appears to be invalid")
+
+
+def test_ipc_event_missing_interprocess_flag(test, device):
+    if device.is_ipc_supported is False:
+        test.skipTest(f"IPC is not supported on {device}")
+
+    e1 = wp.Event(device, interprocess=False)
+
+    try:
+        capture = StdOutCapture()
+        capture.begin()
+        ipc_handle = e1.ipc_handle()
+    finally:
+        output = capture.end()
+
+    # Older Windows C runtimes have a bug where stdout sometimes does not get properly flushed.
+    if sys.platform != "win32":
+        test.assertRegex(output, r"Warp UserWarning: IPC event handle appears to be invalid.")
+
+
+@wp.kernel
+def multiply_by_two(a: wp.array(dtype=wp.float32)):
+    i = wp.tid()
+    a[i] = 2.0 * a[i]
+
+
+def child_task(array_handle, dtype, shape, device, event_handle):
+    with wp.ScopedDevice(device):
+        ipc_array = wp.from_ipc_handle(array_handle, dtype, shape, device=device)
+        ipc_event = wp.event_from_ipc_handle(event_handle, device=device)
+        stream = wp.get_stream()
+        wp.launch(multiply_by_two, ipc_array.shape, inputs=[ipc_array])
+        stream.record_event(ipc_event)
+        stream.wait_event(ipc_event)
+        wp.synchronize_device()
+
+
+def test_ipc_multiprocess_write(test, device):
+    if device.is_ipc_supported is False:
+        test.skipTest(f"IPC is not supported on {device}")
+
+    stream = wp.get_stream(device)
+    e1 = wp.Event(device, interprocess=True)
+
+    with wp.ScopedMempool(device, False):
+        test_array = wp.full(1024, value=42.0, dtype=wp.float32, device=device)
+        ipc_handle = test_array.ipc_handle()
+
+    wp.launch(multiply_by_two, test_array.shape, inputs=[test_array], device=device)
+
+    ctx = mp.get_context("spawn")
+
+    process = ctx.Process(
+        target=child_task, args=(ipc_handle, test_array.dtype, test_array.shape, str(device), e1.ipc_handle())
+    )
+
+    process.start()
+    process.join()
+
+    assert_np_equal(test_array.numpy(), np.full(test_array.shape, 168.0, dtype=np.float32))
+
+
+cuda_devices = get_cuda_test_devices()
+
+
+class TestIpc(unittest.TestCase):
+    pass
+
+
+add_function_test(TestIpc, "test_ipc_get_memory_handle", test_ipc_get_memory_handle, devices=cuda_devices)
+add_function_test(TestIpc, "test_ipc_get_event_handle", test_ipc_get_event_handle, devices=cuda_devices)
+add_function_test(
+    TestIpc, "test_ipc_event_missing_interprocess_flag", test_ipc_event_missing_interprocess_flag, devices=cuda_devices
+)
+add_function_test(
+    TestIpc, "test_ipc_multiprocess_write", test_ipc_multiprocess_write, devices=cuda_devices, check_output=False
+)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/cuda/test_mempool.py

@@ -0,0 +1,233 @@
+# 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
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+def get_device_pair_with_mempool_access_support():
+    devices = wp.get_cuda_devices()
+    for target_device in devices:
+        for peer_device in devices:
+            if target_device != peer_device:
+                if wp.is_mempool_access_supported(target_device, peer_device):
+                    return (target_device, peer_device)
+    return None
+
+
+def get_device_pair_without_mempool_access_support():
+    devices = wp.get_cuda_devices()
+    for target_device in devices:
+        for peer_device in devices:
+            if target_device != peer_device:
+                if not wp.is_mempool_access_supported(target_device, peer_device):
+                    return (target_device, peer_device)
+    return None
+
+
+def test_mempool_release_threshold(test, device):
+    device = wp.get_device(device)
+
+    assert device.is_mempool_supported
+
+    test.assertEqual(wp.is_mempool_supported(device), device.is_mempool_supported)
+
+    was_enabled = wp.is_mempool_enabled(device)
+
+    # toggle
+    wp.set_mempool_enabled(device, not was_enabled)
+    test.assertEqual(wp.is_mempool_enabled(device), not was_enabled)
+
+    # restore
+    wp.set_mempool_enabled(device, was_enabled)
+    test.assertEqual(wp.is_mempool_enabled(device), was_enabled)
+
+    saved_threshold = wp.get_mempool_release_threshold(device)
+
+    # set new absolute threshold
+    wp.set_mempool_release_threshold(device, 42000)
+    test.assertEqual(wp.get_mempool_release_threshold(device), 42000)
+
+    # set new fractional threshold
+    wp.set_mempool_release_threshold(device, 0.5)
+    test.assertEqual(wp.get_mempool_release_threshold(device), int(0.5 * device.total_memory))
+
+    # restore threshold
+    wp.set_mempool_release_threshold(device, saved_threshold)
+    test.assertEqual(wp.get_mempool_release_threshold(device), saved_threshold)
+
+
+def test_mempool_usage_queries(test, device):
+    """Check API to query mempool memory usage."""
+
+    device = wp.get_device(device)
+    pre_alloc_mempool_usage_curr = wp.get_mempool_used_mem_current(device)
+    pre_alloc_mempool_usage_high = wp.get_mempool_used_mem_high(device)
+
+    # Allocate a 1 MiB array
+    test_data = wp.empty(262144, dtype=wp.float32, device=device)
+    wp.synchronize_device(device)
+
+    # Query memory usage again
+    post_alloc_mempool_usage_curr = wp.get_mempool_used_mem_current(device)
+    post_alloc_mempool_usage_high = wp.get_mempool_used_mem_high(device)
+
+    test.assertEqual(
+        post_alloc_mempool_usage_curr, pre_alloc_mempool_usage_curr + 1048576, "Memory usage did not increase by 1 MiB"
+    )
+    test.assertGreaterEqual(post_alloc_mempool_usage_high, 1048576, "High-water mark is not at least 1 MiB")
+
+    # Free the allocation
+    del test_data
+    wp.synchronize_device(device)
+
+    # Query memory usage
+    post_free_mempool_usage_curr = wp.get_mempool_used_mem_current(device)
+    post_free_mempool_usage_high = wp.get_mempool_used_mem_high(device)
+
+    test.assertEqual(
+        post_free_mempool_usage_curr,
+        pre_alloc_mempool_usage_curr,
+        "Test didn't end with the same amount of used memory as the test started with.",
+    )
+    test.assertEqual(
+        post_free_mempool_usage_high, post_alloc_mempool_usage_high, "High-water mark should not change after free"
+    )
+
+
+def test_mempool_exceptions(test, device):
+    device = wp.get_device(device)
+
+    assert not device.is_mempool_supported
+
+    if device.is_cuda:
+        expected_error = RuntimeError
+    else:
+        expected_error = ValueError
+
+    with test.assertRaises(expected_error):
+        wp.get_mempool_release_threshold(device)
+
+    with test.assertRaises(expected_error):
+        wp.set_mempool_release_threshold(device, 42000)
+
+
+def test_mempool_access_self(test, device):
+    device = wp.get_device(device)
+
+    assert device.is_mempool_supported
+
+    # setting mempool access to self is a no-op
+    wp.set_mempool_access_enabled(device, device, True)
+    wp.set_mempool_access_enabled(device, device, False)
+
+    # should always be enabled
+    enabled = wp.is_mempool_access_enabled(device, device)
+    test.assertTrue(enabled)
+
+
+@unittest.skipUnless(get_device_pair_with_mempool_access_support(), "Requires devices with mempool access support")
+def test_mempool_access(test, _):
+    target_device, peer_device = get_device_pair_with_mempool_access_support()
+
+    was_enabled = wp.is_mempool_access_enabled(target_device, peer_device)
+
+    if was_enabled:
+        # try disabling
+        wp.set_mempool_access_enabled(target_device, peer_device, False)
+        is_enabled = wp.is_mempool_access_enabled(target_device, peer_device)
+        test.assertFalse(is_enabled)
+
+        # try re-enabling
+        wp.set_mempool_access_enabled(target_device, peer_device, True)
+        is_enabled = wp.is_mempool_access_enabled(target_device, peer_device)
+        test.assertTrue(is_enabled)
+    else:
+        # try enabling
+        wp.set_mempool_access_enabled(target_device, peer_device, True)
+        is_enabled = wp.is_mempool_access_enabled(target_device, peer_device)
+        test.assertTrue(is_enabled)
+
+        # try re-disabling
+        wp.set_mempool_access_enabled(target_device, peer_device, False)
+        is_enabled = wp.is_mempool_access_enabled(target_device, peer_device)
+        test.assertFalse(is_enabled)
+
+
+@unittest.skipUnless(
+    get_device_pair_without_mempool_access_support(), "Requires devices without mempool access support"
+)
+def test_mempool_access_exceptions_unsupported(test, _):
+    # get a CUDA device pair without mempool access support
+    target_device, peer_device = get_device_pair_without_mempool_access_support()
+
+    # querying is ok, but must return False
+    test.assertFalse(wp.is_mempool_access_enabled(target_device, peer_device))
+
+    # enabling should raise RuntimeError
+    with test.assertRaises(RuntimeError):
+        wp.set_mempool_access_enabled(target_device, peer_device, True)
+
+    # disabling should not raise an error
+    wp.set_mempool_access_enabled(target_device, peer_device, False)
+
+
+@unittest.skipUnless(wp.is_cpu_available() and wp.is_cuda_available(), "Requires both CUDA and CPU devices")
+def test_mempool_access_exceptions_cpu(test, _):
+    # querying is ok, but must return False
+    test.assertFalse(wp.is_mempool_access_enabled("cuda:0", "cpu"))
+    test.assertFalse(wp.is_mempool_access_enabled("cpu", "cuda:0"))
+
+    # enabling should raise ValueError
+    with test.assertRaises(ValueError):
+        wp.set_mempool_access_enabled("cpu", "cuda:0", True)
+    with test.assertRaises(ValueError):
+        wp.set_mempool_access_enabled("cuda:0", "cpu", True)
+
+    # disabling should not raise an error
+    wp.set_mempool_access_enabled("cpu", "cuda:0", False)
+    wp.set_mempool_access_enabled("cuda:0", "cpu", False)
+
+
+class TestMempool(unittest.TestCase):
+    pass
+
+
+devices_with_mempools = [d for d in get_test_devices() if d.is_mempool_supported]
+devices_without_mempools = [d for d in get_test_devices() if not d.is_mempool_supported]
+
+# test devices with mempool support
+add_function_test(
+    TestMempool, "test_mempool_release_threshold", test_mempool_release_threshold, devices=devices_with_mempools
+)
+add_function_test(TestMempool, "test_mempool_usage_queries", test_mempool_usage_queries, devices=devices_with_mempools)
+add_function_test(TestMempool, "test_mempool_access_self", test_mempool_access_self, devices=devices_with_mempools)
+
+# test devices without mempool support
+add_function_test(TestMempool, "test_mempool_exceptions", test_mempool_exceptions, devices=devices_without_mempools)
+
+# mempool access tests
+add_function_test(TestMempool, "test_mempool_access", test_mempool_access)
+
+# mempool access exceptions
+add_function_test(TestMempool, "test_mempool_access_exceptions_unsupported", test_mempool_access_exceptions_unsupported)
+add_function_test(TestMempool, "test_mempool_access_exceptions_cpu", test_mempool_access_exceptions_cpu)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/cuda/test_multigpu.py

@@ -0,0 +1,169 @@
+# 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._src.utils import check_p2p
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def inc(a: wp.array(dtype=float)):
+    tid = wp.tid()
+    a[tid] = a[tid] + 1.0
+
+
+@wp.kernel
+def arange(start: int, step: int, a: wp.array(dtype=int)):
+    tid = wp.tid()
+    a[tid] = start + step * tid
+
+
+class TestMultiGPU(unittest.TestCase):
+    @unittest.skipUnless(len(wp.get_cuda_devices()) > 1, "Requires at least two CUDA devices")
+    def test_multigpu_set_device(self):
+        # save default device
+        saved_device = wp.get_device()
+
+        n = 32
+
+        wp.set_device("cuda:0")
+        a0 = wp.empty(n, dtype=int)
+        wp.launch(arange, dim=a0.size, inputs=[0, 1, a0])
+
+        wp.set_device("cuda:1")
+        a1 = wp.empty(n, dtype=int)
+        wp.launch(arange, dim=a1.size, inputs=[0, 1, a1])
+
+        # restore default device
+        wp.set_device(saved_device)
+
+        assert a0.device == "cuda:0"
+        assert a1.device == "cuda:1"
+
+        expected = np.arange(n, dtype=int)
+
+        assert_np_equal(a0.numpy(), expected)
+        assert_np_equal(a1.numpy(), expected)
+
+    @unittest.skipUnless(len(wp.get_cuda_devices()) > 1, "Requires at least two CUDA devices")
+    def test_multigpu_scoped_device(self):
+        n = 32
+
+        with wp.ScopedDevice("cuda:0"):
+            a0 = wp.empty(n, dtype=int)
+            wp.launch(arange, dim=a0.size, inputs=[0, 1, a0])
+
+        with wp.ScopedDevice("cuda:1"):
+            a1 = wp.empty(n, dtype=int)
+            wp.launch(arange, dim=a1.size, inputs=[0, 1, a1])
+
+        assert a0.device == "cuda:0"
+        assert a1.device == "cuda:1"
+
+        expected = np.arange(n, dtype=int)
+
+        assert_np_equal(a0.numpy(), expected)
+        assert_np_equal(a1.numpy(), expected)
+
+    @unittest.skipUnless(len(wp.get_cuda_devices()) > 1, "Requires at least two CUDA devices")
+    def test_multigpu_nesting(self):
+        initial_device = wp.get_device()
+        initial_cuda_device = wp.get_cuda_device()
+
+        with wp.ScopedDevice("cuda:1"):
+            assert wp.get_device() == "cuda:1"
+            assert wp.get_cuda_device() == "cuda:1"
+
+            with wp.ScopedDevice("cuda:0"):
+                assert wp.get_device() == "cuda:0"
+                assert wp.get_cuda_device() == "cuda:0"
+
+                with wp.ScopedDevice("cpu"):
+                    assert wp.get_device() == "cpu"
+                    assert wp.get_cuda_device() == "cuda:0"
+
+                    wp.set_device("cuda:1")
+
+                    assert wp.get_device() == "cuda:1"
+                    assert wp.get_cuda_device() == "cuda:1"
+
+                assert wp.get_device() == "cuda:0"
+                assert wp.get_cuda_device() == "cuda:0"
+
+            assert wp.get_device() == "cuda:1"
+            assert wp.get_cuda_device() == "cuda:1"
+
+        assert wp.get_device() == initial_device
+        assert wp.get_cuda_device() == initial_cuda_device
+
+    @unittest.skipUnless(len(wp.get_cuda_devices()) > 1, "Requires at least two CUDA devices")
+    @unittest.skipUnless(check_p2p(), "Peer-to-Peer transfers not supported")
+    def test_multigpu_pingpong(self):
+        n = 1024 * 1024
+
+        a0 = wp.zeros(n, dtype=float, device="cuda:0")
+        a1 = wp.zeros(n, dtype=float, device="cuda:1")
+
+        iters = 10
+
+        for _ in range(iters):
+            wp.launch(inc, dim=a0.size, inputs=[a0], device=a0.device)
+            wp.synchronize_device(a0.device)
+            wp.copy(a1, a0)
+
+            wp.launch(inc, dim=a1.size, inputs=[a1], device=a1.device)
+            wp.synchronize_device(a1.device)
+            wp.copy(a0, a1)
+
+        expected = np.full(n, iters * 2, dtype=np.float32)
+
+        assert_np_equal(a0.numpy(), expected)
+        assert_np_equal(a1.numpy(), expected)
+
+    @unittest.skipUnless(len(wp.get_cuda_devices()) > 1, "Requires at least two CUDA devices")
+    @unittest.skipUnless(check_p2p(), "Peer-to-Peer transfers not supported")
+    def test_multigpu_pingpong_streams(self):
+        n = 1024 * 1024
+
+        a0 = wp.zeros(n, dtype=float, device="cuda:0")
+        a1 = wp.zeros(n, dtype=float, device="cuda:1")
+
+        stream0 = wp.get_stream("cuda:0")
+        stream1 = wp.get_stream("cuda:1")
+
+        iters = 10
+
+        for _ in range(iters):
+            wp.launch(inc, dim=a0.size, inputs=[a0], stream=stream0)
+            stream1.wait_stream(stream0)
+            wp.copy(a1, a0, stream=stream1)
+
+            wp.launch(inc, dim=a1.size, inputs=[a1], stream=stream1)
+            stream0.wait_stream(stream1)
+            wp.copy(a0, a1, stream=stream0)
+
+        expected = np.full(n, iters * 2, dtype=np.float32)
+
+        assert_np_equal(a0.numpy(), expected)
+        assert_np_equal(a1.numpy(), expected)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2, failfast=False)

warp/tests/cuda/test_peer.py

@@ -0,0 +1,139 @@
+# 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
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+def get_device_pair_with_peer_access_support():
+    devices = wp.get_cuda_devices()
+    for target_device in devices:
+        for peer_device in devices:
+            if target_device != peer_device:
+                if wp.is_peer_access_supported(target_device, peer_device):
+                    return (target_device, peer_device)
+    return None
+
+
+def get_device_pair_without_peer_access_support():
+    devices = wp.get_cuda_devices()
+    for target_device in devices:
+        for peer_device in devices:
+            if target_device != peer_device:
+                if not wp.is_peer_access_supported(target_device, peer_device):
+                    return (target_device, peer_device)
+    return None
+
+
+def test_peer_access_self(test, device):
+    device = wp.get_device(device)
+
+    assert device.is_cuda
+
+    # device can access self
+    can_access = wp.is_peer_access_supported(device, device)
+    test.assertTrue(can_access)
+
+    # setting peer access to self is a no-op
+    wp.set_peer_access_enabled(device, device, True)
+    wp.set_peer_access_enabled(device, device, False)
+
+    # should always be enabled
+    enabled = wp.is_peer_access_enabled(device, device)
+    test.assertTrue(enabled)
+
+
+@unittest.skipUnless(get_device_pair_with_peer_access_support(), "Requires devices with peer access support")
+def test_peer_access(test, _):
+    target_device, peer_device = get_device_pair_with_peer_access_support()
+
+    was_enabled = wp.is_peer_access_enabled(target_device, peer_device)
+
+    if was_enabled:
+        # try disabling
+        wp.set_peer_access_enabled(target_device, peer_device, False)
+        is_enabled = wp.is_peer_access_enabled(target_device, peer_device)
+        test.assertFalse(is_enabled)
+
+        # try re-enabling
+        wp.set_peer_access_enabled(target_device, peer_device, True)
+        is_enabled = wp.is_peer_access_enabled(target_device, peer_device)
+        test.assertTrue(is_enabled)
+    else:
+        # try enabling
+        wp.set_peer_access_enabled(target_device, peer_device, True)
+        is_enabled = wp.is_peer_access_enabled(target_device, peer_device)
+        test.assertTrue(is_enabled)
+
+        # try re-disabling
+        wp.set_peer_access_enabled(target_device, peer_device, False)
+        is_enabled = wp.is_peer_access_enabled(target_device, peer_device)
+        test.assertFalse(is_enabled)
+
+
+@unittest.skipUnless(get_device_pair_without_peer_access_support(), "Requires devices without peer access support")
+def test_peer_access_exceptions_unsupported(test, _):
+    # get a CUDA device pair without peer access support
+    target_device, peer_device = get_device_pair_without_peer_access_support()
+
+    # querying is ok, but must return False
+    test.assertFalse(wp.is_peer_access_enabled(target_device, peer_device))
+
+    # enabling should raise RuntimeError
+    with test.assertRaises(RuntimeError):
+        wp.set_peer_access_enabled(target_device, peer_device, True)
+
+    # disabling should not raise an error
+    wp.set_peer_access_enabled(target_device, peer_device, False)
+
+
+@unittest.skipUnless(wp.is_cpu_available() and wp.is_cuda_available(), "Requires both CUDA and CPU devices")
+def test_peer_access_exceptions_cpu(test, _):
+    # querying is ok, but must return False
+    test.assertFalse(wp.is_peer_access_enabled("cuda:0", "cpu"))
+    test.assertFalse(wp.is_peer_access_enabled("cpu", "cuda:0"))
+
+    # enabling should raise ValueError
+    with test.assertRaises(ValueError):
+        wp.set_peer_access_enabled("cpu", "cuda:0", True)
+    with test.assertRaises(ValueError):
+        wp.set_peer_access_enabled("cuda:0", "cpu", True)
+
+    # disabling should not raise an error
+    wp.set_peer_access_enabled("cpu", "cuda:0", False)
+    wp.set_peer_access_enabled("cuda:0", "cpu", False)
+
+
+class TestPeer(unittest.TestCase):
+    pass
+
+
+cuda_test_devices = get_cuda_test_devices()
+
+add_function_test(TestPeer, "test_peer_access_self", test_peer_access_self, devices=cuda_test_devices)
+
+# peer access tests
+add_function_test(TestPeer, "test_peer_access", test_peer_access)
+
+# peer access exceptions
+add_function_test(TestPeer, "test_peer_access_exceptions_unsupported", test_peer_access_exceptions_unsupported)
+add_function_test(TestPeer, "test_peer_access_exceptions_cpu", test_peer_access_exceptions_cpu)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)