Implement Python API for ext_intel_device_info descriptors

https://github.com/intel/llvm/blob/sycl/sycl/doc/extensions/supported/sycl_ext_intel_device_info.md

This includes HW characteristics for Intel Level-Zero GPU devices as well as
access to PCI device-identifier.

Author: oleksandr-pavlyk

dpctl/utils/CMakeLists.txt

@@ -4,3 +4,24 @@ foreach(_cy_file ${_cython_sources})
     get_filename_component(_trgt ${_cy_file} NAME_WLE)
     build_dpctl_ext(${_trgt} ${_cy_file} "dpctl/utils")
 endforeach()
+
+add_custom_target(_dpctl4pybind11_header_ready
+    DEPENDS
+    _usmarray_copy_capi_include
+    _memory_copy_capi_include
+    _sycl_device_copy_capi_include
+    _sycl_queue_copy_capi_include
+    _sycl_context_copy_capi_include
+    _sycl_event_copy_capi_include
+)
+
+set(python_module_name _device_queries)
+pybind11_add_module(${python_module_name} MODULE
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/device_queries.cpp
+)
+target_include_directories(${python_module_name}
+    PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../include
+)
+add_dependencies(${python_module_name} _dpctl4pybind11_header_ready)
+install(TARGETS ${python_module_name} DESTINATION "dpctl/utils")

dpctl/utils/__init__.py

