ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-25 16:29:03 +00:00
Code Packages Projects Releases Wiki Activity

Reformat computeinfo/ tests

Browse Source
This commit is contained in:
Pierre Moreau
2020-05-07 17:19:07 +02:00
committed by Kévin Petit
parent f6b156d523
commit 0ed62b4fbe
2 changed files with 1018 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
test_conformance/computeinfo/extended_versioning.cpp
View File

@@ -24,7 +24,8 @@
using name_version_set = std::set<cl_name_version_khr>; using name_version_set = std::set<cl_name_version_khr>;
static bool operator<(const cl_name_version_khr& lhs, const cl_name_version_khr& rhs) static bool operator<(const cl_name_version_khr& lhs,
const cl_name_version_khr& rhs)
{ {
const int cmp = strcmp(lhs.name, rhs.name); const int cmp = strcmp(lhs.name, rhs.name);
if (0 == cmp) if (0 == cmp)
@@ -35,7 +36,8 @@ static bool operator<(const cl_name_version_khr& lhs, const cl_name_version_khr&
return cmp < 0; return cmp < 0;
} }
static bool operator==(const cl_name_version_khr& lhs, const cl_name_version_khr& rhs) static bool operator==(const cl_name_version_khr& lhs,
const cl_name_version_khr& rhs)
{ {
return (0 == strcmp(lhs.name, rhs.name)) && (lhs.version == rhs.version); return (0 == strcmp(lhs.name, rhs.name)) && (lhs.version == rhs.version);
} }
@@ -43,11 +45,14 @@ static bool operator==(const cl_name_version_khr& lhs, const cl_name_version_khr
/* Parse major and minor version numbers out of version_string according to /* Parse major and minor version numbers out of version_string according to
* format, which is a scanf-format with two %u specifiers, then compare the * format, which is a scanf-format with two %u specifiers, then compare the
* version to the major and minor versions of version_numeric */ * version to the major and minor versions of version_numeric */
static bool is_same_version(const char* const format, const char* const version_string, const cl_version_khr version_numeric) static bool is_same_version(const char* const format,
const char* const version_string,
const cl_version_khr version_numeric)
{ {
unsigned int string_major = 0; unsigned int string_major = 0;
unsigned int string_minor = 0; unsigned int string_minor = 0;
const int matched = sscanf(version_string, format, &string_major, &string_minor); const int matched =
sscanf(version_string, format, &string_major, &string_minor);
if (2 != matched) if (2 != matched)
{ {
@@ -61,11 +66,13 @@ static bool is_same_version(const char* const format, const char* const version_
return (string_major == numeric_major) && (string_minor == numeric_minor); return (string_major == numeric_major) && (string_minor == numeric_minor);
} }
static std::vector<char> get_platform_string(cl_platform_id platform, cl_platform_info name) static std::vector<char> get_platform_string(cl_platform_id platform,
cl_platform_info name)
{ {
size_t size{}; size_t size{};
cl_int err = clGetPlatformInfo(platform, name, 0, nullptr, &size); cl_int err = clGetPlatformInfo(platform, name, 0, nullptr, &size);
if (err != CL_SUCCESS) { if (err != CL_SUCCESS)
{
log_error("clGetPlatformInfo failed\n"); log_error("clGetPlatformInfo failed\n");
return {}; return {};
} }
@@ -73,7 +80,8 @@ static std::vector<char> get_platform_string(cl_platform_id platform, cl_platfor
std::vector<char> result(size); std::vector<char> result(size);
err = clGetPlatformInfo(platform, name, size, result.data(), nullptr); err = clGetPlatformInfo(platform, name, size, result.data(), nullptr);
if (err != CL_SUCCESS) { if (err != CL_SUCCESS)
{
log_error("clGetPlatformInfo failed\n"); log_error("clGetPlatformInfo failed\n");
return {}; return {};
} }
@@ -81,11 +89,13 @@ static std::vector<char> get_platform_string(cl_platform_id platform, cl_platfor
return result; return result;
} }
static std::vector<char> get_device_string(cl_device_id device, cl_device_info name) static std::vector<char> get_device_string(cl_device_id device,
cl_device_info name)
{ {
size_t size{}; size_t size{};
cl_int err = clGetDeviceInfo(device, name, 0, nullptr, &size); cl_int err = clGetDeviceInfo(device, name, 0, nullptr, &size);
if (err != CL_SUCCESS) { if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return {}; return {};
} }
@@ -93,7 +103,8 @@ static std::vector<char> get_device_string(cl_device_id device, cl_device_info n
std::vector<char> result(size); std::vector<char> result(size);
err = clGetDeviceInfo(device, name, size, result.data(), nullptr); err = clGetDeviceInfo(device, name, size, result.data(), nullptr);
if (err != CL_SUCCESS) { if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return {}; return {};
} }
@@ -101,13 +112,16 @@ static std::vector<char> get_device_string(cl_device_id device, cl_device_info n
return result; return result;
} }
/* Parse an extension string into a cl_name_version_khr set. Error out if we have /* Parse an extension string into a cl_name_version_khr set. Error out if we
* an invalid extension string */ * have an invalid extension string */
static bool name_version_set_from_extension_string(char* const src, name_version_set& dest) static bool name_version_set_from_extension_string(char* const src,
name_version_set& dest)
{ {
for (char* token = strtok(src, " "); nullptr != token; token = strtok(nullptr, " ")) for (char* token = strtok(src, " "); nullptr != token;
token = strtok(nullptr, " "))
{ {
if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(token)) { if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(token))
{
log_error("Extension name is longer than allowed\n"); log_error("Extension name is longer than allowed\n");
return false; return false;
} }
@@ -115,7 +129,8 @@ static bool name_version_set_from_extension_string(char* const src, name_version
cl_name_version_khr name_version{}; cl_name_version_khr name_version{};
strncpy(name_version.name, token, CL_NAME_VERSION_MAX_NAME_SIZE_KHR); strncpy(name_version.name, token, CL_NAME_VERSION_MAX_NAME_SIZE_KHR);
if (dest.find(name_version) != dest.cend()) { if (dest.find(name_version) != dest.cend())
{
log_error("Duplicate extension in extension string\n"); log_error("Duplicate extension in extension string\n");
return false; return false;
} }
@@ -126,13 +141,16 @@ static bool name_version_set_from_extension_string(char* const src, name_version
return true; return true;
} }
/* Parse a built-in kernels string into a cl_name_version_khr set. Error out if we /* Parse a built-in kernels string into a cl_name_version_khr set. Error out if
* have an invalid built-in kernels string */ * we have an invalid built-in kernels string */
static bool name_version_set_from_built_in_kernel_string(char* const src, name_version_set& dest) static bool name_version_set_from_built_in_kernel_string(char* const src,
name_version_set& dest)
{ {
for (char* token = strtok(src, ";"); nullptr != token; token = strtok(nullptr, ";")) for (char* token = strtok(src, ";"); nullptr != token;
token = strtok(nullptr, ";"))
{ {
if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(token)) { if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(token))
{
log_error("Kernel name is longer than allowed\n"); log_error("Kernel name is longer than allowed\n");
return false; return false;
} }
@@ -140,7 +158,8 @@ static bool name_version_set_from_built_in_kernel_string(char* const src, name_v
cl_name_version_khr name_version{}; cl_name_version_khr name_version{};
strncpy(name_version.name, token, CL_NAME_VERSION_MAX_NAME_SIZE_KHR); strncpy(name_version.name, token, CL_NAME_VERSION_MAX_NAME_SIZE_KHR);
if (dest.find(name_version) != dest.cend()) { if (dest.find(name_version) != dest.cend())
{
log_error("Duplicate kernel name in kernel string\n"); log_error("Duplicate kernel name in kernel string\n");
return false; return false;
} }
@@ -151,14 +170,14 @@ static bool name_version_set_from_built_in_kernel_string(char* const src, name_v
return true; return true;
} }
/* Helper to log the names of elements of the set difference of two cl_name_version_khr sets */ /* Helper to log the names of elements of the set difference of two
static void log_name_only_set_difference(const name_version_set& lhs, const name_version_set& rhs) * cl_name_version_khr sets */
static void log_name_only_set_difference(const name_version_set& lhs,
const name_version_set& rhs)
{ {
std::vector<cl_name_version_khr> difference; std::vector<cl_name_version_khr> difference;
std::set_difference( std::set_difference(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend(),
lhs.cbegin(), lhs.cend(), std::back_inserter(difference));
rhs.cbegin(), rhs.cend(),
std::back_inserter(difference));
for (const cl_name_version_khr& il : difference) for (const cl_name_version_khr& il : difference)
{ {
@@ -168,13 +187,12 @@ static void log_name_only_set_difference(const name_version_set& lhs, const name
/* Helper to log as IL versions the elements of the set difference of two /* Helper to log as IL versions the elements of the set difference of two
* cl_name_version_khr sets */ * cl_name_version_khr sets */
static void log_il_set_difference(const name_version_set& lhs, const name_version_set& rhs) static void log_il_set_difference(const name_version_set& lhs,
const name_version_set& rhs)
{ {
std::vector<cl_name_version_khr> difference; std::vector<cl_name_version_khr> difference;
std::set_difference( std::set_difference(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend(),
lhs.cbegin(), lhs.cend(), std::back_inserter(difference));
rhs.cbegin(), rhs.cend(),
std::back_inserter(difference));
for (const cl_name_version_khr& il : difference) for (const cl_name_version_khr& il : difference)
{ {
@@ -184,27 +202,35 @@ static void log_il_set_difference(const name_version_set& lhs, const name_versio
} }
} }
/* Check that CL_PLATFORM_NUMERIC_VERSION_KHR returns the same version as CL_PLATFORM_VERSION */ /* Check that CL_PLATFORM_NUMERIC_VERSION_KHR returns the same version as
* CL_PLATFORM_VERSION */
static int test_extended_versioning_platform_version(cl_platform_id platform) static int test_extended_versioning_platform_version(cl_platform_id platform)
{ {
log_info("Platform versions:\n"); log_info("Platform versions:\n");
const std::vector<char> version_string(get_platform_string(platform, CL_PLATFORM_VERSION)); const std::vector<char> version_string(
if (version_string.empty()) { get_platform_string(platform, CL_PLATFORM_VERSION));
if (version_string.empty())
{
log_error("Could not get CL platform version string\n"); log_error("Could not get CL platform version string\n");
return 1; return 1;
} }
cl_version_khr version_numeric {}; cl_version_khr version_numeric{};
cl_int err = clGetPlatformInfo(platform, CL_PLATFORM_NUMERIC_VERSION_KHR, sizeof(version_numeric), &version_numeric, nullptr); cl_int err =
if (err != CL_SUCCESS) { clGetPlatformInfo(platform, CL_PLATFORM_NUMERIC_VERSION_KHR,
sizeof(version_numeric), &version_numeric, nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetPlatformInfo failed\n"); log_error("clGetPlatformInfo failed\n");
return 1; return 1;
} }
if (!is_same_version("OpenCL %u.%u", version_string.data(), version_numeric)) if (!is_same_version("OpenCL %u.%u", version_string.data(),
version_numeric))
{ {
log_error("Numeric platform version does not match the version string\n"); log_error(
"Numeric platform version does not match the version string\n");
return 1; return 1;
} }
@@ -213,38 +239,48 @@ static int test_extended_versioning_platform_version(cl_platform_id platform)
return 0; return 0;
} }
/* Check that CL_DEVICE{,_OPENCL_C}_NUMERIC_VERSION_KHR return the same versions as CL_DEVICE{,_OPENCL_C}_VERSION */ /* Check that CL_DEVICE{,_OPENCL_C}_NUMERIC_VERSION_KHR return the same versions
* as CL_DEVICE{,_OPENCL_C}_VERSION */
static int test_extended_versioning_device_versions(cl_device_id deviceID) static int test_extended_versioning_device_versions(cl_device_id deviceID)
{ {
log_info("Device versions:\n"); log_info("Device versions:\n");
static constexpr struct { static constexpr struct
{
cl_platform_info param_name_numeric; cl_platform_info param_name_numeric;
cl_platform_info param_name_string; cl_platform_info param_name_string;
const char* format; const char* format;
} device_version_queries[] { } device_version_queries[]{
{ CL_DEVICE_NUMERIC_VERSION_KHR, CL_DEVICE_VERSION, "OpenCL %u.%u" }, { CL_DEVICE_NUMERIC_VERSION_KHR, CL_DEVICE_VERSION, "OpenCL %u.%u" },
{ CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, CL_DEVICE_OPENCL_C_VERSION, "OpenCL C %u.%u" }, { CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, CL_DEVICE_OPENCL_C_VERSION,
"OpenCL C %u.%u" },
}; };
for (const auto& query : device_version_queries) for (const auto& query : device_version_queries)
{ {
const std::vector<char> version_string(get_device_string(deviceID, query.param_name_string)); const std::vector<char> version_string(
if (version_string.empty()) { get_device_string(deviceID, query.param_name_string));
if (version_string.empty())
{
log_error("Could not get CL platform version string\n"); log_error("Could not get CL platform version string\n");
return 1; return 1;
} }
cl_version_khr version_numeric {}; cl_version_khr version_numeric{};
cl_int err = clGetDeviceInfo(deviceID, query.param_name_numeric, sizeof(version_numeric), &version_numeric, nullptr); cl_int err =
if (err != CL_SUCCESS) { clGetDeviceInfo(deviceID, query.param_name_numeric,
sizeof(version_numeric), &version_numeric, nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
if (!is_same_version(query.format, version_string.data(), version_numeric)) if (!is_same_version(query.format, version_string.data(),
version_numeric))
{ {
log_error("Numeric device version does not match the version string\n"); log_error(
"Numeric device version does not match the version string\n");
return 1; return 1;
} }
} }
@@ -254,33 +290,43 @@ static int test_extended_versioning_device_versions(cl_device_id deviceID)
return 0; return 0;
} }
/* Check that the platform extension string and name_version queries return the same set */ /* Check that the platform extension string and name_version queries return the
* same set */
static int test_extended_versioning_platform_extensions(cl_platform_id platform) static int test_extended_versioning_platform_extensions(cl_platform_id platform)
{ {
log_info("Platform extensions:\n"); log_info("Platform extensions:\n");
std::vector<char> extension_string { get_platform_string(platform, CL_PLATFORM_EXTENSIONS) }; std::vector<char> extension_string{ get_platform_string(
if (extension_string.empty()) { platform, CL_PLATFORM_EXTENSIONS) };
if (extension_string.empty())
{
log_error("Could not get CL platform extensions string\n"); log_error("Could not get CL platform extensions string\n");
return 1; return 1;
} }
size_t size{}; size_t size{};
cl_int err = clGetPlatformInfo(platform, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, 0, nullptr, &size); cl_int err = clGetPlatformInfo(
if (err != CL_SUCCESS) { platform, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, 0, nullptr, &size);
if (err != CL_SUCCESS)
{
log_error("clGetPlatformInfo failed\n"); log_error("clGetPlatformInfo failed\n");
return 1; return 1;
} }
if ((size % sizeof(cl_name_version_khr)) != 0) { if ((size % sizeof(cl_name_version_khr)) != 0)
log_error("CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR return size not a multiple of sizeof(cl_name_version_khr)\n"); {
log_error("CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR return size not a "
"multiple of sizeof(cl_name_version_khr)\n");
return 1; return 1;
} }
const size_t extension_name_vers_count = size / sizeof(cl_name_version_khr); const size_t extension_name_vers_count = size / sizeof(cl_name_version_khr);
std::vector<cl_name_version_khr> extension_name_vers(extension_name_vers_count); std::vector<cl_name_version_khr> extension_name_vers(
extension_name_vers_count);
err = clGetPlatformInfo(platform, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, size, extension_name_vers.data(), nullptr); err = clGetPlatformInfo(platform, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR,
if (err != CL_SUCCESS) { size, extension_name_vers.data(), nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetPlatformInfo failed\n"); log_error("clGetPlatformInfo failed\n");
return 1; return 1;
} }
@@ -288,11 +334,14 @@ static int test_extended_versioning_platform_extensions(cl_platform_id platform)
name_version_set extension_name_vers_set; name_version_set extension_name_vers_set;
for (const auto& extension : extension_name_vers) for (const auto& extension : extension_name_vers)
{ {
/* Extension string doesn't have versions, so set it to all zeroes for matching */ /* Extension string doesn't have versions, so set it to all zeroes for
* matching */
cl_name_version_khr name_version = extension; cl_name_version_khr name_version = extension;
name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0); name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0);
if (extension_name_vers_set.find(name_version) != extension_name_vers_set.cend()) { if (extension_name_vers_set.find(name_version)
!= extension_name_vers_set.cend())
{
log_error("Duplicate extension in extension name-version array\n"); log_error("Duplicate extension in extension name-version array\n");
return 1; return 1;
} }
@@ -301,18 +350,23 @@ static int test_extended_versioning_platform_extensions(cl_platform_id platform)
} }
name_version_set extension_string_set; name_version_set extension_string_set;
if (!name_version_set_from_extension_string(extension_string.data(), extension_string_set)) { if (!name_version_set_from_extension_string(extension_string.data(),
extension_string_set))
{
log_error("Failed to parse platform extension string\n"); log_error("Failed to parse platform extension string\n");
return 1; return 1;
} }
if (extension_string_set != extension_name_vers_set) { if (extension_string_set != extension_name_vers_set)
{
log_error("Platform extension mismatch\n"); log_error("Platform extension mismatch\n");
log_info("\tExtensions only in numeric:"); log_info("\tExtensions only in numeric:");
log_name_only_set_difference(extension_name_vers_set, extension_string_set); log_name_only_set_difference(extension_name_vers_set,
extension_string_set);
log_info("\n\tExtensions only in string:"); log_info("\n\tExtensions only in string:");
log_name_only_set_difference(extension_string_set, extension_name_vers_set); log_name_only_set_difference(extension_string_set,
extension_name_vers_set);
log_info("\n"); log_info("\n");
return 1; return 1;
@@ -323,33 +377,43 @@ static int test_extended_versioning_platform_extensions(cl_platform_id platform)
return 0; return 0;
} }
/* Check that the device extension string and name_version queries return the same set */ /* Check that the device extension string and name_version queries return the
* same set */
static int test_extended_versioning_device_extensions(cl_device_id device) static int test_extended_versioning_device_extensions(cl_device_id device)
{ {
log_info("Device extensions:\n"); log_info("Device extensions:\n");
std::vector<char> extension_string { get_device_string(device, CL_DEVICE_EXTENSIONS) }; std::vector<char> extension_string{ get_device_string(
if (extension_string.empty()) { device, CL_DEVICE_EXTENSIONS) };
if (extension_string.empty())
{
log_error("Could not get CL device extensions string\n"); log_error("Could not get CL device extensions string\n");
return 1; return 1;
} }
size_t size{}; size_t size{};
cl_int err = clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, 0, nullptr, &size); cl_int err = clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR,
if (err != CL_SUCCESS) { 0, nullptr, &size);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
if ((size % sizeof(cl_name_version_khr)) != 0) { if ((size % sizeof(cl_name_version_khr)) != 0)
log_error("CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR return size not a multiple of sizeof(cl_name_version_khr)\n"); {
log_error("CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR return size not a "
"multiple of sizeof(cl_name_version_khr)\n");
return 1; return 1;
} }
const size_t extension_name_vers_count = size / sizeof(cl_name_version_khr); const size_t extension_name_vers_count = size / sizeof(cl_name_version_khr);
std::vector<cl_name_version_khr> extension_name_vers(extension_name_vers_count); std::vector<cl_name_version_khr> extension_name_vers(
extension_name_vers_count);
err = clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, size, extension_name_vers.data(), nullptr); err = clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, size,
if (err != CL_SUCCESS) { extension_name_vers.data(), nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
@@ -357,11 +421,14 @@ static int test_extended_versioning_device_extensions(cl_device_id device)
name_version_set extension_name_vers_set; name_version_set extension_name_vers_set;
for (const auto& extension : extension_name_vers) for (const auto& extension : extension_name_vers)
{ {
/* Extension string doesn't have versions, so set it to all zeroes for matching */ /* Extension string doesn't have versions, so set it to all zeroes for
* matching */
cl_name_version_khr name_version = extension; cl_name_version_khr name_version = extension;
name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0); name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0);
if (extension_name_vers_set.find(name_version) != extension_name_vers_set.cend()) { if (extension_name_vers_set.find(name_version)
!= extension_name_vers_set.cend())
{
log_error("Duplicate extension in extension name-version array\n"); log_error("Duplicate extension in extension name-version array\n");
return 1; return 1;
} }
@@ -370,18 +437,23 @@ static int test_extended_versioning_device_extensions(cl_device_id device)
} }
name_version_set extension_string_set; name_version_set extension_string_set;
if (!name_version_set_from_extension_string(extension_string.data(), extension_string_set)) { if (!name_version_set_from_extension_string(extension_string.data(),
extension_string_set))
{
log_error("Failed to parse device extension string\n"); log_error("Failed to parse device extension string\n");
return 1; return 1;
} }
if (extension_string_set != extension_name_vers_set) { if (extension_string_set != extension_name_vers_set)
{
log_error("Device extension mismatch\n"); log_error("Device extension mismatch\n");
log_info("\tExtensions only in numeric:"); log_info("\tExtensions only in numeric:");
log_name_only_set_difference(extension_name_vers_set, extension_string_set); log_name_only_set_difference(extension_name_vers_set,
extension_string_set);
log_info("\n\tExtensions only in string:"); log_info("\n\tExtensions only in string:");
log_name_only_set_difference(extension_string_set, extension_name_vers_set); log_name_only_set_difference(extension_string_set,
extension_name_vers_set);
log_info("\n"); log_info("\n");
return 1; return 1;
@@ -398,54 +470,74 @@ static int test_extended_versioning_device_il(cl_device_id device)
log_info("Device ILs:\n"); log_info("Device ILs:\n");
size_t size{}; size_t size{};
cl_int err = clGetDeviceInfo(device, CL_DEVICE_ILS_WITH_VERSION_KHR, 0, nullptr, &size); cl_int err = clGetDeviceInfo(device, CL_DEVICE_ILS_WITH_VERSION_KHR, 0,
if (err != CL_SUCCESS) { nullptr, &size);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
if ((size % sizeof(cl_name_version_khr)) != 0) { if ((size % sizeof(cl_name_version_khr)) != 0)
log_error("CL_DEVICE_ILS_WITH_VERSION_KHR return size not a multiple of sizeof(cl_name_version_khr)\n"); {
log_error("CL_DEVICE_ILS_WITH_VERSION_KHR return size not a multiple "
"of sizeof(cl_name_version_khr)\n");
return 1; return 1;
} }
const size_t il_name_vers_count = size / sizeof(cl_name_version_khr); const size_t il_name_vers_count = size / sizeof(cl_name_version_khr);
std::vector<cl_name_version_khr> il_name_vers(il_name_vers_count); std::vector<cl_name_version_khr> il_name_vers(il_name_vers_count);
err = clGetDeviceInfo(device, CL_DEVICE_ILS_WITH_VERSION_KHR, size, il_name_vers.data(), nullptr); err = clGetDeviceInfo(device, CL_DEVICE_ILS_WITH_VERSION_KHR, size,
if (err != CL_SUCCESS) { il_name_vers.data(), nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
const bool has_khr_il_program = is_extension_available(device, "cl_khr_il_program"); const bool has_khr_il_program =
const bool has_core_il_program = get_device_cl_version(device) > Version(2, 0); is_extension_available(device, "cl_khr_il_program");
const bool has_core_il_program =
get_device_cl_version(device) > Version(2, 0);
// IL query should return an empty list if the device does not support IL programs // IL query should return an empty list if the device does not support IL
if (!(has_khr_il_program || has_core_il_program)) { // programs
if (!(has_khr_il_program || has_core_il_program))
{
const bool success = il_name_vers.empty(); const bool success = il_name_vers.empty();
if (!success) { if (!success)
log_error("No il_program support, but CL_DEVICE_ILS_WITH_VERSION_KHR returned a non-empty list\n"); {
log_error(
"No il_program support, but CL_DEVICE_ILS_WITH_VERSION_KHR "
"returned a non-empty list\n");
return 1; return 1;
} else { }
log_info("\tNo il_program support, and CL_DEVICE_ILS_WITH_VERSION_KHR correctly returned the empty list\n"); else
{
log_info(
"\tNo il_program support, and CL_DEVICE_ILS_WITH_VERSION_KHR "
"correctly returned the empty list\n");
return 0; return 0;
} }
} }
// Pick the core or extension version of the query parameter name // Pick the core or extension version of the query parameter name
const cl_device_info il_version_param_name = has_core_il_program ? CL_DEVICE_IL_VERSION : CL_DEVICE_IL_VERSION_KHR; const cl_device_info il_version_param_name =
has_core_il_program ? CL_DEVICE_IL_VERSION : CL_DEVICE_IL_VERSION_KHR;
std::vector<char> il_string { get_device_string(device, il_version_param_name) }; std::vector<char> il_string{ get_device_string(device,
if (il_string.empty()) { il_version_param_name) };
if (il_string.empty())
{
log_error("Couldn't get device IL string\n"); log_error("Couldn't get device IL string\n");
return 1; return 1;
} }
name_version_set il_string_set; name_version_set il_string_set;
char* saveptr_outer = nullptr; char* saveptr_outer = nullptr;
for (char* token = strtok_r(il_string.data(), " ", &saveptr_outer); nullptr != token; for (char* token = strtok_r(il_string.data(), " ", &saveptr_outer);
token = strtok_r(nullptr, " ", &saveptr_outer)) nullptr != token; token = strtok_r(nullptr, " ", &saveptr_outer))
{ {
char* saveptr_inner = nullptr; char* saveptr_inner = nullptr;
const char* const prefix = strtok_r(token, "_", &saveptr_inner); const char* const prefix = strtok_r(token, "_", &saveptr_inner);
@@ -454,11 +546,13 @@ static int test_extended_versioning_device_il(cl_device_id device)
unsigned major = 0; unsigned major = 0;
unsigned minor = 0; unsigned minor = 0;
const int matched = sscanf(version, "%u.%u", &major, &minor); const int matched = sscanf(version, "%u.%u", &major, &minor);
if (2 != matched) { if (2 != matched)
{
log_error("IL version string scan mismatch\n"); log_error("IL version string scan mismatch\n");
return 1; return 1;
} }
if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(prefix)) { if (CL_NAME_VERSION_MAX_NAME_SIZE_KHR <= strlen(prefix))
{
log_error("IL name longer than allowed\n"); log_error("IL name longer than allowed\n");
return 1; return 1;
} }
@@ -467,7 +561,8 @@ static int test_extended_versioning_device_il(cl_device_id device)
strncpy(name_version.name, prefix, CL_NAME_VERSION_MAX_NAME_SIZE_KHR); strncpy(name_version.name, prefix, CL_NAME_VERSION_MAX_NAME_SIZE_KHR);
name_version.version = CL_MAKE_VERSION_KHR(major, minor, 0); name_version.version = CL_MAKE_VERSION_KHR(major, minor, 0);
if (il_string_set.find(name_version) != il_string_set.end()) { if (il_string_set.find(name_version) != il_string_set.end())
{
log_error("Duplicate IL version in IL string\n"); log_error("Duplicate IL version in IL string\n");
return 1; return 1;
} }
@@ -484,7 +579,8 @@ static int test_extended_versioning_device_il(cl_device_id device)
cl_name_version_khr name_version = il; cl_name_version_khr name_version = il;
name_version.version = CL_MAKE_VERSION_KHR(major, minor, 0); name_version.version = CL_MAKE_VERSION_KHR(major, minor, 0);
if (il_name_vers_set.find(name_version) != il_name_vers_set.cend()) { if (il_name_vers_set.find(name_version) != il_name_vers_set.cend())
{
log_error("Duplicate IL in name-version array\n"); log_error("Duplicate IL in name-version array\n");
return 1; return 1;
} }
@@ -492,7 +588,8 @@ static int test_extended_versioning_device_il(cl_device_id device)
il_name_vers_set.insert(name_version); il_name_vers_set.insert(name_version);
} }
if (il_string_set != il_name_vers_set) { if (il_string_set != il_name_vers_set)
{
log_error("Device IL mismatch\n"); log_error("Device IL mismatch\n");
log_info("\tILs only in numeric:"); log_info("\tILs only in numeric:");
@@ -512,29 +609,37 @@ static int test_extended_versioning_device_il(cl_device_id device)
static int test_extended_versioning_device_built_in_kernels(cl_device_id device) static int test_extended_versioning_device_built_in_kernels(cl_device_id device)
{ {
log_info("Device built-in kernels:\n"); log_info("Device built-in kernels:\n");
std::vector<char> kernel_string { get_device_string(device, CL_DEVICE_BUILT_IN_KERNELS) }; std::vector<char> kernel_string{ get_device_string(
if (kernel_string.empty()) { device, CL_DEVICE_BUILT_IN_KERNELS) };
if (kernel_string.empty())
{
log_error("Could not get CL device extensions string\n"); log_error("Could not get CL device extensions string\n");
return 1; return 1;
} }
size_t size{}; size_t size{};
cl_int err = clGetDeviceInfo(device, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, 0, nullptr, &size); cl_int err = clGetDeviceInfo(
if (err != CL_SUCCESS) { device, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, 0, nullptr, &size);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
if ((size % sizeof(cl_name_version_khr)) != 0) { if ((size % sizeof(cl_name_version_khr)) != 0)
log_error("CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR return size not a multiple of sizeof(cl_name_version_khr)\n"); {
log_error("CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR return size not "
"a multiple of sizeof(cl_name_version_khr)\n");
return 1; return 1;
} }
const size_t kernel_name_vers_count = size / sizeof(cl_name_version_khr); const size_t kernel_name_vers_count = size / sizeof(cl_name_version_khr);
std::vector<cl_name_version_khr> kernel_name_vers(kernel_name_vers_count); std::vector<cl_name_version_khr> kernel_name_vers(kernel_name_vers_count);
err = clGetDeviceInfo(device, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, size, kernel_name_vers.data(), nullptr); err = clGetDeviceInfo(device, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR,
if (err != CL_SUCCESS) { size, kernel_name_vers.data(), nullptr);
if (err != CL_SUCCESS)
{
log_error("clGetDeviceInfo failed\n"); log_error("clGetDeviceInfo failed\n");
return 1; return 1;
} }
@@ -545,7 +650,9 @@ static int test_extended_versioning_device_built_in_kernels(cl_device_id device)
cl_name_version_khr name_version = kernel; cl_name_version_khr name_version = kernel;
name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0); name_version.version = CL_MAKE_VERSION_KHR(0, 0, 0);
if (kernel_name_vers_set.find(name_version) != kernel_name_vers_set.cend()) { if (kernel_name_vers_set.find(name_version)
!= kernel_name_vers_set.cend())
{
log_error("Duplicate kernel in kernel name-version array\n"); log_error("Duplicate kernel in kernel name-version array\n");
return 1; return 1;
} }
@@ -554,12 +661,15 @@ static int test_extended_versioning_device_built_in_kernels(cl_device_id device)
} }
name_version_set kernel_string_set; name_version_set kernel_string_set;
if (!name_version_set_from_built_in_kernel_string(kernel_string.data(), kernel_string_set)) { if (!name_version_set_from_built_in_kernel_string(kernel_string.data(),
kernel_string_set))
{
log_error("Failed to parse device kernel string\n"); log_error("Failed to parse device kernel string\n");
return 1; return 1;
} }
if (kernel_string_set != kernel_name_vers_set) { if (kernel_string_set != kernel_name_vers_set)
{
log_error("Device kernel mismatch\n"); log_error("Device kernel mismatch\n");
log_info("\tKernels only in numeric:"); log_info("\tKernels only in numeric:");
@@ -576,15 +686,19 @@ static int test_extended_versioning_device_built_in_kernels(cl_device_id device)
return 0; return 0;
} }
int test_extended_versioning(cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements) int test_extended_versioning(cl_device_id deviceID, cl_context context,
cl_command_queue ignoreQueue, int num_elements)
{ {
if (!is_extension_available(deviceID, "cl_khr_extended_versioning")) { if (!is_extension_available(deviceID, "cl_khr_extended_versioning"))
log_info("cl_khr_extended_versioning not supported. Skipping test...\n"); {
log_info(
"cl_khr_extended_versioning not supported. Skipping test...\n");
return 0; return 0;
} }
cl_platform_id platform; cl_platform_id platform;
cl_int err = clGetDeviceInfo(deviceID, CL_DEVICE_PLATFORM, sizeof(platform), &platform, nullptr); cl_int err = clGetDeviceInfo(deviceID, CL_DEVICE_PLATFORM, sizeof(platform),
&platform, nullptr);
test_error(err, "clGetDeviceInfo failed\n"); test_error(err, "clGetDeviceInfo failed\n");
int total_errors = 0; int total_errors = 0;

1323
test_conformance/computeinfo/main.cpp
View File

File diff suppressed because it is too large Load Diff