-
Notifications
You must be signed in to change notification settings - Fork 34
Expand file tree
/
Copy pathdevice_queries.cpp
More file actions
181 lines (137 loc) · 5.49 KB
/
device_queries.cpp
File metadata and controls
181 lines (137 loc) · 5.49 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#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;
}
std::uint64_t py_intel_free_memory(const sycl::device &d)
{
static constexpr std::uint64_t free_memory_unavailable = 0;
if (d.has(sycl::aspect::ext_intel_free_memory)) {
return d.get_info<sycl::ext::intel::info::device::free_memory>();
}
return free_memory_unavailable;
}
std::uint32_t py_intel_memory_clock_rate(const sycl::device &d)
{
static constexpr std::uint32_t rate_unavailable = 0;
if (d.has(sycl::aspect::ext_intel_memory_clock_rate)) {
return d.get_info<sycl::ext::intel::info::device::memory_clock_rate>();
}
return rate_unavailable;
}
std::uint32_t py_intel_memory_bus_width(const sycl::device &d)
{
static constexpr std::uint32_t width_unavailable = 0;
if (d.has(sycl::aspect::ext_intel_memory_bus_width)) {
return d.get_info<sycl::ext::intel::info::device::memory_bus_width>();
}
return width_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"));
m.def("intel_device_info_free_memory", &py_intel_free_memory,
"Returns the memory available on the device in units of bytes.",
py::arg("device"));
m.def("intel_device_info_memory_clock_rate", &py_intel_memory_clock_rate,
"Returns the maximum clock rate of device's global memory in MHz.",
py::arg("device"));
m.def("intel_device_info_memory_bus_width", &py_intel_memory_bus_width,
"Returns the maximum bus width between device and memory in bits.",
py::arg("device"));
}