Skip to content

Commit 4e2097e

Browse files
fhazubski-IntelCompute-Runtime-Automation
fhazubski-Intel
authored and
Compute-Runtime-Automation
committed
Add new clGetDeviceInfo queries
Add support for following queries: - CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION - CL_DEVICE_EXTENSIONS_WITH_VERSION - CL_DEVICE_NUMERIC_VERSION - CL_DEVICE_OPENCL_C_ALL_VERSIONS Related-To: NEO-4368 Change-Id: I920671869fdb8815521173e2ec5ab3a4b905ec19 Signed-off-by: Filip Hazubski <[email protected]>
1 parent 23ad107 commit 4e2097e

File tree

8 files changed

+214
-16
lines changed

8 files changed

+214
-16
lines changed

‎opencl/source/cl_device/cl_device.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -123,6 +123,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
123123

124124
protected:
125125
void initializeCaps();
126+
void initializeOpenclCAllVersions();
126127
void initializeOsSpecificCaps();
127128
void setupFp64Flags();
128129

‎opencl/source/cl_device/cl_device_caps.cpp‎

Lines changed: 49 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -30,8 +30,6 @@ static std::string spirVersions = "1.2 ";
3030
#define TOSTR(b) QTR(b)
3131
static std::string driverVersion = TOSTR(NEO_OCL_DRIVER_VERSION);
3232

33-
const char *builtInKernels = ""; // the "always available" (extension-independent) builtin kernels
34-
3533
static constexpr cl_device_fp_config defaultFpFlags = static_cast<cl_device_fp_config>(CL_FP_ROUND_TO_NEAREST |
3634
CL_FP_ROUND_TO_ZERO |
3735
CL_FP_ROUND_TO_INF |
@@ -106,17 +104,21 @@ void ClDevice::initializeCaps() {
106104
case 30:
107105
deviceInfo.clVersion = "OpenCL 3.0 NEO ";
108106
deviceInfo.clCVersion = "OpenCL C 3.0 ";
107+
deviceInfo.numericClVersion = CL_MAKE_VERSION(3, 0, 0);
109108
break;
110109
case 21:
111110
deviceInfo.clVersion = "OpenCL 2.1 NEO ";
112111
deviceInfo.clCVersion = "OpenCL C 2.0 ";
112+
deviceInfo.numericClVersion = CL_MAKE_VERSION(2, 1, 0);
113113
break;
114114
case 12:
115115
default:
116116
deviceInfo.clVersion = "OpenCL 1.2 NEO ";
117117
deviceInfo.clCVersion = "OpenCL C 1.2 ";
118+
deviceInfo.numericClVersion = CL_MAKE_VERSION(1, 2, 0);
118119
break;
119120
}
121+
initializeOpenclCAllVersions();
120122
deviceInfo.platformLP = (hwInfo.capabilityTable.supportsOcl21Features == false);
121123
deviceInfo.spirVersions = spirVersions.c_str();
122124
auto supportsVme = hwInfo.capabilityTable.supportsVme;
@@ -196,16 +198,23 @@ void ClDevice::initializeCaps() {
196198

197199
deviceInfo.deviceExtensions = deviceExtensions.c_str();
198200

199-
exposedBuiltinKernels = builtInKernels;
200-
201+
std::vector<std::string> exposedBuiltinKernelsVector;
201202
if (supportsVme) {
202-
exposedBuiltinKernels.append("block_motion_estimate_intel;");
203+
exposedBuiltinKernelsVector.push_back("block_motion_estimate_intel");
203204
}
204205
if (supportsAdvancedVme) {
205-
auto advVmeKernels = "block_advanced_motion_estimate_check_intel;block_advanced_motion_estimate_bidirectional_check_intel;";
206-
exposedBuiltinKernels.append(advVmeKernels);
206+
exposedBuiltinKernelsVector.push_back("block_advanced_motion_estimate_check_intel");
207+
exposedBuiltinKernelsVector.push_back("block_advanced_motion_estimate_bidirectional_check_intel");
208+
}
209+
for (auto builtInKernel : exposedBuiltinKernelsVector) {
210+
exposedBuiltinKernels.append(builtInKernel);
211+
exposedBuiltinKernels.append(";");
212+
213+
cl_name_version kernelNameVersion;
214+
kernelNameVersion.version = CL_MAKE_VERSION(1, 0, 0);
215+
strcpy_s(kernelNameVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, builtInKernel.c_str());
216+
deviceInfo.builtInKernelsWithVersion.push_back(kernelNameVersion);
207217
}
208-
209218
deviceInfo.builtInKernels = exposedBuiltinKernels.c_str();
210219

211220
deviceInfo.deviceType = CL_DEVICE_TYPE_GPU;
@@ -386,6 +395,38 @@ void ClDevice::initializeCaps() {
386395
}
387396

388397
initializeOsSpecificCaps();
398+
399+
std::stringstream deviceExtensionsStringStream{deviceExtensions};
400+
std::vector<std::string> deviceExtensionsVector{
401+
std::istream_iterator<std::string>{deviceExtensionsStringStream}, std::istream_iterator<std::string>{}};
402+
for (auto deviceExtension : deviceExtensionsVector) {
403+
cl_name_version deviceExtensionWithVersion;
404+
deviceExtensionWithVersion.version = CL_MAKE_VERSION(1, 0, 0);
405+
strcpy_s(deviceExtensionWithVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, deviceExtension.c_str());
406+
deviceInfo.extensionsWithVersion.push_back(deviceExtensionWithVersion);
407+
}
408+
}
409+
410+
void ClDevice::initializeOpenclCAllVersions() {
411+
cl_name_version openClCVersion;
412+
strcpy_s(openClCVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, "OpenCL C");
413+
414+
openClCVersion.version = CL_MAKE_VERSION(1, 0, 0);
415+
deviceInfo.openclCAllVersions.push_back(openClCVersion);
416+
openClCVersion.version = CL_MAKE_VERSION(1, 1, 0);
417+
deviceInfo.openclCAllVersions.push_back(openClCVersion);
418+
openClCVersion.version = CL_MAKE_VERSION(1, 2, 0);
419+
deviceInfo.openclCAllVersions.push_back(openClCVersion);
420+
421+
if (ocl21FeaturesEnabled) {
422+
openClCVersion.version = CL_MAKE_VERSION(2, 0, 0);
423+
deviceInfo.openclCAllVersions.push_back(openClCVersion);
424+
}
425+
426+
if (enabledClVersion == 30) {
427+
openClCVersion.version = CL_MAKE_VERSION(3, 0, 0);
428+
deviceInfo.openclCAllVersions.push_back(openClCVersion);
429+
}
389430
}
390431

391432
} // namespace NEO

