Add get_devices method to dpctl.SyclPlatform class

dpctl/_backend.pxd

@@ -313,6 +313,8 @@ cdef extern from "syclinterface/dpctl_sycl_platform_interface.h":
     cdef DPCTLPlatformVectorRef DPCTLPlatform_GetPlatforms()
     cdef DPCTLSyclContextRef DPCTLPlatform_GetDefaultContext(
         const DPCTLSyclPlatformRef)
+    cdef DPCTLDeviceVectorRef DPCTLPlatform_GetDevices(
+        const DPCTLSyclPlatformRef PRef, _device_type DTy)
 
 
 cdef extern from "syclinterface/dpctl_sycl_context_interface.h":

dpctl/_sycl_device_factory.pyx

@@ -154,15 +154,15 @@ cpdef list get_devices(backend=backend_type.all, device_type=device_type_t.all):
     ``backend`` in addition to only ``device_type``.
 
     Args:
-        backend (optional):
+        backend (str, :class:`dpctl.backend_type`, optional):
             A :class:`dpctl.backend_type` enum value or a string that
             specifies a SYCL backend. Currently, accepted values are: "cuda",
             "hip", "opencl", "level_zero", or "all".
             Default: ``dpctl.backend_type.all``.
-        device_type (optional):
+        device_type (str, :class:`dpctl.device_type`, optional):
             A :class:`dpctl.device_type` enum value or a string that
             specifies a SYCL device type. Currently, accepted values are:
-            "gpu", "cpu", "accelerator", "host", or "all".
+            "gpu", "cpu", "accelerator", or "all".
             Default: ``dpctl.device_type.all``.
     Returns:
         list:
