bring back has_{cpu|gpu}_queues

Diptorup Deb · Diptorup Deb · commit fb1fbb2d6b67 · 2020-10-03T22:27:14.000-05:00
diff --git a/dpctl/sycl_core.pyx b/dpctl/sycl_core.pyx
@@ -79,6 +79,11 @@ cdef class SyclKernelInvalidRangeError (Exception):
     '''
     pass
 
+cdef class SyclQueueCreationError (Exception):
+    '''This exception is raised when a range that has more than three
+       dimensions or less than one dimension.
+    '''
+    pass
 
 cdef class SyclContext:
 
@@ -479,29 +484,55 @@ cdef class SyclQueue:
 cdef class _SyclRTManager:
     ''' Wrapper for the C API's sycl queue manager interface.
     '''
-    cdef dict _backend_ty_dict
-    cdef dict _device_ty_dict
+    cdef dict _backend_str_ty_dict
+    cdef dict _device_str_ty_dict
+    cdef dict _backend_enum_ty_dict
+    cdef dict _device_enum_ty_dict
 
     def __cinit__ (self):
 
-        self._backend_ty_dict = {
-            "opencl": _backend_type._OPENCL,
-            "level0": _backend_type._LEVEL_ZERO
+        self._backend_str_ty_dict = {
+            "opencl" : _backend_type._OPENCL,
+            "level0" : _backend_type._LEVEL_ZERO,
+        }
+
+        self._device_str_ty_dict = {
+            "gpu" : _device_type._GPU,
+            "cpu" : _device_type._CPU,
+        }
+
+        self._backend_enum_ty_dict = {
+            backend_type.opencl : _backend_type._OPENCL,
+            backend_type.level_zero : _backend_type._LEVEL_ZERO,
         }
 
-        self._device_ty_dict = {
-            "gpu": _device_type._GPU,
-            "cpu": _device_type._CPU,
+        self._device_enum_ty_dict = {
+            device_type.cpu : _device_type._CPU,
+            device_type.gpu : _device_type._GPU,
         }
 
+    cdef _raise_queue_creation_error (self, str be, str dev, int devid, fname):
+        e = SyclQueueCreationError(
+                "Queue creation failed for :", be, dev, devid
+            )
+        e.fname = fname
+        e.code = -1
+        raise e
+
+
     def _set_as_current_queue (self, backend_ty, device_ty, device_id):
         cdef DPPLSyclQueueRef queue_ref
 
         try :
-            beTy = self._backend_ty_dict[backend_ty]
+            beTy = self._backend_str_ty_dict[backend_ty]
             try :
-                devTy = self._device_ty_dict[device_ty]
+                devTy = self._device_str_ty_dict[device_ty]
                 queue_ref = DPPLQueueMgr_PushQueue(beTy, devTy, device_id)
+                if queue_ref is NULL:
+                    self._raise_queue_creation_error(
+                        backend_ty, device_ty, device_id,
+                        "DPPLQueueMgr_PushQueue"
+                    )
                 return SyclQueue._create(queue_ref)
             except KeyError:
                 raise UnsupportedDeviceError("Device can only be gpu or cpu")
@@ -553,17 +584,52 @@ cdef class _SyclRTManager:
     def get_num_queues (self, backend_ty, device_ty):
         cdef size_t num = 0
         try :
-            beTy = self._backend_ty_dict[backend_ty]
+            beTy = self._backend_enum_ty_dict[backend_ty]
             try :
-                devTy = self._device_ty_dict[device_ty]
+                devTy = self._device_enum_ty_dict[device_ty]
                 num = DPPLQueueMgr_GetNumQueues(beTy, devTy)
             except KeyError:
-                print("Device can only be gpu or cpu")
+                raise UnsupportedDeviceError(
+                        "Device can only be device_type.gpu or device_type.cpu"
+                      )
         except KeyError:
-            print("Backend can only be opencl or level-0")
+            raise UnsupportedBackendError(
+                      "Backend can only be backend_type.opencl or "
+                      "backend_type.level_zero"
+                  )
 
         return num
 
+    def has_gpu_queues (self, backend_ty=backend_type.opencl):
+        cdef size_t num = 0
+        try :
+            beTy = self._backend_enum_ty_dict[backend_ty]
+            num = DPPLQueueMgr_GetNumQueues(beTy, _device_type._GPU)
+        except KeyError:
+            raise UnsupportedBackendError(
+                      "Backend can only be backend_type.opencl or "
+                      "backend_type.level_zero"
+                  )
+        if num:
+            return True
+        else:
+            return False
+
+    def has_cpu_queues (self, backend_ty=backend_type.opencl):
+        cdef size_t num = 0
+        try :
+            beTy = self._backend_enum_ty_dict[backend_ty]
+            num = DPPLQueueMgr_GetNumQueues(beTy, _device_type._CPU)
+        except KeyError:
+            raise UnsupportedBackendError(
+                      "Backend can only be backend_type.opencl or "
+                      "backend_type.level_zero"
+                  )
+        if num:
+            return True
+        else:
+            return False
+
     def has_sycl_platforms (self):
         cdef size_t num_platforms = DPPLPlatform_GetNumPlatforms()
         if num_platforms:
@@ -603,6 +669,8 @@ get_current_device_type  = _mgr.get_current_device_type
 get_num_platforms        = _mgr.get_num_platforms
 get_num_activated_queues = _mgr.get_num_activated_queues
 get_num_queues           = _mgr.get_num_queues
+has_cpu_queues           = _mgr.has_cpu_queues
+has_gpu_queues           = _mgr.has_gpu_queues
 has_sycl_platforms       = _mgr.has_sycl_platforms
 set_default_queue        = _mgr.set_default_queue
 is_in_device_context     = _mgr.is_in_device_context
diff --git a/dpctl/tests/test_sycl_kernel_submit.py b/dpctl/tests/test_sycl_kernel_submit.py
@@ -28,9 +28,7 @@
 import dpctl._memory as dpctl_mem
 import numpy as np
 
-@unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                          device_ty="gpu") > 0,
-                     "No OpenCL GPU queues available")
+@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
 class Test1DKernelSubmit (unittest.TestCase):
 
     def test_create_program_from_source (self):
diff --git a/dpctl/tests/test_sycl_program.py b/dpctl/tests/test_sycl_program.py
@@ -27,9 +27,7 @@
 import unittest
 import os
 
-@unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                          device_ty="gpu") > 0,
-                     "No OpenCL GPU queues available")
+@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
 class TestProgramFromOCLSource (unittest.TestCase):
 
     def test_create_program_from_source (self):
@@ -59,9 +57,7 @@ def test_create_program_from_source (self):
             self.assertEqual(axpyKernel.get_num_args(), 4)
 
 
-@unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                          device_ty="gpu") > 0,
-                     "No OpenCL GPU queues available")
+@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
 class TestProgramFromSPRIV (unittest.TestCase):
 
     def test_create_program_from_spirv(self):
diff --git a/dpctl/tests/test_sycl_queue_manager.py b/dpctl/tests/test_sycl_queue_manager.py
@@ -56,19 +56,19 @@ class TestIsInDeviceContext (unittest.TestCase):
     def test_is_in_device_context_outside_device_ctxt (self):
         self.assertFalse(dpctl.is_in_device_context())
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="gpu") > 0,
-                         "No OpenCL GPU queues available")
+    @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.get_num_queues(backend_ty="opencl",
-                                              device_ty="gpu") > 0,
-                         "No OpenCL GPU queues available")
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="cpu") > 0,
-                         "No OpenCL CPU queues available")
+    @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"):
@@ -87,13 +87,15 @@ def test_get_current_device_type_inside_device_ctxt (self):
         self.assertEqual(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.assertEqual(
+                dpctl.get_current_device_type(), dpctl.device_type.gpu
+            )
 
         self.assertEqual(dpctl.get_current_device_type(), None)
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="cpu") > 0,
-                         "No OpenCL CPU queues available")
+    @unittest.skipUnless(
+        dpctl.has_cpu_queues(), "No OpenCL CPU queues available"
+    )
     def test_get_current_device_type_inside_nested_device_ctxt (self):
         self.assertEqual(dpctl.get_current_device_type(), None)
 
@@ -114,12 +116,12 @@ class TestGetCurrentQueueInMultipleThreads (unittest.TestCase):
     def test_num_current_queues_outside_with_clause (self):
         self.assertEqual(dpctl.get_num_activated_queues(), 0)
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="gpu") > 0,
-                         "No OpenCL GPU queues available")
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="cpu") > 0,
-                         "No OpenCL CPU queues available")
+    @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)
@@ -128,12 +130,12 @@ def test_num_current_queues_inside_with_clause (self):
         self.assertEqual(dpctl.get_num_activated_queues(), 0)
 
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="gpu") > 0,
-                         "No OpenCL GPU queues available")
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="cpu") > 0,
-                         "No OpenCL CPU queues available")
+    @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, local
         def SessionThread (self):
diff --git a/dpctl/tests/test_sycl_usm.py b/dpctl/tests/test_sycl_usm.py
@@ -47,9 +47,9 @@ def test_memory_without_context (self):
         # Without context
         self.assertEqual(mobj._usm_type(), 'shared')
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="cpu") > 0,
-                         "No OpenCL CPU queues available")
+    @unittest.skipUnless(
+        dpctl.has_cpu_queues(), "No OpenCL CPU queues available"
+    )
     def test_memory_cpu_context (self):
         mobj = self._create_memory()
 
@@ -67,9 +67,9 @@ def test_memory_cpu_context (self):
             # not in the same SYCL context
             self.assertTrue(usm_type in ['unknown', 'shared'])
 
-    @unittest.skipUnless(dpctl.get_num_queues(backend_ty="opencl",
-                                              device_ty="gpu") > 0,
-                         "No OpenCL GPU queues available")
+    @unittest.skipUnless(
+        dpctl.has_gpu_queues(), "No OpenCL GPU queues available"
+    )
     def test_memory_gpu_context (self):
         mobj = self._create_memory()
 