‎opencl/source/cl_device/cl_device_info.cpp‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -129,6 +129,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
129129
case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG >(src, srcSize, retSize); break;
130130
case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT >(src, srcSize, retSize); break;
131131
case CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT: getCap<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT >(src, srcSize, retSize); break;
132+
case CL_DEVICE_NUMERIC_VERSION: getCap<CL_DEVICE_NUMERIC_VERSION >(src, srcSize, retSize); break;
132133
case CL_DEVICE_OPENCL_C_VERSION: getStr<CL_DEVICE_OPENCL_C_VERSION >(src, srcSize, retSize); break;
133134
case CL_DEVICE_PARENT_DEVICE: getCap<CL_DEVICE_PARENT_DEVICE >(src, srcSize, retSize); break;
134135
case CL_DEVICE_PARTITION_AFFINITY_DOMAIN: getCap<CL_DEVICE_PARTITION_AFFINITY_DOMAIN >(src, srcSize, retSize); break;
@@ -214,6 +215,18 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
214215
case CL_DEVICE_OPENCL_C_FEATURES:
215216
retSize = srcSize = 0;
216217
break;
218+
case CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION:
219+
src = deviceInfo.builtInKernelsWithVersion.data();
220+
retSize = srcSize = deviceInfo.builtInKernelsWithVersion.size() * sizeof(cl_name_version);
221+
break;
222+
case CL_DEVICE_OPENCL_C_ALL_VERSIONS:
223+
src = deviceInfo.openclCAllVersions.data();
224+
retSize = srcSize = deviceInfo.openclCAllVersions.size() * sizeof(cl_name_version);
225+
break;
226+
case CL_DEVICE_EXTENSIONS_WITH_VERSION:
227+
src = deviceInfo.extensionsWithVersion.data();
228+
retSize = srcSize = deviceInfo.extensionsWithVersion.size() * sizeof(cl_name_version);
229+
break;
217230
default:
218231
if (getDeviceInfoForImage(paramName, src, srcSize, retSize) && !getSharedDeviceInfo().imageSupport) {
219232
src = &value;

‎opencl/source/cl_device/cl_device_info.h‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,11 +9,16 @@
99

1010
#include "opencl/extensions/public/cl_ext_private.h"
1111

12+
#include <vector>
13+
1214
namespace NEO {
1315

1416
// clang-format off
1517
struct ClDeviceInfo {
1618
cl_name_version ilsWithVersion[1];
19+
std::vector<cl_name_version> builtInKernelsWithVersion;
20+
std::vector<cl_name_version> openclCAllVersions;
21+
std::vector<cl_name_version> extensionsWithVersion;
1722
cl_device_type deviceType;
1823
size_t maxSliceCount;
1924
size_t image3DMaxWidth;
@@ -50,6 +55,7 @@ struct ClDeviceInfo {
5055
double platformHostTimerResolution;
5156
size_t planarYuvMaxWidth;
5257
size_t planarYuvMaxHeight;
58+
cl_version numericClVersion;
5359
cl_uint maxComputUnits;
5460
cl_uint maxWorkItemDimensions;
5561
cl_uint maxNumOfSubGroups;

‎opencl/source/cl_device/cl_device_info_map.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -129,6 +129,7 @@ template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT > :
129129
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::nativeVectorWidthLong> {};
130130
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::nativeVectorWidthShort> {};
131131
template<> struct Map<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT > : public ClMapBase<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, uint32_t, &ClDeviceInfo::nonUniformWorkGroupSupport> {};
132+
template<> struct Map<CL_DEVICE_NUMERIC_VERSION > : public ClMapBase<CL_DEVICE_NUMERIC_VERSION, uint32_t, &ClDeviceInfo::numericClVersion> {};
132133
template<> struct Map<CL_DEVICE_OPENCL_C_VERSION > : public ClMapBase<CL_DEVICE_OPENCL_C_VERSION, const char *, &ClDeviceInfo::clCVersion> {};
133134
template<> struct Map<CL_DEVICE_PARENT_DEVICE > : public ClMapBase<CL_DEVICE_PARENT_DEVICE, cl_device_id, &ClDeviceInfo::parentDevice> {};
134135
template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN > : public ClMapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN, uint64_t, &ClDeviceInfo::partitionAffinityDomain> {};

‎opencl/test/unit_test/device/device_caps_tests.cpp‎

Lines changed: 93 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
#include "opencl/test/unit_test/helpers/hw_helper_tests.h"
1717
#include "opencl/test/unit_test/mocks/mock_builtins.h"
1818
#include "opencl/test/unit_test/mocks/mock_execution_environment.h"
19+
#include "opencl/test/unit_test/mocks/ult_cl_device_factory.h"
1920

2021
#include "driver_version.h"
2122
#include "gtest/gtest.h"
@@ -41,6 +42,34 @@ struct DeviceGetCapsTest : public ::testing::Test {
4142
MockSipData::calledType = SipKernelType::COUNT;
4243
MockSipData::called = false;
4344
}
45+
46+
void verifyOpenclCAllVersions(MockClDevice &clDevice) {
47+
auto openclCWithVersion = clDevice.getDeviceInfo().openclCAllVersions.begin();
48+
49+
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
50+
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), openclCWithVersion->version);
51+
openclCWithVersion++;
52+
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
53+
EXPECT_EQ(CL_MAKE_VERSION(1u, 1u, 0u), openclCWithVersion->version);
54+
openclCWithVersion++;
55+
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
56+
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), openclCWithVersion->version);
57+
openclCWithVersion++;
58+
59+
if (clDevice.areOcl21FeaturesEnabled()) {
60+
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
61+
EXPECT_EQ(CL_MAKE_VERSION(2u, 0u, 0u), openclCWithVersion->version);
62+
openclCWithVersion++;
63+
}
64+
65+
if (clDevice.getEnabledClVersion() == 30) {
66+
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
67+
EXPECT_EQ(CL_MAKE_VERSION(3u, 0u, 0u), openclCWithVersion->version);
68+
openclCWithVersion++;
69+
}
70+
71+
EXPECT_EQ(clDevice.getDeviceInfo().openclCAllVersions.end(), openclCWithVersion);
72+
}
4473
};
4574

