Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add new clGetDeviceInfo queries

Browse Source 
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 <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2020-05-26 15:28:40 +02:00
committed by sys_ocldev
parent 23ad10731b
commit 4e2097e427
8 changed files with 213 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
opencl/source/cl_device/cl_device.h
View File

@ -123,6 +123,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
protected:
void initializeCaps();
void initializeOpenclCAllVersions();
void initializeOsSpecificCaps();
void setupFp64Flags();

55
opencl/source/cl_device/cl_device_caps.cpp
View File

@ -30,8 +30,6 @@ static std::string spirVersions = "1.2 ";
#define TOSTR(b) QTR(b)
static std::string driverVersion = TOSTR(NEO_OCL_DRIVER_VERSION);
const char *builtInKernels = ""; // the "always available" (extension-independent) builtin kernels
static constexpr cl_device_fp_config defaultFpFlags = static_cast<cl_device_fp_config>(CL_FP_ROUND_TO_NEAREST |
CL_FP_ROUND_TO_ZERO |
CL_FP_ROUND_TO_INF |
@ -106,17 +104,21 @@ void ClDevice::initializeCaps() {
case 30:
deviceInfo.clVersion = "OpenCL 3.0 NEO ";
deviceInfo.clCVersion = "OpenCL C 3.0 ";
deviceInfo.numericClVersion = CL_MAKE_VERSION(3, 0, 0);
break;
case 21:
deviceInfo.clVersion = "OpenCL 2.1 NEO ";
deviceInfo.clCVersion = "OpenCL C 2.0 ";
deviceInfo.numericClVersion = CL_MAKE_VERSION(2, 1, 0);
break;
case 12:
default:
deviceInfo.clVersion = "OpenCL 1.2 NEO ";
deviceInfo.clCVersion = "OpenCL C 1.2 ";
deviceInfo.numericClVersion = CL_MAKE_VERSION(1, 2, 0);
break;
}
initializeOpenclCAllVersions();
deviceInfo.platformLP = (hwInfo.capabilityTable.supportsOcl21Features == false);
deviceInfo.spirVersions = spirVersions.c_str();
auto supportsVme = hwInfo.capabilityTable.supportsVme;
@ -196,16 +198,23 @@ void ClDevice::initializeCaps() {
deviceInfo.deviceExtensions = deviceExtensions.c_str();
exposedBuiltinKernels = builtInKernels;
std::vector<std::string> exposedBuiltinKernelsVector;
if (supportsVme) {
exposedBuiltinKernels.append("block_motion_estimate_intel;");
exposedBuiltinKernelsVector.push_back("block_motion_estimate_intel");
}
if (supportsAdvancedVme) {
auto advVmeKernels = "block_advanced_motion_estimate_check_intel;block_advanced_motion_estimate_bidirectional_check_intel;";
exposedBuiltinKernels.append(advVmeKernels);
exposedBuiltinKernelsVector.push_back("block_advanced_motion_estimate_check_intel");
exposedBuiltinKernelsVector.push_back("block_advanced_motion_estimate_bidirectional_check_intel");
}
for (auto builtInKernel : exposedBuiltinKernelsVector) {
exposedBuiltinKernels.append(builtInKernel);
exposedBuiltinKernels.append(";");
cl_name_version kernelNameVersion;
kernelNameVersion.version = CL_MAKE_VERSION(1, 0, 0);
strcpy_s(kernelNameVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, builtInKernel.c_str());
deviceInfo.builtInKernelsWithVersion.push_back(kernelNameVersion);
}
deviceInfo.builtInKernels = exposedBuiltinKernels.c_str();
deviceInfo.deviceType = CL_DEVICE_TYPE_GPU;
@ -386,6 +395,38 @@ void ClDevice::initializeCaps() {
}
initializeOsSpecificCaps();
std::stringstream deviceExtensionsStringStream{deviceExtensions};
std::vector<std::string> deviceExtensionsVector{
std::istream_iterator<std::string>{deviceExtensionsStringStream}, std::istream_iterator<std::string>{}};
for (auto deviceExtension : deviceExtensionsVector) {
cl_name_version deviceExtensionWithVersion;
deviceExtensionWithVersion.version = CL_MAKE_VERSION(1, 0, 0);
strcpy_s(deviceExtensionWithVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, deviceExtension.c_str());
deviceInfo.extensionsWithVersion.push_back(deviceExtensionWithVersion);
}
}
void ClDevice::initializeOpenclCAllVersions() {
cl_name_version openClCVersion;
strcpy_s(openClCVersion.name, CL_NAME_VERSION_MAX_NAME_SIZE, "OpenCL C");
openClCVersion.version = CL_MAKE_VERSION(1, 0, 0);
deviceInfo.openclCAllVersions.push_back(openClCVersion);
openClCVersion.version = CL_MAKE_VERSION(1, 1, 0);
deviceInfo.openclCAllVersions.push_back(openClCVersion);
openClCVersion.version = CL_MAKE_VERSION(1, 2, 0);
deviceInfo.openclCAllVersions.push_back(openClCVersion);
if (ocl21FeaturesEnabled) {
openClCVersion.version = CL_MAKE_VERSION(2, 0, 0);
deviceInfo.openclCAllVersions.push_back(openClCVersion);
}
if (enabledClVersion == 30) {
openClCVersion.version = CL_MAKE_VERSION(3, 0, 0);
deviceInfo.openclCAllVersions.push_back(openClCVersion);
}
}
} // namespace NEO

