20 #include <sycl/feature_test.hpp>
33 std::vector<info::fp_config> result;
35 result.push_back(info::fp_config::denorm);
37 result.push_back(info::fp_config::inf_nan);
39 result.push_back(info::fp_config::round_to_nearest);
41 result.push_back(info::fp_config::round_to_zero);
43 result.push_back(info::fp_config::round_to_inf);
47 result.push_back(info::fp_config::soft_float);
49 result.push_back(info::fp_config::correctly_rounded_divide_sqrt);
53 inline std::vector<info::partition_affinity_domain>
55 std::vector<info::partition_affinity_domain> result;
57 result.push_back(info::partition_affinity_domain::numa);
59 result.push_back(info::partition_affinity_domain::L4_cache);
61 result.push_back(info::partition_affinity_domain::L3_cache);
63 result.push_back(info::partition_affinity_domain::L2_cache);
65 result.push_back(info::partition_affinity_domain::L1_cache);
67 result.push_back(info::partition_affinity_domain::next_partitionable);
71 inline std::vector<info::execution_capability>
73 std::vector<info::execution_capability> result;
75 result.push_back(info::execution_capability::exec_kernel);
77 result.push_back(info::execution_capability::exec_native_kernel);
83 switch (AffinityDomain) {
84 #define __SYCL_AFFINITY_DOMAIN_STRING_CASE(DOMAIN) \
89 sycl::info::partition_affinity_domain::numa)
91 sycl::info::partition_affinity_domain::L4_cache)
93 sycl::info::partition_affinity_domain::L3_cache)
95 sycl::info::partition_affinity_domain::L2_cache)
97 sycl::info::partition_affinity_domain::L1_cache)
99 sycl::info::partition_affinity_domain::next_partitionable)
100 #undef __SYCL_AFFINITY_DOMAIN_STRING_CASE
102 assert(
false &&
"Missing case for affinity domain.");
125 using type = info::device::native_vector_width_half;
129 using type = info::device::native_vector_width_double;
140 sizeof(result), &result,
nullptr);
141 return ReturnT(result);
150 sizeof(result), &result,
nullptr);
154 return createSyclObjFromImpl<platform>(
155 platform_impl::getOrMakePlatformImpl(result, Plugin));
164 size_t resultSize = 0;
167 if (resultSize == 0) {
168 return std::string();
170 std::unique_ptr<char[]> result(
new char[resultSize]);
172 result.get(),
nullptr);
174 return std::string(result.get());
185 template <
typename ReturnT>
191 template <
typename Param>
201 cl_device_fp_config result;
203 sizeof(result), &result,
nullptr);
217 auto dotPos = result.find(
'.');
218 if (dotPos == std::string::npos)
221 auto leftPos = result.rfind(
' ', dotPos);
222 if (leftPos == std::string::npos)
227 auto rightPos = result.find(
' ', dotPos);
228 return result.substr(leftPos, rightPos - leftPos);
235 info::device::single_fp_config> {
253 sizeof(Properties), &Properties,
nullptr);
258 Dev,
nullptr,
nullptr);
259 if (Result == PI_ERROR_INVALID_OPERATION)
269 info::device::atomic_memory_order_capabilities> {
282 info::device::atomic_fence_order_capabilities> {
295 info::device::atomic_memory_scope_capabilities> {
308 info::device::atomic_fence_scope_capabilities> {
321 info::device::ext_oneapi_bfloat16_math_functions> {
328 sizeof(result), &result,
nullptr);
329 if (Err != PI_SUCCESS) {
339 info::device::execution_capabilities> {
345 sizeof(result), &result,
nullptr);
353 info::device::built_in_kernel_ids> {
359 std::vector<kernel_id> ids;
360 ids.reserve(names.size());
361 for (
const auto &name : names) {
362 ids.push_back(ProgramManager::getInstance().getBuiltInKernelID(name));
371 info::device::built_in_kernels> {
382 info::device::extensions> {
393 case info::partition_property::no_partition:
394 case info::partition_property::partition_equally:
395 case info::partition_property::partition_by_counts:
396 case info::partition_property::partition_by_affinity_domain:
397 case info::partition_property::ext_intel_partition_by_cslice:
406 info::device::partition_properties> {
415 size_t arrayLength = resultSize /
sizeof(cl_device_partition_property);
416 if (arrayLength == 0) {
419 std::unique_ptr<cl_device_partition_property[]> arrayResult(
420 new cl_device_partition_property[arrayLength]);
422 arrayResult.get(),
nullptr);
424 std::vector<info::partition_property> result;
425 for (
size_t i = 0; i < arrayLength; ++i) {
431 result.push_back(pp);
440 info::device::partition_affinity_domains> {
441 static std::vector<info::partition_affinity_domain>
446 sizeof(result), &result,
nullptr);
455 info::device::partition_type_affinity_domain> {
461 nullptr, &resultSize);
462 if (resultSize != 1) {
463 return info::partition_affinity_domain::not_applicable;
465 cl_device_partition_property result;
468 sizeof(result), &result,
nullptr);
477 return info::partition_affinity_domain::not_applicable;
484 info::device::partition_type_property> {
488 0,
nullptr, &resultSize);
490 return info::partition_property::no_partition;
492 size_t arrayLength = resultSize /
sizeof(cl_device_partition_property);
494 std::unique_ptr<cl_device_partition_property[]> arrayResult(
495 new cl_device_partition_property[arrayLength]);
497 resultSize, arrayResult.get(),
500 return info::partition_property::no_partition;
507 info::device::sub_group_sizes> {
509 size_t resultSize = 0;
514 std::vector<size_t> result(resultSize /
sizeof(
size_t));
517 result.data(),
nullptr);
532 std::string platform_name = plt.
get_info<info::platform::name>();
533 if (platform_name ==
"Intel(R) FPGA Emulation Platform for OpenCL(TM)" ||
534 platform_name ==
"Intel(R) FPGA SDK for OpenCL(TM)")
550 return {values[1], values[0]};
553 return {values[2], values[1], values[0]};
557 template <
int Dimensions>
559 info::device::max_work_item_sizes<Dimensions>> {
564 sizeof(result), &result,
nullptr);
565 return construct_id<Dimensions>(result);
571 size_t, ext::oneapi::experimental::info::device::max_global_work_groups> {
580 id<1>, ext::oneapi::experimental::info::device::max_work_groups<1>> {
585 max_global_work_groups>
::get(dev,
591 sizeof(result), &result,
nullptr);
592 return id<1>(std::min(Limit, result[0]));
598 id<2>, ext::oneapi::experimental::info::device::max_work_groups<2>> {
603 max_global_work_groups>
::get(dev,
609 sizeof(result), &result,
nullptr);
610 return id<2>(std::min(Limit, result[1]), std::min(Limit, result[0]));
616 id<3>, ext::oneapi::experimental::info::device::max_work_groups<3>> {
621 max_global_work_groups>
::get(dev,
627 sizeof(result), &result,
nullptr);
628 return id<3>(std::min(Limit, result[2]), std::min(Limit, result[1]),
629 std::min(Limit, result[0]));
637 info::device::ext_oneapi_max_global_work_groups> {
640 ext::oneapi::experimental::info::device::
641 max_global_work_groups>
::get(dev, Plugin);
649 info::device::ext_oneapi_max_work_groups_1d> {
652 max_work_groups<1>>
::get(dev,
661 info::device::ext_oneapi_max_work_groups_2d> {
664 max_work_groups<2>>
::get(dev,
673 info::device::ext_oneapi_max_work_groups_3d> {
676 max_work_groups<3>>
::get(dev,
688 if (result ==
nullptr)
689 throw invalid_object_error(
690 "No parent for device because it is not a subdevice",
691 PI_ERROR_INVALID_DEVICE);
694 std::shared_ptr<detail::platform_impl> Platform =
695 platform_impl::getPlatformFromPiDevice(dev, Plugin);
696 return createSyclObjFromImpl<device>(
697 Platform->getOrMakeDeviceImpl(result, Platform));
744 info::device::usm_restricted_shared_allocations> {
751 return (Err != PI_SUCCESS)
784 bool, ext::codeplay::experimental::info::device::supports_fusion> {
786 #if SYCL_EXT_CODEPLAY_KERNEL_FUSION
790 return (Plugin.
getBackend() == backend::ext_oneapi_level_zero) ||
792 #else // SYCL_EXT_CODEPLAY_KERNEL_FUSION
796 #endif // SYCL_EXT_CODEPLAY_KERNEL_FUSION
800 template <
typename Param>
804 "Invalid device information descriptor");
813 template <
typename Param>
818 return info::device_type::host;
821 template <>
inline uint32_t get_device_info_host<info::device::vendor_id>() {
826 inline uint32_t get_device_info_host<info::device::max_compute_units>() {
827 return std::thread::hardware_concurrency();
831 inline uint32_t get_device_info_host<info::device::max_work_item_dimensions>() {
836 inline id<1> get_device_info_host<info::device::max_work_item_sizes<1>>() {
842 inline id<2> get_device_info_host<info::device::max_work_item_sizes<2>>() {
848 inline id<3> get_device_info_host<info::device::max_work_item_sizes<3>>() {
855 ext::oneapi::experimental::info::device::max_global_work_groups>() {
865 ext::oneapi::experimental::info::device::max_global_work_groups>();
874 ext::oneapi::experimental::info::device::max_global_work_groups>();
875 return {Limit, Limit};
883 ext::oneapi::experimental::info::device::max_global_work_groups>();
884 return {Limit, Limit, Limit};
890 inline constexpr
size_t
891 get_device_info_host<info::device::ext_oneapi_max_global_work_groups>() {
893 ext::oneapi::experimental::info::device::max_global_work_groups>();
900 get_device_info_host<info::device::ext_oneapi_max_work_groups_1d>() {
910 get_device_info_host<info::device::ext_oneapi_max_work_groups_2d>() {
919 get_device_info_host<info::device::ext_oneapi_max_work_groups_3d>() {
925 inline size_t get_device_info_host<info::device::max_work_group_size>() {
932 get_device_info_host<info::device::preferred_vector_width_char>() {
939 get_device_info_host<info::device::preferred_vector_width_short>() {
946 get_device_info_host<info::device::preferred_vector_width_int>() {
953 get_device_info_host<info::device::preferred_vector_width_long>() {
960 get_device_info_host<info::device::preferred_vector_width_float>() {
967 get_device_info_host<info::device::preferred_vector_width_double>() {
974 get_device_info_host<info::device::preferred_vector_width_half>() {
980 inline uint32_t get_device_info_host<info::device::native_vector_width_char>() {
981 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Char);
986 get_device_info_host<info::device::native_vector_width_short>() {
987 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Short);
991 inline uint32_t get_device_info_host<info::device::native_vector_width_int>() {
992 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Int);
996 inline uint32_t get_device_info_host<info::device::native_vector_width_long>() {
997 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Long);
1002 get_device_info_host<info::device::native_vector_width_float>() {
1003 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Float);
1008 get_device_info_host<info::device::native_vector_width_double>() {
1009 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Double);
1013 inline uint32_t get_device_info_host<info::device::native_vector_width_half>() {
1014 return PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex::Half);
1018 inline uint32_t get_device_info_host<info::device::max_clock_frequency>() {
1019 return PlatformUtil::getMaxClockFrequency();
1022 template <>
inline uint32_t get_device_info_host<info::device::address_bits>() {
1023 return sizeof(
void *) * 8;
1027 inline uint64_t get_device_info_host<info::device::global_mem_size>() {
1028 return static_cast<uint64_t
>(OSUtil::getOSMemSize());
1032 inline uint64_t get_device_info_host<info::device::max_mem_alloc_size>() {
1034 const uint64_t a = get_device_info_host<info::device::global_mem_size>() / 4;
1035 const uint64_t b = 128ul * 1024 * 1024;
1036 return (a > b) ? a : b;
1039 template <>
inline bool get_device_info_host<info::device::image_support>() {
1043 template <>
inline bool get_device_info_host<info::device::atomic64>() {
1048 inline std::vector<memory_order>
1049 get_device_info_host<info::device::atomic_memory_order_capabilities>() {
1050 return {memory_order::relaxed, memory_order::acquire, memory_order::release,
1051 memory_order::acq_rel, memory_order::seq_cst};
1055 inline std::vector<memory_order>
1056 get_device_info_host<info::device::atomic_fence_order_capabilities>() {
1057 return {memory_order::relaxed, memory_order::acquire, memory_order::release,
1058 memory_order::acq_rel};
1062 inline std::vector<memory_scope>
1063 get_device_info_host<info::device::atomic_memory_scope_capabilities>() {
1064 return {memory_scope::work_item, memory_scope::sub_group,
1065 memory_scope::work_group, memory_scope::device, memory_scope::system};
1069 inline std::vector<memory_scope>
1070 get_device_info_host<info::device::atomic_fence_scope_capabilities>() {
1071 return {memory_scope::work_item, memory_scope::sub_group,
1072 memory_scope::work_group, memory_scope::device, memory_scope::system};
1077 get_device_info_host<info::device::ext_oneapi_bfloat16_math_functions>() {
1082 inline uint32_t get_device_info_host<info::device::max_read_image_args>() {
1088 inline uint32_t get_device_info_host<info::device::max_write_image_args>() {
1094 inline size_t get_device_info_host<info::device::image2d_max_width>() {
1110 inline size_t get_device_info_host<info::device::image2d_max_height>() {
1126 inline size_t get_device_info_host<info::device::image3d_max_width>() {
1142 inline size_t get_device_info_host<info::device::image3d_max_height>() {
1158 inline size_t get_device_info_host<info::device::image3d_max_depth>() {
1174 inline size_t get_device_info_host<info::device::image_max_buffer_size>() {
1180 inline size_t get_device_info_host<info::device::image_max_array_size>() {
1185 template <>
inline uint32_t get_device_info_host<info::device::max_samplers>() {
1191 inline size_t get_device_info_host<info::device::max_parameter_size>() {
1197 inline uint32_t get_device_info_host<info::device::mem_base_addr_align>() {
1202 inline std::vector<info::fp_config>
1203 get_device_info_host<info::device::half_fp_config>() {
1209 inline std::vector<info::fp_config>
1210 get_device_info_host<info::device::single_fp_config>() {
1212 return {info::fp_config::round_to_nearest, info::fp_config::inf_nan};
1216 inline std::vector<info::fp_config>
1217 get_device_info_host<info::device::double_fp_config>() {
1220 info::fp_config::round_to_zero, info::fp_config::round_to_inf,
1221 info::fp_config::inf_nan, info::fp_config::denorm};
1226 get_device_info_host<info::device::global_mem_cache_type>() {
1232 get_device_info_host<info::device::global_mem_cache_line_size>() {
1233 return PlatformUtil::getMemCacheLineSize();
1237 inline uint64_t get_device_info_host<info::device::global_mem_cache_size>() {
1238 return PlatformUtil::getMemCacheSize();
1242 inline uint64_t get_device_info_host<info::device::max_constant_buffer_size>() {
1248 inline uint32_t get_device_info_host<info::device::max_constant_args>() {
1255 get_device_info_host<info::device::local_mem_type>() {
1256 return info::local_mem_type::global;
1260 inline uint64_t get_device_info_host<info::device::local_mem_size>() {
1266 inline bool get_device_info_host<info::device::error_correction_support>() {
1271 inline bool get_device_info_host<info::device::host_unified_memory>() {
1276 inline size_t get_device_info_host<info::device::profiling_timer_resolution>() {
1277 typedef std::ratio_divide<std::chrono::high_resolution_clock::period,
1280 return ns_period::num / ns_period::den;
1283 template <>
inline bool get_device_info_host<info::device::is_endian_little>() {
1292 template <>
inline bool get_device_info_host<info::device::is_available>() {
1297 inline bool get_device_info_host<info::device::is_compiler_available>() {
1302 inline bool get_device_info_host<info::device::is_linker_available>() {
1307 inline std::vector<info::execution_capability>
1308 get_device_info_host<info::device::execution_capabilities>() {
1309 return {info::execution_capability::exec_kernel};
1312 template <>
inline bool get_device_info_host<info::device::queue_profiling>() {
1317 inline std::vector<kernel_id>
1318 get_device_info_host<info::device::built_in_kernel_ids>() {
1323 inline std::vector<std::string>
1324 get_device_info_host<info::device::built_in_kernels>() {
1328 template <>
inline platform get_device_info_host<info::device::platform>() {
1329 return createSyclObjFromImpl<platform>(platform_impl::getHostPlatformImpl());
1332 template <>
inline std::string get_device_info_host<info::device::name>() {
1333 return "SYCL host device";
1336 template <>
inline std::string get_device_info_host<info::device::vendor>() {
1341 inline std::string get_device_info_host<info::device::driver_version>() {
1345 template <>
inline std::string get_device_info_host<info::device::profile>() {
1346 return "FULL PROFILE";
1349 template <>
inline std::string get_device_info_host<info::device::version>() {
1354 inline std::string get_device_info_host<info::device::opencl_c_version>() {
1355 return "not applicable";
1359 inline std::vector<std::string>
1360 get_device_info_host<info::device::extensions>() {
1366 inline size_t get_device_info_host<info::device::printf_buffer_size>() {
1372 inline bool get_device_info_host<info::device::preferred_interop_user_sync>() {
1376 template <>
inline device get_device_info_host<info::device::parent_device>() {
1377 throw invalid_object_error(
1378 "Partitioning to subdevices of the host device is not implemented",
1379 PI_ERROR_INVALID_DEVICE);
1384 get_device_info_host<info::device::partition_max_sub_devices>() {
1390 inline std::vector<info::partition_property>
1391 get_device_info_host<info::device::partition_properties>() {
1397 inline std::vector<info::partition_affinity_domain>
1398 get_device_info_host<info::device::partition_affinity_domains>() {
1405 get_device_info_host<info::device::partition_type_property>() {
1406 return info::partition_property::no_partition;
1411 get_device_info_host<info::device::partition_type_affinity_domain>() {
1413 return info::partition_affinity_domain::not_applicable;
1417 inline uint32_t get_device_info_host<info::device::reference_count>() {
1423 inline uint32_t get_device_info_host<info::device::max_num_sub_groups>() {
1425 throw runtime_error(
"Sub-group feature is not supported on HOST device.",
1426 PI_ERROR_INVALID_DEVICE);
1430 inline std::vector<size_t>
1431 get_device_info_host<info::device::sub_group_sizes>() {
1433 throw runtime_error(
"Sub-group feature is not supported on HOST device.",
1434 PI_ERROR_INVALID_DEVICE);
1439 get_device_info_host<info::device::sub_group_independent_forward_progress>() {
1441 throw runtime_error(
"Sub-group feature is not supported on HOST device.",
1442 PI_ERROR_INVALID_DEVICE);
1446 inline bool get_device_info_host<info::device::kernel_kernel_pipe_support>() {
1451 inline std::string get_device_info_host<info::device::backend_version>() {
1452 throw runtime_error(
1453 "Backend version feature is not supported on HOST device.",
1454 PI_ERROR_INVALID_DEVICE);
1458 inline bool get_device_info_host<info::device::usm_device_allocations>() {
1463 inline bool get_device_info_host<info::device::usm_host_allocations>() {
1468 inline bool get_device_info_host<info::device::usm_shared_allocations>() {
1474 get_device_info_host<info::device::usm_restricted_shared_allocations>() {
1479 inline bool get_device_info_host<info::device::usm_system_allocations>() {
1484 inline bool get_device_info_host<info::device::ext_intel_mem_channel>() {
1492 get_device_info_host<ext::intel::info::device::device_id>() {
1493 throw runtime_error(
1494 "Obtaining the device ID is not supported on HOST device",
1495 PI_ERROR_INVALID_DEVICE);
1499 get_device_info_host<ext::intel::info::device::pci_address>() {
1500 throw runtime_error(
1501 "Obtaining the PCI address is not supported on HOST device",
1502 PI_ERROR_INVALID_DEVICE);
1505 inline uint32_t get_device_info_host<ext::intel::info::device::gpu_eu_count>() {
1506 throw runtime_error(
"Obtaining the EU count is not supported on HOST device",
1507 PI_ERROR_INVALID_DEVICE);
1511 get_device_info_host<ext::intel::info::device::gpu_eu_simd_width>() {
1512 throw runtime_error(
1513 "Obtaining the EU SIMD width is not supported on HOST device",
1514 PI_ERROR_INVALID_DEVICE);
1517 inline uint32_t get_device_info_host<ext::intel::info::device::gpu_slices>() {
1518 throw runtime_error(
1519 "Obtaining the number of slices is not supported on HOST device",
1520 PI_ERROR_INVALID_DEVICE);
1524 get_device_info_host<ext::intel::info::device::gpu_subslices_per_slice>() {
1525 throw runtime_error(
"Obtaining the number of subslices per slice is not "
1526 "supported on HOST device",
1527 PI_ERROR_INVALID_DEVICE);
1531 get_device_info_host<ext::intel::info::device::gpu_eu_count_per_subslice>() {
1532 throw runtime_error(
1533 "Obtaining the EU count per subslice is not supported on HOST device",
1534 PI_ERROR_INVALID_DEVICE);
1538 get_device_info_host<ext::intel::info::device::gpu_hw_threads_per_eu>() {
1539 throw runtime_error(
1540 "Obtaining the HW threads count per EU is not supported on HOST device",
1541 PI_ERROR_INVALID_DEVICE);
1545 get_device_info_host<ext::intel::info::device::max_mem_bandwidth>() {
1546 throw runtime_error(
1547 "Obtaining the maximum memory bandwidth is not supported on HOST device",
1548 PI_ERROR_INVALID_DEVICE);
1552 get_device_info_host<ext::intel::info::device::uuid>() {
1553 throw runtime_error(
1554 "Obtaining the device uuid is not supported on HOST device",
1555 PI_ERROR_INVALID_DEVICE);
1561 inline std::string get_device_info_host<info::device::ext_intel_pci_address>() {
1562 throw runtime_error(
1563 "Obtaining the PCI address is not supported on HOST device",
1564 PI_ERROR_INVALID_DEVICE);
1569 inline uint32_t get_device_info_host<info::device::ext_intel_gpu_eu_count>() {
1570 throw runtime_error(
"Obtaining the EU count is not supported on HOST device",
1571 PI_ERROR_INVALID_DEVICE);
1577 get_device_info_host<info::device::ext_intel_gpu_eu_simd_width>() {
1578 throw runtime_error(
1579 "Obtaining the EU SIMD width is not supported on HOST device",
1580 PI_ERROR_INVALID_DEVICE);
1585 inline uint32_t get_device_info_host<info::device::ext_intel_gpu_slices>() {
1586 throw runtime_error(
1587 "Obtaining the number of slices is not supported on HOST device",
1588 PI_ERROR_INVALID_DEVICE);
1594 get_device_info_host<info::device::ext_intel_gpu_subslices_per_slice>() {
1595 throw runtime_error(
"Obtaining the number of subslices per slice is not "
1596 "supported on HOST device",
1597 PI_ERROR_INVALID_DEVICE);
1603 get_device_info_host<info::device::ext_intel_gpu_eu_count_per_subslice>() {
1604 throw runtime_error(
1605 "Obtaining the EU count per subslice is not supported on HOST device",
1606 PI_ERROR_INVALID_DEVICE);
1612 get_device_info_host<info::device::ext_intel_gpu_hw_threads_per_eu>() {
1613 throw runtime_error(
1614 "Obtaining the HW threads count per EU is not supported on HOST device",
1615 PI_ERROR_INVALID_DEVICE);
1621 get_device_info_host<info::device::ext_intel_max_mem_bandwidth>() {
1622 throw runtime_error(
1623 "Obtaining the maximum memory bandwidth is not supported on HOST device",
1624 PI_ERROR_INVALID_DEVICE);
1627 template <>
inline bool get_device_info_host<info::device::ext_oneapi_srgb>() {
1635 get_device_info_host<info::device::ext_intel_device_info_uuid>() {
1636 throw runtime_error(
1637 "Obtaining the device uuid is not supported on HOST device",
1638 PI_ERROR_INVALID_DEVICE);
1642 inline uint64_t get_device_info_host<ext::intel::info::device::free_memory>() {
1643 throw runtime_error(
1644 "Obtaining the device free memory is not supported on HOST device",
1645 PI_ERROR_INVALID_DEVICE);
1650 get_device_info_host<ext::intel::info::device::memory_clock_rate>() {
1651 throw runtime_error(
1652 "Obtaining the device memory clock rate is not supported on HOST device",
1653 PI_ERROR_INVALID_DEVICE);
1658 get_device_info_host<ext::intel::info::device::memory_bus_width>() {
1659 throw runtime_error(
1660 "Obtaining the device memory bus width is not supported on HOST device",
1661 PI_ERROR_INVALID_DEVICE);
1666 get_device_info_host<ext::intel::info::device::max_compute_queue_indices>() {
1667 throw runtime_error(
1668 "Obtaining max compute queue indices is not supported on HOST device",
1669 PI_ERROR_INVALID_DEVICE);
1674 ext::codeplay::experimental::info::device::supports_fusion>() {