@@ -210,15 +210,15 @@ cpdef int get_num_devices(
     :class:`dpctl.device_type` and :class:`dpctl.backend_type`.
 
     Args:
-        backend (optional):
+        backend (str, :class:`dpctl.backend_type`, optional):
             A :class:`dpctl.backend_type` enum value or a string that
             specifies a SYCL backend. Currently, accepted values are: "cuda",
             "hip", "opencl", "level_zero", or "all".
             Default: ``dpctl.backend_type.all``.
-        device_type (optional):
+        device_type (str, :class:`dpctl.device_type`, optional):
             A :class:`dpctl.device_type` enum value or a string that
             specifies a SYCL device type. Currently, accepted values are:
-            "gpu", "cpu", "accelerator", "host", or "all".
+            "gpu", "cpu", "accelerator", or "all".
             Default: ``dpctl.device_type.all``.
     Returns:
         int:

dpctl/_sycl_platform.pyx

@@ -26,6 +26,10 @@ from libcpp cimport bool
 from ._backend cimport (  # noqa: E211
     DPCTLCString_Delete,
     DPCTLDeviceSelector_Delete,
+    DPCTLDeviceVector_Delete,
+    DPCTLDeviceVector_GetAt,
+    DPCTLDeviceVector_Size,
+    DPCTLDeviceVectorRef,
     DPCTLFilterSelector_Create,
     DPCTLPlatform_AreEq,
     DPCTLPlatform_Copy,
@@ -34,6 +38,7 @@ from ._backend cimport (  # noqa: E211
     DPCTLPlatform_Delete,
     DPCTLPlatform_GetBackend,
     DPCTLPlatform_GetDefaultContext,
+    DPCTLPlatform_GetDevices,
     DPCTLPlatform_GetName,
     DPCTLPlatform_GetPlatforms,
     DPCTLPlatform_GetVendor,
@@ -46,17 +51,21 @@ from ._backend cimport (  # noqa: E211
     DPCTLPlatformVector_Size,
     DPCTLPlatformVectorRef,
     DPCTLSyclContextRef,
+    DPCTLSyclDeviceRef,
     DPCTLSyclDeviceSelectorRef,
     DPCTLSyclPlatformRef,
     _backend_type,
+    _device_type,
 )
 
 import warnings
 
 from ._sycl_context import SyclContextCreationError
 from .enum_types import backend_type
+from .enum_types import device_type as device_type_t
 
 from ._sycl_context cimport SyclContext
+from ._sycl_device cimport SyclDevice
 
 __all__ = [
     "get_platforms",
@@ -366,6 +375,79 @@ cdef class SyclPlatform(_SyclPlatform):
         """
         return DPCTLPlatform_Hash(self._platform_ref)
 
+    def get_devices(self, device_type=device_type_t.all):
+        """
+        Returns the list of :class:`dpctl.SyclDevice` objects associated with
+        :class:`dpctl.SyclPlatform` instance selected based on
+        the given :class:`dpctl.device_type`.
+
+        Args:
+            device_type (str, :class:`dpctl.device_type`, optional):
+                A :class:`dpctl.device_type` enum value or a string that
+                specifies a SYCL device type. Currently, accepted values are:
+                "gpu", "cpu", "accelerator", or "all", and their equivalent
+                ``dpctl.device_type`` enumerators.
+                Default: ``dpctl.device_type.all``.
+
+        Returns:
+            list:
+                A :obj:`list` of :class:`dpctl.SyclDevice` objects
+                that belong to this platform.
+
+        Raises:
+            TypeError:
+                If `device_type` is not a string or :class:`dpctl.device_type`
+                enum.
+            ValueError:
+                If the ``DPCTLPlatform_GetDevices`` call returned
+                ``NULL`` instead of a ``DPCTLDeviceVectorRef`` object.
+        """
+        cdef _device_type DTy = _device_type._ALL_DEVICES
+        cdef DPCTLDeviceVectorRef DVRef = NULL
+        cdef size_t num_devs
+        cdef size_t i
+        cdef DPCTLSyclDeviceRef DRef
+
+        if isinstance(device_type, str):
+            dty_str = device_type.strip().lower()
+            if dty_str == "accelerator":
+                DTy = _device_type._ACCELERATOR
+            elif dty_str == "all":
+                DTy = _device_type._ALL_DEVICES
+            elif dty_str == "cpu":
+                DTy = _device_type._CPU
+            elif dty_str == "gpu":
+                DTy = _device_type._GPU
+            else:
+                DTy = _device_type._UNKNOWN_DEVICE
+        elif isinstance(device_type, device_type_t):
+            if device_type == device_type_t.all:
+                DTy = _device_type._ALL_DEVICES
+            elif device_type == device_type_t.accelerator:
+                DTy = _device_type._ACCELERATOR
+            elif device_type == device_type_t.cpu:
+                DTy = _device_type._CPU
+            elif device_type == device_type_t.gpu:
+                DTy = _device_type._GPU
+            else:
+                DTy = _device_type._UNKNOWN_DEVICE
+        else:
+            raise TypeError(
+                "device type should be specified as a str or an "
+                "``enum_types.device_type``."
+            )
+        DVRef = DPCTLPlatform_GetDevices(self.get_platform_ref(), DTy)
+        if (DVRef is NULL):
+            raise ValueError("Internal error: NULL device vector encountered")
+        num_devs = DPCTLDeviceVector_Size(DVRef)
+        devices = []
+        for i in range(num_devs):
+            DRef = DPCTLDeviceVector_GetAt(DVRef, i)
+            devices.append(SyclDevice._create(DRef))
+        DPCTLDeviceVector_Delete(DVRef)
+
+        return devices
+
 
 def lsplatform(verbosity=0):
     """

dpctl/tests/test_sycl_device_factory.py

@@ -51,8 +51,6 @@ def string_to_device_type(dty_str):
         return dty.accelerator
     elif dty_str == "cpu":
         return dty.cpu
-    elif dty_str == "host":
-        return dty.host
     elif dty_str == "gpu":
         return dty.gpu
 
@@ -62,8 +60,6 @@ def string_to_backend_type(bty_str):
         return bty.cuda
     elif bty_str == "hip":
         return bty.hip
-    elif bty_str == "host":
-        return bty.host
     elif bty_str == "level_zero":
         return bty.level_zero
     elif bty_str == "opencl":

dpctl/tests/test_sycl_platform.py

@@ -22,6 +22,7 @@
 import pytest
 
 import dpctl
+from dpctl import device_type
 
 from .helper import has_sycl_platforms
 
@@ -212,3 +213,49 @@ def test_get_platforms():
             assert has_sycl_platforms()
     except Exception:
         pytest.fail("Encountered an exception inside get_platforms().")
+
+
+def test_platform_get_devices():
+    platforms = dpctl.get_platforms()
+    if platforms:
+        for p in platforms:
+            assert len(p.get_devices())
+    else:
+        pytest.skip("No platforms available")
+
+
+def _str_device_type_to_enum(dty):
+    if dty == "accelerator":
+        return device_type.accelerator
+    elif dty == "cpu":
+        return device_type.cpu
+    elif dty == "gpu":
+        return device_type.gpu
+
+
+def test_platform_get_devices_str_device_type():
+    platforms = dpctl.get_platforms()
+    dtys = ["accelerator", "all", "cpu", "gpu"]
+    if platforms:
+        for p in platforms:
+            for dty in dtys:
+                devices = p.get_devices(device_type=dty)
+                if len(devices):
+                    dty_enum = _str_device_type_to_enum(dty)
+                    assert (d.device_type == dty_enum for d in devices)
+
+
+def test_platform_get_devices_enum_device_type():
+    platforms = dpctl.get_platforms()
+    dtys = [
+        device_type.accelerator,
+        device_type.all,
+        device_type.cpu,
+        device_type.gpu,
+    ]
+    if platforms:
+        for p in platforms:
+            for dty in dtys:
+                devices = p.get_devices(device_type=dty)
+                if len(devices):
+                    assert (d.device_type == dty for d in devices)

libsyclinterface/helper/source/dpctl_utils_helper.cpp

@@ -73,9 +73,6 @@ info::device_type DPCTL_StrToDeviceType(const std::string &devTyStr)
     else if (devTyStr == "custom") {
         devTy = info::device_type::custom;
     }
-    else if (devTyStr == "host") {
-        devTy = info::device_type::host;
-    }
     else {
         // \todo handle the error
         throw std::runtime_error("Unknown device type.");

libsyclinterface/include/syclinterface/dpctl_sycl_device_manager.h

@@ -145,7 +145,7 @@ DPCTL_API
 size_t DPCTLDeviceMgr_GetNumDevices(int device_identifier);
 
 /*!
- * @brief Prints out the info::deivice attributes for the device that are
+ * @brief Prints out the info::device attributes for the device that are
  * currently supported by dpctl.
  *
  * @param    DRef           A #DPCTLSyclDeviceRef opaque pointer.

libsyclinterface/include/syclinterface/dpctl_sycl_platform_interface.h

@@ -29,6 +29,7 @@
 #include "Support/ExternC.h"
 #include "Support/MemOwnershipAttrs.h"
 #include "dpctl_data_types.h"
+#include "dpctl_sycl_device_manager.h"
 #include "dpctl_sycl_enum_types.h"
 #include "dpctl_sycl_platform_manager.h"
 #include "dpctl_sycl_types.h"
@@ -176,6 +177,20 @@ DPCTLPlatform_GetDefaultContext(__dpctl_keep const DPCTLSyclPlatformRef PRef);
  * @ingroup PlatformInterface
  */
 DPCTL_API
-size_t DPCTLPlatform_Hash(__dpctl_keep DPCTLSyclPlatformRef PRef);
+size_t DPCTLPlatform_Hash(__dpctl_keep const DPCTLSyclPlatformRef PRef);
+
+/*!
+ * @brief Returns a vector of devices associated with sycl::platform referenced
+ * by DPCTLSyclPlatformRef object.
+ *
+ * @param    PRef           The DPCTLSyclPlatformRef pointer.
+ * @param    DTy            A DPCTLSyclDeviceType enum value.
+ * @return   A DPCTLDeviceVectorRef with devices associated with given PRef.
+ * @ingroup PlatformInterface
+ */
+DPCTL_API
+__dpctl_give DPCTLDeviceVectorRef
+DPCTLPlatform_GetDevices(__dpctl_keep const DPCTLSyclPlatformRef PRef,
+                         DPCTLSyclDeviceType DTy);
 
 DPCTL_C_EXTERN_C_END

libsyclinterface/source/dpctl_sycl_platform_interface.cpp

@@ -29,6 +29,7 @@
 #include "dpctl_device_selection.hpp"
 #include "dpctl_error_handlers.h"
 #include "dpctl_string_utils.hpp"
+#include "dpctl_sycl_enum_types.h"
 #include "dpctl_sycl_type_casters.hpp"
 #include "dpctl_utils_helper.h"
 #include <iomanip>
@@ -269,3 +270,49 @@ size_t DPCTLPlatform_Hash(__dpctl_keep const DPCTLSyclPlatformRef PRef)
         return 0;
     }
 }
+
+__dpctl_give DPCTLDeviceVectorRef
+DPCTLPlatform_GetDevices(__dpctl_keep const DPCTLSyclPlatformRef PRef,
+                         DPCTLSyclDeviceType DTy)
+{
+    auto P = unwrap<platform>(PRef);
+    if (!P) {
+        error_handler("Cannot retrieve devices from DPCTLSyclPlatformRef as "
+                      "input is a nullptr.",
+                      __FILE__, __func__, __LINE__);
+        return nullptr;
+    }
+
+    using vecTy = std::vector<DPCTLSyclDeviceRef>;
+    vecTy *DevicesVectorPtr = nullptr;
+    try {
+        DevicesVectorPtr = new vecTy();
+    } catch (std::exception const &e) {
+        delete DevicesVectorPtr;
+        error_handler(e, __FILE__, __func__, __LINE__);
+        return nullptr;
+    }
+
+    // handle unknown device
+    // custom and automatic are also treated as unknown
+    // as DPC++ would normally treat as `all`
+    // see CMPLRLLVM-65826
+    if (DTy == DPCTLSyclDeviceType::DPCTL_UNKNOWN_DEVICE) {
+        return wrap<vecTy>(DevicesVectorPtr);
+    }
+
+    try {
+        auto SyclDTy = DPCTL_DPCTLDeviceTypeToSyclDeviceType(DTy);
+        auto Devices = P->get_devices(SyclDTy);
+        DevicesVectorPtr->reserve(Devices.size());
+        for (const auto &Dev : Devices) {
+            DevicesVectorPtr->emplace_back(
+                wrap<device>(new device(std::move(Dev))));
+        }
+        return wrap<vecTy>(DevicesVectorPtr);
+    } catch (std::exception const &e) {
+        delete DevicesVectorPtr;
+        error_handler(e, __FILE__, __func__, __LINE__);
+        return nullptr;
+    }
+}

libsyclinterface/tests/test_sycl_device_selector_interface.cpp

@@ -220,8 +220,7 @@ INSTANTIATE_TEST_SUITE_P(FilterSelectorCreation,
                                            "gpu:0",
                                            "gpu:1",
                                            "1",
-                                           "0",
-                                           "host"));
+                                           "0"));
 
 INSTANTIATE_TEST_SUITE_P(NegativeFilterSelectorCreation,
                          TestUnsupportedFilters,