13
opencl/source/cl_device/cl_device_info.cpp
View File

@ -129,6 +129,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG >(src, srcSize, retSize); break;
case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: getCap<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT >(src, srcSize, retSize); break;
case CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT: getCap<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT >(src, srcSize, retSize); break;
case CL_DEVICE_NUMERIC_VERSION: getCap<CL_DEVICE_NUMERIC_VERSION >(src, srcSize, retSize); break;
case CL_DEVICE_OPENCL_C_VERSION: getStr<CL_DEVICE_OPENCL_C_VERSION >(src, srcSize, retSize); break;
case CL_DEVICE_PARENT_DEVICE: getCap<CL_DEVICE_PARENT_DEVICE >(src, srcSize, retSize); break;
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,
case CL_DEVICE_OPENCL_C_FEATURES:
retSize = srcSize = 0;
break;
case CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION:
src = deviceInfo.builtInKernelsWithVersion.data();
retSize = srcSize = deviceInfo.builtInKernelsWithVersion.size() * sizeof(cl_name_version);
break;
case CL_DEVICE_OPENCL_C_ALL_VERSIONS:
src = deviceInfo.openclCAllVersions.data();
retSize = srcSize = deviceInfo.openclCAllVersions.size() * sizeof(cl_name_version);
break;
case CL_DEVICE_EXTENSIONS_WITH_VERSION:
src = deviceInfo.extensionsWithVersion.data();
retSize = srcSize = deviceInfo.extensionsWithVersion.size() * sizeof(cl_name_version);
break;
default:
if (getDeviceInfoForImage(paramName, src, srcSize, retSize) && !getSharedDeviceInfo().imageSupport) {
src = &value;

6
opencl/source/cl_device/cl_device_info.h
View File

@ -9,11 +9,16 @@
#include "opencl/extensions/public/cl_ext_private.h"
#include <vector>
namespace NEO {
// clang-format off
struct ClDeviceInfo {
cl_name_version ilsWithVersion[1];
std::vector<cl_name_version> builtInKernelsWithVersion;
std::vector<cl_name_version> openclCAllVersions;
std::vector<cl_name_version> extensionsWithVersion;
cl_device_type deviceType;
size_t maxSliceCount;
size_t image3DMaxWidth;
@ -50,6 +55,7 @@ struct ClDeviceInfo {
double platformHostTimerResolution;
size_t planarYuvMaxWidth;
size_t planarYuvMaxHeight;
cl_version numericClVersion;
cl_uint maxComputUnits;
cl_uint maxWorkItemDimensions;
cl_uint maxNumOfSubGroups;

1
opencl/source/cl_device/cl_device_info_map.h
View File

@ -129,6 +129,7 @@ template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT > :
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::nativeVectorWidthLong> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::nativeVectorWidthShort> {};
template<> struct Map<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT > : public ClMapBase<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, uint32_t, &ClDeviceInfo::nonUniformWorkGroupSupport> {};
template<> struct Map<CL_DEVICE_NUMERIC_VERSION > : public ClMapBase<CL_DEVICE_NUMERIC_VERSION, uint32_t, &ClDeviceInfo::numericClVersion> {};
template<> struct Map<CL_DEVICE_OPENCL_C_VERSION > : public ClMapBase<CL_DEVICE_OPENCL_C_VERSION, const char *, &ClDeviceInfo::clCVersion> {};
template<> struct Map<CL_DEVICE_PARENT_DEVICE > : public ClMapBase<CL_DEVICE_PARENT_DEVICE, cl_device_id, &ClDeviceInfo::parentDevice> {};
template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN > : public ClMapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN, uint64_t, &ClDeviceInfo::partitionAffinityDomain> {};

101
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@ -16,6 +16,7 @@
#include "opencl/test/unit_test/helpers/hw_helper_tests.h"
#include "opencl/test/unit_test/mocks/mock_builtins.h"
#include "opencl/test/unit_test/mocks/mock_execution_environment.h"
#include "opencl/test/unit_test/mocks/ult_cl_device_factory.h"
#include "driver_version.h"
#include "gtest/gtest.h"
@ -41,6 +42,34 @@ struct DeviceGetCapsTest : public ::testing::Test {
MockSipData::calledType = SipKernelType::COUNT;
MockSipData::called = false;
}
void verifyOpenclCAllVersions(MockClDevice &clDevice) {
auto openclCWithVersion = clDevice.getDeviceInfo().openclCAllVersions.begin();
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), openclCWithVersion->version);
openclCWithVersion++;
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 1u, 0u), openclCWithVersion->version);
openclCWithVersion++;
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), openclCWithVersion->version);
openclCWithVersion++;
if (clDevice.areOcl21FeaturesEnabled()) {
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(2u, 0u, 0u), openclCWithVersion->version);
openclCWithVersion++;
}
if (clDevice.getEnabledClVersion() == 30) {
EXPECT_STREQ("OpenCL C", openclCWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(3u, 0u, 0u), openclCWithVersion->version);
openclCWithVersion++;
}
EXPECT_EQ(clDevice.getDeviceInfo().openclCAllVersions.end(), openclCWithVersion);
}
};
TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
@ -63,6 +92,9 @@ TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
EXPECT_NE(nullptr, caps.profile);
EXPECT_NE(nullptr, caps.clVersion);
EXPECT_NE(nullptr, caps.clCVersion);
EXPECT_NE(0u, caps.numericClVersion);
EXPECT_GT(caps.openclCAllVersions.size(), 0u);
EXPECT_GT(caps.extensionsWithVersion.size(), 0u);
EXPECT_NE(nullptr, caps.spirVersions);
EXPECT_NE(nullptr, caps.deviceExtensions);
@ -266,7 +298,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion30WhenCapsAreCreatedThenDeviceRepo
const auto &caps = device->getDeviceInfo();
EXPECT_STREQ("OpenCL 3.0 NEO ", caps.clVersion);
EXPECT_STREQ("OpenCL C 3.0 ", caps.clCVersion);
EXPECT_EQ(CL_MAKE_VERSION(3u, 0u, 0u), caps.numericClVersion);
EXPECT_FALSE(device->ocl21FeaturesEnabled);
verifyOpenclCAllVersions(*device);
}
TEST_F(DeviceGetCapsTest, givenForceOclVersion21WhenCapsAreCreatedThenDeviceReportsOpenCL21) {
@ -276,7 +310,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion21WhenCapsAreCreatedThenDeviceRepo
const auto &caps = device->getDeviceInfo();
EXPECT_STREQ("OpenCL 2.1 NEO ", caps.clVersion);
EXPECT_STREQ("OpenCL C 2.0 ", caps.clCVersion);
EXPECT_EQ(CL_MAKE_VERSION(2u, 1u, 0u), caps.numericClVersion);
EXPECT_TRUE(device->ocl21FeaturesEnabled);
verifyOpenclCAllVersions(*device);
}
TEST_F(DeviceGetCapsTest, givenForceOclVersion12WhenCapsAreCreatedThenDeviceReportsOpenCL12) {
@ -286,7 +322,9 @@ TEST_F(DeviceGetCapsTest, givenForceOclVersion12WhenCapsAreCreatedThenDeviceRepo
const auto &caps = device->getDeviceInfo();
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), caps.numericClVersion);
EXPECT_FALSE(device->ocl21FeaturesEnabled);
verifyOpenclCAllVersions(*device);
}
TEST_F(DeviceGetCapsTest, givenForceOCL21FeaturesSupportEnabledWhenCapsAreCreatedThenDeviceReportsSupportOfOcl21Features) {
@ -315,14 +353,15 @@ TEST_F(DeviceGetCapsTest, givenForceOcl30AndForceOCL21FeaturesSupportEnabledWhen
TEST_F(DeviceGetCapsTest, givenForceInvalidOclVersionWhenCapsAreCreatedThenDeviceWillDefaultToOpenCL12) {
DebugManagerStateRestore dbgRestorer;
{
DebugManager.flags.ForceOCLVersion.set(1);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
const auto &caps = device->getDeviceInfo();
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
DebugManager.flags.ForceOCLVersion.set(0);
}
DebugManager.flags.ForceOCLVersion.set(1);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
const auto &caps = device->getDeviceInfo();
EXPECT_STREQ("OpenCL 1.2 NEO ", caps.clVersion);
EXPECT_STREQ("OpenCL C 1.2 ", caps.clCVersion);
EXPECT_EQ(CL_MAKE_VERSION(1u, 2u, 0u), caps.numericClVersion);
EXPECT_FALSE(device->ocl21FeaturesEnabled);
verifyOpenclCAllVersions(*device);
}
TEST_F(DeviceGetCapsTest, givenForce32bitAddressingWhenCapsAreCreatedThenDeviceReports32bitAddressingOptimization) {
@ -738,6 +777,38 @@ TEST_F(DeviceGetCapsTest, WhenDeviceIsCreatedThenVmeIsEnabled) {
EXPECT_TRUE(freshDebugSettingsManager.flags.EnableIntelVme.get());
}
TEST_F(DeviceGetCapsTest, givenVmeRelatedFlagsSetWhenCapsAreCreatedThenDeviceReportCorrectBuiltins) {
DebugManagerStateRestore dbgRestorer;
for (auto isVmeEnabled : ::testing::Bool()) {
DebugManager.flags.EnableIntelVme.set(isVmeEnabled);
for (auto isAdvancedVmeEnabled : ::testing::Bool()) {
DebugManager.flags.EnableIntelAdvancedVme.set(isAdvancedVmeEnabled);
UltClDeviceFactory deviceFactory{1, 0};
const auto &caps = deviceFactory.rootDevices[0]->getDeviceInfo();
auto builtInKernelWithVersion = caps.builtInKernelsWithVersion.begin();
if (isVmeEnabled) {
EXPECT_STREQ("block_motion_estimate_intel", builtInKernelWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
builtInKernelWithVersion++;
}
if (isAdvancedVmeEnabled) {
EXPECT_STREQ("block_advanced_motion_estimate_check_intel", builtInKernelWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
builtInKernelWithVersion++;
EXPECT_STREQ("block_advanced_motion_estimate_bidirectional_check_intel", builtInKernelWithVersion->name);
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), builtInKernelWithVersion->version);
builtInKernelWithVersion++;
}
EXPECT_EQ(caps.builtInKernelsWithVersion.end(), builtInKernelWithVersion);
}
}
}
TEST_F(DeviceGetCapsTest, WhenDeviceIsCreatedThenPriorityHintsExtensionIsReported) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
const auto &caps = device->getDeviceInfo();
@ -871,6 +942,20 @@ TEST_F(DeviceGetCapsTest, givenDeviceWhenGettingHostUnifiedMemoryCapThenItDepend
EXPECT_EQ((localMemoryEnabled == false), caps.hostUnifiedMemory);
}
TEST_F(DeviceGetCapsTest, givenDefaultDeviceWhenQueriedForExtensionsWithVersionThenValuesMatchWithExtensionsString) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
std::string allExtensions;
for (auto extensionWithVersion : pClDevice->getDeviceInfo().extensionsWithVersion) {
EXPECT_EQ(CL_MAKE_VERSION(1u, 0u, 0u), extensionWithVersion.version);
allExtensions += extensionWithVersion.name;
allExtensions += " ";
}
EXPECT_STREQ(pClDevice->deviceExtensions.c_str(), allExtensions.c_str());
}
TEST(DeviceGetCaps, givenDeviceThatDoesntHaveFp64WhenDbgFlagEnablesFp64ThenReportFp64Flags) {
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.OverrideDefaultFP64Settings.set(1);

47
opencl/test/unit_test/device/get_device_info_size_tests.cpp
View File

@ -10,6 +10,7 @@
#include "opencl/source/cl_device/cl_device_info_map.h"
#include "opencl/test/unit_test/fixtures/device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_platform.h"
#include "opencl/test/unit_test/mocks/ult_cl_device_factory.h"
#include "gtest/gtest.h"
@ -44,12 +45,14 @@ TEST_P(GetDeviceInfoSize, sizeIsValid) {
std::pair<uint32_t, size_t> deviceInfoParams2[] = {
{CL_DEVICE_ADDRESS_BITS, sizeof(cl_uint)},
{CL_DEVICE_AVAILABLE, sizeof(cl_bool)},
// {CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION, sizeof(cl_name_version[])},
{CL_DEVICE_COMPILER_AVAILABLE, sizeof(cl_bool)},
{CL_DEVICE_DOUBLE_FP_CONFIG, sizeof(cl_device_fp_config)},
{CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool)},
{CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(cl_bool)},
{CL_DEVICE_EXECUTION_CAPABILITIES, sizeof(cl_device_exec_capabilities)},
// {CL_DEVICE_EXTENSIONS, sizeof(char[])},
// {CL_DEVICE_EXTENSIONS_WITH_VERSION, sizeof(cl_name_version[])},
{CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof(cl_ulong)},
{CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof(cl_device_mem_cache_type)},
{CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, sizeof(cl_uint)},
@ -84,6 +87,8 @@ std::pair<uint32_t, size_t> deviceInfoParams2[] = {
{CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, sizeof(cl_uint)},
{CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint)},
{CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, sizeof(cl_uint)},
{CL_DEVICE_NUMERIC_VERSION, sizeof(cl_version)},
// {CL_DEVICE_OPENCL_C_ALL_VERSIONS, sizeof(cl_name_version[])},
{CL_DEVICE_OPENCL_C_FEATURES, 0u},
// {CL_DEVICE_OPENCL_C_VERSION, sizeof(char[])},
{CL_DEVICE_PARENT_DEVICE, sizeof(cl_device_id)},
@ -238,3 +243,45 @@ TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForDeviceVersionThenProperSiz
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForBuiltInKernelsWithVersionThenProperSizeIsReturned) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
size_t sizeReturned = 0;
auto retVal = pClDevice->getDeviceInfo(
CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION,
0,
nullptr,
&sizeReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pClDevice->getDeviceInfo().builtInKernelsWithVersion.size() * sizeof(cl_name_version), sizeReturned);
}
TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForOpenclCAllVersionsThenProperSizeIsReturned) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
size_t sizeReturned = 0;
auto retVal = pClDevice->getDeviceInfo(
CL_DEVICE_OPENCL_C_ALL_VERSIONS,
0,
nullptr,
&sizeReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pClDevice->getDeviceInfo().openclCAllVersions.size() * sizeof(cl_name_version), sizeReturned);
}
TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForExtensionsWithVersionThenProperSizeIsReturned) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
size_t sizeReturned = 0;
auto retVal = pClDevice->getDeviceInfo(
CL_DEVICE_EXTENSIONS_WITH_VERSION,
0,
nullptr,
&sizeReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pClDevice->getDeviceInfo().extensionsWithVersion.size() * sizeof(cl_name_version), sizeReturned);
}

