class TestGetCurrentQueueInMultipleThreads(unittest.TestCase): def test_num_current_queues_outside_with_clause(self): self.assertEqual(dpctl.get_num_activated_queues(), 0) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_num_current_queues_inside_with_clause(self): with dpctl.device_context("opencl:cpu:0"): self.assertEqual(dpctl.get_num_activated_queues(), 1) with dpctl.device_context("opencl:gpu:0"): self.assertEqual(dpctl.get_num_activated_queues(), 2) self.assertEqual(dpctl.get_num_activated_queues(), 0) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_num_current_queues_inside_threads(self): from threading import Thread def SessionThread(self): self.assertEqual(dpctl.get_num_activated_queues(), 0) with dpctl.device_context("opencl:gpu:0"): self.assertEqual(dpctl.get_num_activated_queues(), 1) Session1 = Thread(target=SessionThread(self)) Session2 = Thread(target=SessionThread(self)) with dpctl.device_context("opencl:cpu:0"): self.assertEqual(dpctl.get_num_activated_queues(), 1) Session1.start() Session2.start()
class TestSyclQueue(unittest.TestCase): @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_queue_not_equals(self): with dpctl.device_context("opencl:gpu") as gpuQ0: with dpctl.device_context("opencl:cpu") as cpuQ: self.assertFalse(cpuQ.equals(gpuQ0)) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") def test_queue_equals(self): with dpctl.device_context("opencl:gpu") as gpuQ0: with dpctl.device_context("opencl:gpu") as gpuQ1: self.assertTrue(gpuQ0.equals(gpuQ1))
def main(): parser = argparse.ArgumentParser(description="Black-Scholes") parser.add_argument("--options", dest="options", type=int, default=10000000) args = parser.parse_args() options = args.options if dpctl.has_gpu_queues(): print("\nScheduling on OpenCL GPU\n") with dpctl.device_context("opencl:gpu") as gpu_queue: run(10) else: print("\nSkip scheduling on OpenCL GPU\n") # if dpctl.has_gpu_queues(dpctl.backend_type.level_zero): # print("\nScheduling on Level Zero GPU\n") # with dpctl.device_context("level0:gpu") as gpu_queue: # run(10) # else: # print("\nSkip scheduling on Level Zero GPU\n") if dpctl.has_cpu_queues(): print("\nScheduling on OpenCL CPU\n") with dpctl.device_context("opencl:cpu") as cpu_queue: run(10) else: print("\nSkip scheduling on OpenCL CPU\n")
class TestIsInDeviceContext(unittest.TestCase): def test_is_in_device_context_outside_device_ctxt(self): self.assertFalse(dpctl.is_in_device_context()) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") def test_is_in_device_context_inside_device_ctxt(self): with dpctl.device_context("opencl:gpu:0"): self.assertTrue(dpctl.is_in_device_context()) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_is_in_device_context_inside_nested_device_ctxt(self): with dpctl.device_context("opencl:cpu:0"): with dpctl.device_context("opencl:gpu:0"): self.assertTrue(dpctl.is_in_device_context()) self.assertTrue(dpctl.is_in_device_context()) self.assertFalse(dpctl.is_in_device_context())
def test_dppy_array_pass(): """Tests if dppy supports passing an array-like object DuckArray that defines `__sycl_usm_array_interface__` to a dppy.kernel """ @dppy.kernel def dppy_f(array_like_obj): i = dppy.get_global_id(0) array_like_obj[i] = 10 global_size = 100 hb = np.arange(0, global_size, dtype="i4") da = DuckUSMArray(hb.shape, dtype=hb.dtype, host_buffer=hb) if dpctl.has_gpu_queues(dpctl.backend_type.level_zero): print("\nScheduling on OpenCL GPU\n") with dpctl.device_context("opencl:gpu") as gpu_queue: dppy_f[global_size, dppy.DEFAULT_LOCAL_SIZE](da) else: print("\nSkip scheduling on OpenCL GPU\n") assert da[0] == 10
# limitations under the License. # # ===-----------------------------------------------------------------------===# # # \file # Defines unit test cases for kernel submission to a sycl::queue. # ===-----------------------------------------------------------------------===# import ctypes import dpctl import unittest import dpctl.memory as dpctl_mem import dpctl.program as dpctl_prog import numpy as np @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") class Test1DKernelSubmit(unittest.TestCase): def test_create_program_from_source(self): oclSrc = " \ kernel void axpy(global int* a, global int* b, global int* c, int d) { \ size_t index = get_global_id(0); \ c[index] = d*a[index] + b[index]; \ }" with dpctl.device_context("opencl:gpu:0"): q = dpctl.get_current_queue() prog = dpctl_prog.create_program_from_source(q, oclSrc) axpyKernel = prog.get_sycl_kernel("axpy") abuf = dpctl_mem.MemoryUSMShared(1024 * np.dtype("i").itemsize) bbuf = dpctl_mem.MemoryUSMShared(1024 * np.dtype("i").itemsize)
class TestMemory(unittest.TestCase): @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_memory_create(self): nbytes = 1024 queue = dpctl.get_current_queue() mobj = MemoryUSMShared(nbytes, queue) self.assertEqual(mobj.nbytes, nbytes) def _create_memory(self): nbytes = 1024 queue = dpctl.get_current_queue() mobj = MemoryUSMShared(nbytes, queue) return mobj @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_memory_without_context(self): mobj = self._create_memory() # Without context self.assertEqual(mobj._usm_type(), "shared") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_memory_cpu_context(self): mobj = self._create_memory() # CPU context with dpctl.device_context("opencl:cpu:0"): # type respective to the context in which # memory was created usm_type = mobj._usm_type() self.assertEqual(usm_type, "shared") current_queue = dpctl.get_current_queue() # type as view from current queue usm_type = mobj._usm_type(current_queue) # type can be unknown if current queue is # not in the same SYCL context self.assertTrue(usm_type in ["unknown", "shared"]) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") def test_memory_gpu_context(self): mobj = self._create_memory() # GPU context with dpctl.device_context("opencl:gpu:0"): usm_type = mobj._usm_type() self.assertEqual(usm_type, "shared") current_queue = dpctl.get_current_queue() usm_type = mobj._usm_type(current_queue) self.assertTrue(usm_type in ["unknown", "shared"]) @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_buffer_protocol(self): mobj = self._create_memory() mv1 = memoryview(mobj) mv2 = memoryview(mobj) self.assertEqual(mv1, mv2)
class TestMemory(unittest.TestCase): @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_memory_create(self): nbytes = 1024 queue = dpctl.get_current_queue() mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue) self.assertEqual(mobj.nbytes, nbytes) self.assertTrue(hasattr(mobj, "__sycl_usm_array_interface__")) @unittest.expectedFailure @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_memory_create_with_np(self): mobj = dpctl.memory.MemoryUSMShared(np.int64(16384)) self.assertTrue(hasattr(mobj, "__sycl_usm_array_interface__")) def _create_memory(self): nbytes = 1024 queue = dpctl.get_current_queue() mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue) return mobj def _create_host_buf(self, nbytes): ba = bytearray(nbytes) for i in range(nbytes): ba[i] = (i % 32) + ord("a") return ba @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_memory_without_context(self): mobj = self._create_memory() # Without context self.assertEqual(mobj.get_usm_type(), "shared") @unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available") def test_memory_cpu_context(self): mobj = self._create_memory() # CPU context with dpctl.device_context("opencl:cpu:0"): # type respective to the context in which # memory was created usm_type = mobj.get_usm_type() self.assertEqual(usm_type, "shared") current_queue = dpctl.get_current_queue() # type as view from current queue usm_type = mobj.get_usm_type(current_queue) # type can be unknown if current queue is # not in the same SYCL context self.assertTrue(usm_type in ["unknown", "shared"]) @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") def test_memory_gpu_context(self): mobj = self._create_memory() # GPU context with dpctl.device_context("opencl:gpu:0"): usm_type = mobj.get_usm_type() self.assertEqual(usm_type, "shared") current_queue = dpctl.get_current_queue() usm_type = mobj.get_usm_type(current_queue) self.assertTrue(usm_type in ["unknown", "shared"]) @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_buffer_protocol(self): mobj = self._create_memory() mv1 = memoryview(mobj) mv2 = memoryview(mobj) self.assertEqual(mv1, mv2) @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_copy_host_roundtrip(self): mobj = self._create_memory() host_src_obj = self._create_host_buf(mobj.nbytes) mobj.copy_from_host(host_src_obj) host_dest_obj = mobj.copy_to_host() del mobj self.assertEqual(host_src_obj, host_dest_obj) @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_zero_copy(self): mobj = self._create_memory() mobj2 = type(mobj)(mobj) self.assertTrue(mobj2.reference_obj is mobj) mobj_data = mobj.__sycl_usm_array_interface__["data"] mobj2_data = mobj2.__sycl_usm_array_interface__["data"] self.assertEqual(mobj_data, mobj2_data) @unittest.skipUnless(dpctl.has_sycl_platforms(), "No SYCL devices except the default host device.") def test_pickling(self): import pickle mobj = self._create_memory() host_src_obj = self._create_host_buf(mobj.nbytes) mobj.copy_from_host(host_src_obj) mobj_reconstructed = pickle.loads(pickle.dumps(mobj)) self.assertEqual(type(mobj), type(mobj_reconstructed), "Pickling should preserve type") self.assertEqual( mobj.tobytes(), mobj_reconstructed.tobytes(), "Pickling should preserve buffer content", ) self.assertNotEqual( mobj._pointer, mobj_reconstructed._pointer, "Pickling/unpickling changes pointer", )
# limitations under the License. # # ===-----------------------------------------------------------------------===# # # \file # Defines unit test cases for the SyclProgram and SyclKernel classes defined # in sycl_core.pyx. # ===-----------------------------------------------------------------------===# import dpctl import dpctl.program as dpctl_prog import unittest import os @unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available") class TestProgramFromOCLSource(unittest.TestCase): def test_create_program_from_source(self): oclSrc = " \ kernel void add(global int* a, global int* b, global int* c) { \ size_t index = get_global_id(0); \ c[index] = a[index] + b[index]; \ } \ kernel void axpy(global int* a, global int* b, global int* c, int d) { \ size_t index = get_global_id(0); \ c[index] = a[index] + d*b[index]; \ }" with dpctl.device_context("opencl:gpu:0"): q = dpctl.get_current_queue() prog = dpctl_prog.create_program_from_source(q, oclSrc) self.assertIsNotNone(prog)