@@ -18,14 +18,87 @@
 A collection of utility functions.
 """
 
+from .._sycl_device import SyclDevice
 from ._compute_follows_data import (
     ExecutionPlacementError,
     get_coerced_usm_type,
     get_execution_queue,
     validate_usm_type,
 )
+from ._device_queries import (
+    intel_device_info_device_id,
+    intel_device_info_gpu_eu_count,
+    intel_device_info_gpu_eu_count_per_subslice,
+    intel_device_info_gpu_eu_simd_width,
+    intel_device_info_gpu_hw_threads_per_eu,
+    intel_device_info_gpu_slices,
+    intel_device_info_gpu_subslices_per_slice,
+    intel_device_info_max_mem_bandwidth,
+)
 from ._onetrace_context import onetrace_enabled
 
+
+def intel_device_info(dev):
+    """intel_device_info(sycl_device)
+
+    For Intel(R) GPU devices returns a dictionary
+    with device architectural details, and an empty
+    dictionary otherwise. The dictionary contains
+    the following keys:
+
+        device_id: 32-bits device PCI identifier
+        gpu_eu_count: Total number of execution units
+        gpu_hw_threads_per_eu: Number of thread contexts in EU
+        gpu_eu_simd_width: Physical SIMD width of EU
+        gpu_slices: Total number of slices
+        gpu_subslices_per_slice: Number of sub-slices per slice
+        gpu_eu_count_per_subslice: Number of EUs in subslice
+        max_mem_bandwidth: Maximum memory bandwidth in bytes/second
+
+    Unsupported descriptors are omitted from the dictionary.
+    Descriptors other than PCI identifier are supported only for
+    SyclDevices with Leve-Zero backend.
+    """
+    if not isinstance(dev, SyclDevice):
+        raise TypeError(f"Expected dpctl.SyclDevice, got {type(dev)}")
+    dev_id = intel_device_info_device_id(dev)
+    if dev_id:
+        res = {
+            "device_id": dev_id,
+        }
+        if dev.has_aspect_gpu:
+            eu_count = intel_device_info_gpu_eu_count(dev)
+            if eu_count:
+                res["gpu_eu_count"] = eu_count
+            hw_threads = intel_device_info_gpu_hw_threads_per_eu(dev)
+            if hw_threads:
+                res["gpu_hw_threads_per_eu"] = hw_threads
+            simd_w = intel_device_info_gpu_eu_simd_width(dev)
+            if simd_w:
+                res["gpu_eu_simd_width"] = simd_w
+            n_slices = intel_device_info_gpu_slices(dev)
+            if n_slices:
+                res["gpu_slices"] = n_slices
+            n_subslices = intel_device_info_gpu_subslices_per_slice(dev)
+            if n_subslices:
+                res["gpu_subslices_per_slice"] = n_subslices
+            n_eu_per_subslice = intel_device_info_gpu_eu_count_per_subslice(dev)
+            if n_eu_per_subslice:
+                res["gpu_eu_count_per_subslice"] = n_eu_per_subslice
+        bw = intel_device_info_max_mem_bandwidth(dev)
+        if bw:
+            res["max_mem_bandwidth"] = bw
+        return res
+    return dict()
+
+
+def _is_gen9(dev):
+    if not isinstance(dev, SyclDevice):
+        raise TypeError(f"Expected dpctl.SyclDevice, got {type(dev)}")
+    dev_id = intel_device_info_device_id(dev)
+    return (dev_id & 0xFF00) == 0x3E00
+
+
 __all__ = [
     "get_execution_queue",
     "get_coerced_usm_type",

dpctl/utils/src/device_queries.cpp

@@ -0,0 +1,139 @@
+#include "dpctl4pybind11.hpp"
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <sycl/sycl.hpp>
+
+#include <cstddef>
+#include <cstdint>
+
+namespace
+{
+
+std::uint32_t py_intel_device_id(const sycl::device &d)
+{
+    static constexpr std::uint32_t device_id_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_device_id)) {
+        return d.get_info<sycl::ext::intel::info::device::device_id>();
+    }
+
+    return device_id_unavailable;
+}
+
+std::uint32_t py_intel_gpu_eu_count(const sycl::device &d)
+{
+    static constexpr std::uint32_t eu_count_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_eu_count)) {
+        return d.get_info<sycl::ext::intel::info::device::gpu_eu_count>();
+    }
+
+    return eu_count_unavailable;
+}
+
+std::uint32_t py_intel_gpu_hw_threads_per_eu(const sycl::device &d)
+{
+    static constexpr std::uint32_t thread_count_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_hw_threads_per_eu)) {
+        return d
+            .get_info<sycl::ext::intel::info::device::gpu_hw_threads_per_eu>();
+    }
+
+    return thread_count_unavailable;
+}
+
+std::uint32_t py_intel_gpu_eu_simd_width(const sycl::device &d)
+{
+    static constexpr std::uint32_t width_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_eu_simd_width)) {
+        return d.get_info<sycl::ext::intel::info::device::gpu_eu_simd_width>();
+    }
+
+    return width_unavailable;
+}
+
+std::uint32_t py_intel_gpu_slices(const sycl::device &d)
+{
+    static constexpr std::uint32_t count_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_slices)) {
+        return d.get_info<sycl::ext::intel::info::device::gpu_slices>();
+    }
+
+    return count_unavailable;
+}
+
+std::uint32_t py_intel_gpu_subslices_per_slice(const sycl::device &d)
+{
+    static constexpr std::uint32_t count_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_subslices_per_slice)) {
+        return d.get_info<
+            sycl::ext::intel::info::device::gpu_subslices_per_slice>();
+    }
+
+    return count_unavailable;
+}
+
+std::uint32_t py_intel_gpu_eu_count_per_subslice(const sycl::device &d)
+{
+    static constexpr std::uint32_t count_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_gpu_eu_count_per_subslice)) {
+        return d.get_info<
+            sycl::ext::intel::info::device::gpu_eu_count_per_subslice>();
+    }
+
+    return count_unavailable;
+}
+
+std::uint64_t py_intel_max_mem_bandwidth(const sycl::device &d)
+{
+    static constexpr std::uint64_t bandwidth_unavailable = 0;
+
+    if (d.has(sycl::aspect::ext_intel_max_mem_bandwidth)) {
+        return d.get_info<sycl::ext::intel::info::device::max_mem_bandwidth>();
+    }
+
+    return bandwidth_unavailable;
+}
+
+}; // namespace
+
+PYBIND11_MODULE(_device_queries, m)
+{
+    m.def("intel_device_info_device_id", &py_intel_device_id,
+          "Get ext_intel_device_id for the device, zero if not an intel device",
+          py::arg("device"));
+
+    m.def("intel_device_info_gpu_eu_count", &py_intel_gpu_eu_count,
+          "Returns the number of execution units (EUs) associated with the "
+          "Intel GPU.",
+          py::arg("device"));
+
+    m.def("intel_device_info_gpu_hw_threads_per_eu",
+          &py_intel_gpu_hw_threads_per_eu,
+          "Returns the number of hardware threads in EU.", py::arg("device"));
+
+    m.def("intel_device_info_gpu_eu_simd_width", &py_intel_gpu_eu_simd_width,
+          "Returns the physical SIMD width of the execution unit (EU).",
+          py::arg("device"));
+
+    m.def("intel_device_info_gpu_slices", &py_intel_gpu_slices,
+          "Returns the number of slices in the GPU device, or zero.",
+          py::arg("device"));
+
+    m.def("intel_device_info_gpu_subslices_per_slice",
+          &py_intel_gpu_subslices_per_slice,
+          "Returns the number of subslices per slice.", py::arg("device"));
+
+    m.def("intel_device_info_gpu_eu_count_per_subslice",
+          &py_intel_gpu_eu_count_per_subslice,
+          "Returns the number of EUs per subslice of GPU.", py::arg("device"));
+
+    m.def("intel_device_info_max_mem_bandwidth", &py_intel_max_mem_bandwidth,
+          "Returns the maximum memory bandwidth in units of bytes/second.",
+          py::arg("device"));
+}