4
opencl/test/unit_test/device/get_device_info_tests.cpp
View File

@ -705,6 +705,7 @@ cl_device_info deviceInfoParams[] = {
CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL,
CL_DEVICE_AVC_ME_VERSION_INTEL,
CL_DEVICE_BUILT_IN_KERNELS,
CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION,
CL_DEVICE_COMPILER_AVAILABLE,
CL_DEVICE_IL_VERSION,
// NOT_SUPPORTED
@ -714,6 +715,7 @@ cl_device_info deviceInfoParams[] = {
CL_DEVICE_ERROR_CORRECTION_SUPPORT,
CL_DEVICE_EXECUTION_CAPABILITIES,
CL_DEVICE_EXTENSIONS,
CL_DEVICE_EXTENSIONS_WITH_VERSION,
CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE,
CL_DEVICE_GLOBAL_MEM_CACHE_SIZE,
CL_DEVICE_GLOBAL_MEM_CACHE_TYPE,
@ -751,6 +753,8 @@ cl_device_info deviceInfoParams[] = {
CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,
CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG,
CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT,
CL_DEVICE_NUMERIC_VERSION,
CL_DEVICE_OPENCL_C_ALL_VERSIONS,
CL_DEVICE_OPENCL_C_FEATURES,
CL_DEVICE_OPENCL_C_VERSION,
CL_DEVICE_PARENT_DEVICE,