예제 #1
0
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()
예제 #2
0
class TestGetCurrentDevice(unittest.TestCase):
    def test_get_current_device_type_outside_device_ctxt(self):
        self.assertNotEqual(dpctl.get_current_device_type(), None)

    def test_get_current_device_type_inside_device_ctxt(self):
        self.assertNotEqual(dpctl.get_current_device_type(), None)

        with dpctl.device_context("opencl:gpu:0"):
            self.assertEqual(dpctl.get_current_device_type(),
                             dpctl.device_type.gpu)

        self.assertNotEqual(dpctl.get_current_device_type(), None)

    @unittest.skipUnless(dpctl.has_cpu_queues(),
                         "No OpenCL CPU queues available")
    def test_get_current_device_type_inside_nested_device_ctxt(self):
        self.assertNotEqual(dpctl.get_current_device_type(), None)

        with dpctl.device_context("opencl:cpu:0"):
            self.assertEqual(dpctl.get_current_device_type(),
                             dpctl.device_type.cpu)

            with dpctl.device_context("opencl:gpu:0"):
                self.assertEqual(dpctl.get_current_device_type(),
                                 dpctl.device_type.gpu)
            self.assertEqual(dpctl.get_current_device_type(),
                             dpctl.device_type.cpu)

        self.assertNotEqual(dpctl.get_current_device_type(), None)
예제 #3
0
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")
예제 #4
0
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))
예제 #5
0
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())
예제 #6
0
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)
예제 #7
0
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",
        )