4675
TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
@@ -63,6 +92,9 @@ TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
6392
EXPECT_NE(nullptr, caps.profile);
6493
EXPECT_NE(nullptr, caps.clVersion);
6594
EXPECT_NE(nullptr, caps.clCVersion);
95+
EXPECT_NE(0u, caps.numericClVersion);
96+
EXPECT_GT(caps.openclCAllVersions.size(), 0u);
97+
EXPECT_GT(caps.extensionsWithVersion.size(), 0u);
6698

6799
EXPECT_NE(nullptr, caps.spirVersions);
68100
EXPECT_NE(nullptr, caps.deviceExtensions);
@@ -266,7 +298,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion30WhenCapsAreCreatedThenDeviceRepo
266298
const auto &caps = device->getDeviceInfo();
267299
EXPECT_STREQ("OpenCL 3.0 NEO ", caps.clVersion);
268300
EXPECT_STREQ("OpenCL C 3.0 ", caps.clCVersion);
301+
EXPECT_EQ(CL_MAKE_VERSION(3u, 0u, 0u), caps.numericClVersion);
269302
EXPECT_FALSE(device->ocl21FeaturesEnabled);
303+
verifyOpenclCAllVersions(*device);
270304
}
271305

272306
TEST_F(DeviceGetCapsTest, givenForceOclVersion21WhenCapsAreCreatedThenDeviceReportsOpenCL21) {
@@ -276,7 +310,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion21WhenCapsAreCreatedThenDeviceRepo
276310
const auto &caps = device->getDeviceInfo();
277311
EXPECT_STREQ("OpenCL 2.1 NEO ", caps.clVersion);
278312
EXPECT_STREQ("OpenCL C 2.0 ", caps.clCVersion);
313+
EXPECT_EQ(CL_MAKE_VERSION(2u, 1u, 0u), caps.numericClVersion);
279314
EXPECT_TRUE(device->ocl21FeaturesEnabled);
315+
verifyOpenclCAllVersions(*device);
280316
}
281317

282318
TEST_F(DeviceGetCapsTest, givenForceOclVersion12WhenCapsAreCreatedThenDeviceReportsOpenCL12) {
@@ -286,7 +322,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion12WhenCapsAreCreatedThenDeviceRepo
286322
const auto &caps = device->getDeviceInfo();
287323
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
288324
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
325+
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), caps.numericClVersion);
289326
EXPECT_FALSE(device->ocl21FeaturesEnabled);
327+
verifyOpenclCAllVersions(*device);
290328
}
291329

292330
TEST_F(DeviceGetCapsTest, givenForceOCL21FeaturesSupportEnabledWhenCapsAreCreatedThenDeviceReportsSupportOfOcl21Features) {
@@ -315,14 +353,15 @@ TEST_F(DeviceGetCapsTest, givenForceOcl30AndForceOCL21FeaturesSupportEnabledWhen
315353

316354
TEST_F(DeviceGetCapsTest, givenForceInvalidOclVersionWhenCapsAreCreatedThenDeviceWillDefaultToOpenCL12) {
317355
DebugManagerStateRestore dbgRestorer;
318-
{
319-
DebugManager.flags.ForceOCLVersion.set(1);
320-
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
321-
const auto &caps = device->getDeviceInfo();
322-
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
323-
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
324-
DebugManager.flags.ForceOCLVersion.set(0);
325-
}
356+
DebugManager.flags.ForceOCLVersion.set(1);
357+
358+
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
359+
const auto &caps = device->getDeviceInfo();
360+
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
361+
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
362+
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), caps.numericClVersion);
363+
EXPECT_FALSE(device->ocl21FeaturesEnabled);
364+
verifyOpenclCAllVersions(*device);
326365
}
327366

328367
TEST_F(DeviceGetCapsTest, givenForce32bitAddressingWhenCapsAreCreatedThenDeviceReports32bitAddressingOptimization) {
@@ -738,6 +777,38 @@ TEST_F(DeviceGetCapsTest, WhenDeviceIsCreatedThenVmeIsEnabled) {
738777
EXPECT_TRUE(freshDebugSettingsManager.flags.EnableIntelVme.get());
739778
}
740779

780+
TEST_F(DeviceGetCapsTest, givenVmeRelatedFlagsSetWhenCapsAreCreatedThenDeviceReportCorrectBuiltins) {
781+
DebugManagerStateRestore dbgRestorer;
782+
783+
for (auto isVmeEnabled : ::testing::Bool()) {
784+
DebugManager.flags.EnableIntelVme.set(isVmeEnabled);
785+
for (auto isAdvancedVmeEnabled : ::testing::Bool()) {
786+
DebugManager.flags.EnableIntelAdvancedVme.set(isAdvancedVmeEnabled);
787+
788+
UltClDeviceFactory deviceFactory{1, 0};
789+
const auto &caps = deviceFactory.rootDevices[0]->getDeviceInfo();
790+
auto builtInKernelWithVersion = caps.builtInKernelsWithVersion.begin();
791+
792+
if (isVmeEnabled) {
793+
EXPECT_STREQ("block_motion_estimate_intel", builtInKernelWithVersion->name);
794+
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
795+
builtInKernelWithVersion++;
796+
}
797+
798+
if (isAdvancedVmeEnabled) {
799+
EXPECT_STREQ("block_advanced_motion_estimate_check_intel", builtInKernelWithVersion->name);
800+
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
801+
builtInKernelWithVersion++;
802+
EXPECT_STREQ("block_advanced_motion_estimate_bidirectional_check_intel", builtInKernelWithVersion->name);
803+
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
804+
builtInKernelWithVersion++;
805+
}
806+
807+
EXPECT_EQ(caps.builtInKernelsWithVersion.end(), builtInKernelWithVersion);
808+
}
809+
}
810+
}
811+
741812
TEST_F(DeviceGetCapsTest, WhenDeviceIsCreatedThenPriorityHintsExtensionIsReported) {
742813
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
743814
const auto &caps = device->getDeviceInfo();
@@ -871,6 +942,20 @@ TEST_F(DeviceGetCapsTest, givenDeviceWhenGettingHostUnifiedMemoryCapThenItDepend
871942
EXPECT_EQ((localMemoryEnabled == false), caps.hostUnifiedMemory);
872943
}
873944

945+
TEST_F(DeviceGetCapsTest, givenDefaultDeviceWhenQueriedForExtensionsWithVersionThenValuesMatchWithExtensionsString) {
946+
UltClDeviceFactory deviceFactory{1, 0};
947+
auto pClDevice = deviceFactory.rootDevices[0];
948+
std::string allExtensions;
949+
950+
for (auto extensionWithVersion : pClDevice->getDeviceInfo().extensionsWithVersion) {
951+
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), extensionWithVersion.version);
952+
allExtensions += extensionWithVersion.name;
953+
allExtensions += " ";
954+
}
955+
956+
EXPECT_STREQ(pClDevice->deviceExtensions.c_str(), allExtensions.c_str());
957+
}
958+
874959
TEST(DeviceGetCaps, givenDeviceThatDoesntHaveFp64WhenDbgFlagEnablesFp64ThenReportFp64Flags) {
875960
DebugManagerStateRestore dbgRestorer;
876961
DebugManager.flags.OverrideDefaultFP64Settings.set(1);

0 commit comments

Comments
 (0)