ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-20 14:39:01 +00:00
Code Packages Projects Releases Wiki Activity
Files
a43d96de6932520e8e67408f0869e864e0a7e9a1
OpenCL-CTS/test_common/harness/kernelHelpers.cpp
Chetan Mistry a43d96de69 Redesign clGetKernelArgInfo (#522) (#1056) 
* Improve Functionality of Harness

In the harness we previously were able to determine whether or
not a device supports the half or double data types, but doing so
required unintuitive function calls and would need to be repeated
per test.
A new pair of functions have been added which clearly state
what they do, and makes it easier to determine whether or not
a device supports the types.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* Remove Old GetKernelArgInfo Tests (#522)

In the API test suite we have 2 versions which test the
clGetKernelArgInfo API. As part of this ticket we are redesigning
the implementation of this test. This change removes all of
the old code and makes it so that the tests simply pass. A later
commit will add the redesigned test

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* Redesign GetKernelArgInfo (#522)

The previous test for this API consisted of 5K+ lines
of code which would define the test kernels and the
expected outputs from this API. This redesign
instead generates the kernels and expected outputs
leading to incresased maintanability and a significantly
reduce line-of-code count.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Address Review Comments

This commit does the following:
    1) Update the Copyright to 2021
    2) Fixes a typo in a comment
    3) Explicitly declares a vector variable
       (previously auto)
    4) Output subtest result after completion rather than
       all of them at the end

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Ensure Kernel Arguments do not exceed CL_DEVICE_MAX_PARAMETER_SIZE

As per upstream comments, this change ensures that the total
size of parameters passed into a kernel does not exceed the
limit specified by CL_DEVICE_MAX_PARAMETER_SIZE for the device
used.
Additionally this change replaces ASSERT_SUCCESS() with test_error()
as per upstream requests.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Address Image and Vector Failures

This change aligns vector 3 types to be sized 4.
Additionally it ensures that image arguments do not
have the address space qualifier specified because
they are by default in the __global space.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Ensure that the size of pipe arguments are correct

As mentioned in PR comments, the test previously assumed that
sizeof(char) == sizeof(pipe char). The Clang implementation
treats a pipe to take the same size as a pointer, which
is now reflected in the code.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Ensure that CL_DEVICE_MAX_PIPE_ARGS is not Exceeded

This commit refactors the code so that Pipes are handled
separately.
Additionally, it removes signed char and char signed as
scalar types to test and removes some redundent code
for modifiying the expected type when processing unsigned
scalar types.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Remove compatibility test from skip-list

There is a list of tests which should be skipped when
using an offline compiler. As get_kernel_arg_compatibility
has been removed, it should also be removed here.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>

* [SQUASH] Disable Pipe Tests

This change disables the Pipe tests for clGetKernelArgInfo
as pipe metadata is not accurately reported on clang
which leads to the pipe tests failing.

Signed-off-by: Chetankumar Mistry <chetan.mistry@arm.com>
2021-05-13 09:18:12 +01:00

1782 lines
61 KiB
C++
Raw Blame History

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "crc32.h"
#include "kernelHelpers.h"
#include "deviceInfo.h"
#include "errorHelpers.h"
#include "imageHelpers.h"
#include "typeWrappers.h"
#include "testHarness.h"
#include "parseParameters.h"
#include <cassert>
#include <vector>
#include <string>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <mutex>
#include <algorithm>
#if defined(_WIN32)
std::string slash = "\\";
#else
std::string slash = "/";
#endif
static std::mutex gCompilerMutex;
static cl_int get_first_device_id(const cl_context context,
cl_device_id &device);
long get_file_size(const std::string &fileName)
{
std::ifstream ifs(fileName.c_str(), std::ios::binary);
if (!ifs.good()) return 0;
// get length of file:
ifs.seekg(0, std::ios::end);
std::ios::pos_type length = ifs.tellg();
return static_cast<long>(length);
}
static std::string get_kernel_content(unsigned int numKernelLines,
const char *const *kernelProgram)
{
std::string kernel;
for (size_t i = 0; i < numKernelLines; ++i)
{
std::string chunk(kernelProgram[i], 0, std::string::npos);
kernel += chunk;
}
return kernel;
}
std::string get_kernel_name(const std::string &source)
{
// Create list of kernel names
std::string kernelsList;
size_t kPos = source.find("kernel");
while (kPos != std::string::npos)
{
// check for '__kernel'
size_t pos = kPos;
if (pos >= 2 && source[pos - 1] == '_' && source[pos - 2] == '_')
pos -= 2;
// check character before 'kernel' (white space expected)
size_t wsPos = source.find_last_of(" \t\r\n", pos);
if (wsPos == std::string::npos || wsPos + 1 == pos)
{
// check character after 'kernel' (white space expected)
size_t akPos = kPos + sizeof("kernel") - 1;
wsPos = source.find_first_of(" \t\r\n", akPos);
if (!(wsPos == akPos))
{
kPos = source.find("kernel", kPos + 1);
continue;
}
bool attributeFound;
do
{
attributeFound = false;
// find '(' after kernel name name
size_t pPos = source.find("(", akPos);
if (!(pPos != std::string::npos)) continue;
// check for not empty kernel name before '('
pos = source.find_last_not_of(" \t\r\n", pPos - 1);
if (!(pos != std::string::npos && pos > akPos)) continue;
// find character before kernel name
wsPos = source.find_last_of(" \t\r\n", pos);
if (!(wsPos != std::string::npos && wsPos >= akPos)) continue;
std::string name =
source.substr(wsPos + 1, pos + 1 - (wsPos + 1));
// check for kernel attribute
if (name == "__attribute__")
{
attributeFound = true;
int pCount = 1;
akPos = pPos + 1;
while (pCount > 0 && akPos != std::string::npos)
{
akPos = source.find_first_of("()", akPos + 1);
if (akPos != std::string::npos)
{
if (source[akPos] == '(')
pCount++;
else
pCount--;
}
}
}
else
{
kernelsList += name + ".";
}
} while (attributeFound);
}
kPos = source.find("kernel", kPos + 1);
}
std::ostringstream oss;
if (MAX_LEN_FOR_KERNEL_LIST > 0)
{
if (kernelsList.size() > MAX_LEN_FOR_KERNEL_LIST + 1)
{
kernelsList = kernelsList.substr(0, MAX_LEN_FOR_KERNEL_LIST + 1);
kernelsList[kernelsList.size() - 1] = '.';
kernelsList[kernelsList.size() - 1] = '.';
}
oss << kernelsList;
}
return oss.str();
}
static std::string
get_offline_compilation_file_type_str(const CompilationMode compilationMode)
{
switch (compilationMode)
{
default: assert(0 && "Invalid compilation mode"); abort();
case kOnline:
assert(0 && "Invalid compilation mode for offline compilation");
abort();
case kBinary: return "binary";
case kSpir_v: return "SPIR-V";
}
}
static std::string get_unique_filename_prefix(unsigned int numKernelLines,
const char *const *kernelProgram,
const char *buildOptions)
{
std::string kernel = get_kernel_content(numKernelLines, kernelProgram);
std::string kernelName = get_kernel_name(kernel);
cl_uint kernelCrc = crc32(kernel.data(), kernel.size());
std::ostringstream oss;
oss << kernelName << std::hex << std::setfill('0') << std::setw(8)
<< kernelCrc;
if (buildOptions)
{
cl_uint bOptionsCrc = crc32(buildOptions, strlen(buildOptions));
oss << '.' << std::hex << std::setfill('0') << std::setw(8)
<< bOptionsCrc;
}
return oss.str();
}
static std::string
get_cl_build_options_filename_with_path(const std::string &filePath,
const std::string &fileNamePrefix)
{
return filePath + slash + fileNamePrefix + ".options";
}
static std::string
get_cl_source_filename_with_path(const std::string &filePath,
const std::string &fileNamePrefix)
{
return filePath + slash + fileNamePrefix + ".cl";
}
static std::string
get_binary_filename_with_path(CompilationMode mode, cl_uint deviceAddrSpaceSize,
const std::string &filePath,
const std::string &fileNamePrefix)
{
std::string binaryFilename = filePath + slash + fileNamePrefix;
if (kSpir_v == mode)
{
std::ostringstream extension;
extension << ".spv" << deviceAddrSpaceSize;
binaryFilename += extension.str();
}
return binaryFilename;
}
static bool file_exist_on_disk(const std::string &filePath,
const std::string &fileName)
{
std::string fileNameWithPath = filePath + slash + fileName;
bool exist = false;
std::ifstream ifs;
ifs.open(fileNameWithPath.c_str(), std::ios::binary);
if (ifs.good()) exist = true;
ifs.close();
return exist;
}
static bool should_save_kernel_source_to_disk(CompilationMode mode,
CompilationCacheMode cacheMode,
const std::string &binaryPath,
const std::string &binaryName)
{
bool saveToDisk = false;
if (cacheMode == kCacheModeDumpCl
|| (cacheMode == kCacheModeOverwrite && mode != kOnline))
{
saveToDisk = true;
}
if (cacheMode == kCacheModeCompileIfAbsent && mode != kOnline)
{
saveToDisk = !file_exist_on_disk(binaryPath, binaryName);
}
return saveToDisk;
}
static int save_kernel_build_options_to_disk(const std::string &path,
const std::string &prefix,
const char *buildOptions)
{
std::string filename =
get_cl_build_options_filename_with_path(path, prefix);
std::ofstream ofs(filename.c_str(), std::ios::binary);
if (!ofs.good())
{
log_info("Can't save kernel build options: %s\n", filename.c_str());
return -1;
}
ofs.write(buildOptions, strlen(buildOptions));
ofs.close();
log_info("Saved kernel build options to file: %s\n", filename.c_str());
return CL_SUCCESS;
}
static int save_kernel_source_to_disk(const std::string &path,
const std::string &prefix,
const std::string &source)
{
std::string filename = get_cl_source_filename_with_path(path, prefix);
std::ofstream ofs(filename.c_str(), std::ios::binary);
if (!ofs.good())
{
log_info("Can't save kernel source: %s\n", filename.c_str());
return -1;
}
ofs.write(source.c_str(), source.size());
ofs.close();
log_info("Saved kernel source to file: %s\n", filename.c_str());
return CL_SUCCESS;
}
static int
save_kernel_source_and_options_to_disk(unsigned int numKernelLines,
const char *const *kernelProgram,
const char *buildOptions)
{
int error;
std::string kernel = get_kernel_content(numKernelLines, kernelProgram);
std::string kernelNamePrefix =
get_unique_filename_prefix(numKernelLines, kernelProgram, buildOptions);
// save kernel source to disk
error = save_kernel_source_to_disk(gCompilationCachePath, kernelNamePrefix,
kernel);
// save kernel build options to disk if exists
if (buildOptions != NULL)
error |= save_kernel_build_options_to_disk(
gCompilationCachePath, kernelNamePrefix, buildOptions);
return error;
}
static std::string
get_compilation_mode_str(const CompilationMode compilationMode)
{
switch (compilationMode)
{
default: assert(0 && "Invalid compilation mode"); abort();
case kOnline: return "online";
case kBinary: return "binary";
case kSpir_v: return "spir-v";
}
}
static cl_int get_cl_device_info_str(const cl_device_id device,
const cl_uint device_address_space_size,
const CompilationMode compilationMode,
std::string &clDeviceInfo)
{
std::string extensionsString = get_device_extensions_string(device);
std::string versionString = get_device_version_string(device);
std::ostringstream clDeviceInfoStream;
std::string file_type =
get_offline_compilation_file_type_str(compilationMode);
clDeviceInfoStream << "# OpenCL device info affecting " << file_type
<< " offline compilation:" << std::endl
<< "CL_DEVICE_ADDRESS_BITS=" << device_address_space_size
<< std::endl
<< "CL_DEVICE_EXTENSIONS=\"" << extensionsString << "\""
<< std::endl;
/* We only need the device's supported IL version(s) when compiling IL
* that will be loaded with clCreateProgramWithIL() */
if (compilationMode == kSpir_v)
{
std::string ilVersionString = get_device_il_version_string(device);
clDeviceInfoStream << "CL_DEVICE_IL_VERSION=\"" << ilVersionString
<< "\"" << std::endl;
}
clDeviceInfoStream << "CL_DEVICE_VERSION=\"" << versionString << "\""
<< std::endl;
clDeviceInfoStream << "CL_DEVICE_IMAGE_SUPPORT="
<< (0 == checkForImageSupport(device)) << std::endl;
clDeviceInfoStream << "CL_DEVICE_NAME=\"" << get_device_name(device).c_str()
<< "\"" << std::endl;
clDeviceInfo = clDeviceInfoStream.str();
return CL_SUCCESS;
}
static int write_cl_device_info(const cl_device_id device,
const cl_uint device_address_space_size,
const CompilationMode compilationMode,
std::string &clDeviceInfoFilename)
{
std::string clDeviceInfo;
int error = get_cl_device_info_str(device, device_address_space_size,
compilationMode, clDeviceInfo);
if (error != CL_SUCCESS)
{
return error;
}
cl_uint crc = crc32(clDeviceInfo.data(), clDeviceInfo.size());
/* Get the filename for the clDeviceInfo file.
* Note: the file includes the hash on its content, so it is usually
* unnecessary to delete it. */
std::ostringstream clDeviceInfoFilenameStream;
clDeviceInfoFilenameStream << gCompilationCachePath << slash
<< "clDeviceInfo-";
clDeviceInfoFilenameStream << std::hex << std::setfill('0') << std::setw(8)
<< crc << ".txt";
clDeviceInfoFilename = clDeviceInfoFilenameStream.str();
if ((size_t)get_file_size(clDeviceInfoFilename) == clDeviceInfo.size())
{
/* The CL device info file has already been created.
* Nothing to do. */
return 0;
}
/* The file does not exist or its length is not as expected.
* Create/overwrite it. */
std::ofstream ofs(clDeviceInfoFilename);
if (!ofs.good())
{
log_info("OfflineCompiler: can't create CL device info file: %s\n",
clDeviceInfoFilename.c_str());
return -1;
}
ofs << clDeviceInfo;
ofs.close();
return CL_SUCCESS;
}
static std::string get_offline_compilation_command(
const cl_uint device_address_space_size,
const CompilationMode compilationMode, const std::string &bOptions,
const std::string &sourceFilename, const std::string &outputFilename,
const std::string &clDeviceInfoFilename)
{
std::ostringstream wrapperOptions;
wrapperOptions << gCompilationProgram
<< " --mode=" << get_compilation_mode_str(compilationMode)
<< " --source=" << sourceFilename
<< " --output=" << outputFilename
<< " --cl-device-info=" << clDeviceInfoFilename;
if (bOptions != "")
{
// Add build options passed to this function
wrapperOptions << " -- " << bOptions;
}
return wrapperOptions.str();
}
static int invoke_offline_compiler(const cl_device_id device,
const cl_uint device_address_space_size,
const CompilationMode compilationMode,
const std::string &bOptions,
const std::string &sourceFilename,
const std::string &outputFilename)
{
std::string runString;
std::string clDeviceInfoFilename;
// See cl_offline_compiler-interface.txt for a description of the
// format of the CL device information file generated below, and
// the internal command line interface for invoking the offline
// compiler.
cl_int err = write_cl_device_info(device, device_address_space_size,
compilationMode, clDeviceInfoFilename);
if (err != CL_SUCCESS)
{
log_error("Failed writing CL device info file\n");
return err;
}
runString = get_offline_compilation_command(
device_address_space_size, compilationMode, bOptions, sourceFilename,
outputFilename, clDeviceInfoFilename);
// execute script
log_info("Executing command: %s\n", runString.c_str());
fflush(stdout);
int returnCode = system(runString.c_str());
if (returnCode != 0)
{
log_error("ERROR: Command finished with error: 0x%x\n", returnCode);
return CL_COMPILE_PROGRAM_FAILURE;
}
return CL_SUCCESS;
}
static cl_int get_first_device_id(const cl_context context,
cl_device_id &device)
{
cl_uint numDevices = 0;
cl_int error = clGetContextInfo(context, CL_CONTEXT_NUM_DEVICES,
sizeof(cl_uint), &numDevices, NULL);
test_error(error, "clGetContextInfo failed getting CL_CONTEXT_NUM_DEVICES");
if (numDevices == 0)
{
log_error("ERROR: No CL devices found\n");
return -1;
}
std::vector<cl_device_id> devices(numDevices, 0);
error =
clGetContextInfo(context, CL_CONTEXT_DEVICES,
numDevices * sizeof(cl_device_id), &devices[0], NULL);
test_error(error, "clGetContextInfo failed getting CL_CONTEXT_DEVICES");
device = devices[0];
return CL_SUCCESS;
}
static cl_int get_device_address_bits(const cl_device_id device,
cl_uint &device_address_space_size)
{
cl_int error =
clGetDeviceInfo(device, CL_DEVICE_ADDRESS_BITS, sizeof(cl_uint),
&device_address_space_size, NULL);
test_error(error, "Unable to obtain device address bits");
if (device_address_space_size != 32 && device_address_space_size != 64)
{
log_error("ERROR: Unexpected number of device address bits: %u\n",
device_address_space_size);
return -1;
}
return CL_SUCCESS;
}
static int get_offline_compiler_output(
std::ifstream &ifs, const cl_device_id device, cl_uint deviceAddrSpaceSize,
const CompilationMode compilationMode, const std::string &bOptions,
const std::string &kernelPath, const std::string &kernelNamePrefix)
{
std::string sourceFilename =
get_cl_source_filename_with_path(kernelPath, kernelNamePrefix);
std::string outputFilename = get_binary_filename_with_path(
compilationMode, deviceAddrSpaceSize, kernelPath, kernelNamePrefix);
ifs.open(outputFilename.c_str(), std::ios::binary);
if (!ifs.good())
{
std::string file_type =
get_offline_compilation_file_type_str(compilationMode);
if (gCompilationCacheMode == kCacheModeForceRead)
{
log_info("OfflineCompiler: can't open cached %s file: %s\n",
file_type.c_str(), outputFilename.c_str());
return -1;
}
else
{
int error = invoke_offline_compiler(device, deviceAddrSpaceSize,
compilationMode, bOptions,
sourceFilename, outputFilename);
if (error != CL_SUCCESS) return error;
// read output file
ifs.open(outputFilename.c_str(), std::ios::binary);
if (!ifs.good())
{
log_info("OfflineCompiler: can't read generated %s file: %s\n",
file_type.c_str(), outputFilename.c_str());
return -1;
}
}
}
return CL_SUCCESS;
}
static int create_single_kernel_helper_create_program_offline(
cl_context context, cl_device_id device, cl_program *outProgram,
unsigned int numKernelLines, const char *const *kernelProgram,
const char *buildOptions, CompilationMode compilationMode)
{
if (kCacheModeDumpCl == gCompilationCacheMode)
{
return -1;
}
// Get device CL_DEVICE_ADDRESS_BITS
int error;
cl_uint device_address_space_size = 0;
if (device == NULL)
{
error = get_first_device_id(context, device);
test_error(error, "Failed to get device ID for first device");
}
error = get_device_address_bits(device, device_address_space_size);
if (error != CL_SUCCESS) return error;
// set build options
std::string bOptions;
bOptions += buildOptions ? std::string(buildOptions) : "";
std::string kernelName =
get_unique_filename_prefix(numKernelLines, kernelProgram, buildOptions);
std::ifstream ifs;
error = get_offline_compiler_output(ifs, device, device_address_space_size,
compilationMode, bOptions,
gCompilationCachePath, kernelName);
if (error != CL_SUCCESS) return error;
ifs.seekg(0, ifs.end);
int length = ifs.tellg();
ifs.seekg(0, ifs.beg);
// treat modifiedProgram as input for clCreateProgramWithBinary
if (compilationMode == kBinary)
{
// read binary from file:
std::vector<unsigned char> modifiedKernelBuf(length);
ifs.read((char *)&modifiedKernelBuf[0], length);
ifs.close();
size_t lengths = modifiedKernelBuf.size();
const unsigned char *binaries = { &modifiedKernelBuf[0] };
log_info("offlineCompiler: clCreateProgramWithSource replaced with "
"clCreateProgramWithBinary\n");
*outProgram = clCreateProgramWithBinary(context, 1, &device, &lengths,
&binaries, NULL, &error);
if (*outProgram == NULL || error != CL_SUCCESS)
{
print_error(error, "clCreateProgramWithBinary failed");
return error;
}
}
// treat modifiedProgram as input for clCreateProgramWithIL
else if (compilationMode == kSpir_v)
{
// read spir-v from file:
std::vector<unsigned char> modifiedKernelBuf(length);
ifs.read((char *)&modifiedKernelBuf[0], length);
ifs.close();
size_t length = modifiedKernelBuf.size();
log_info("offlineCompiler: clCreateProgramWithSource replaced with "
"clCreateProgramWithIL\n");
if (gCoreILProgram)
{
*outProgram = clCreateProgramWithIL(context, &modifiedKernelBuf[0],
length, &error);
}
else
{
cl_platform_id platform;
error = clGetDeviceInfo(device, CL_DEVICE_PLATFORM,
sizeof(cl_platform_id), &platform, NULL);
test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed");
clCreateProgramWithILKHR_fn clCreateProgramWithILKHR = NULL;
clCreateProgramWithILKHR = (clCreateProgramWithILKHR_fn)
clGetExtensionFunctionAddressForPlatform(
platform, "clCreateProgramWithILKHR");
if (clCreateProgramWithILKHR == NULL)
{
log_error(
"ERROR: clGetExtensionFunctionAddressForPlatform failed\n");
return -1;
}
*outProgram = clCreateProgramWithILKHR(
context, &modifiedKernelBuf[0], length, &error);
}
if (*outProgram == NULL || error != CL_SUCCESS)
{
if (gCoreILProgram)
{
print_error(error, "clCreateProgramWithIL failed");
}
else
{
print_error(error, "clCreateProgramWithILKHR failed");
}
return error;
}
}
return CL_SUCCESS;
}
static int create_single_kernel_helper_create_program(
cl_context context, cl_device_id device, cl_program *outProgram,
unsigned int numKernelLines, const char **kernelProgram,
const char *buildOptions, CompilationMode compilationMode)
{
std::lock_guard<std::mutex> compiler_lock(gCompilerMutex);
std::string filePrefix =
get_unique_filename_prefix(numKernelLines, kernelProgram, buildOptions);
bool shouldSaveToDisk = should_save_kernel_source_to_disk(
compilationMode, gCompilationCacheMode, gCompilationCachePath,
filePrefix);
if (shouldSaveToDisk)
{
if (CL_SUCCESS
!= save_kernel_source_and_options_to_disk(
numKernelLines, kernelProgram, buildOptions))
{
log_error("Unable to dump kernel source to disk");
return -1;
}
}
if (compilationMode == kOnline)
{
int error = CL_SUCCESS;
/* Create the program object from source */
*outProgram = clCreateProgramWithSource(context, numKernelLines,
kernelProgram, NULL, &error);
if (*outProgram == NULL || error != CL_SUCCESS)
{
print_error(error, "clCreateProgramWithSource failed");
return error;
}
return CL_SUCCESS;
}
else
{
return create_single_kernel_helper_create_program_offline(
context, device, outProgram, numKernelLines, kernelProgram,
buildOptions, compilationMode);
}
}
int create_single_kernel_helper_create_program(cl_context context,
cl_program *outProgram,
unsigned int numKernelLines,
const char **kernelProgram,
const char *buildOptions)
{
return create_single_kernel_helper_create_program(
context, NULL, outProgram, numKernelLines, kernelProgram, buildOptions,
gCompilationMode);
}
int create_single_kernel_helper_create_program_for_device(
cl_context context, cl_device_id device, cl_program *outProgram,
unsigned int numKernelLines, const char **kernelProgram,
const char *buildOptions)
{
return create_single_kernel_helper_create_program(
context, device, outProgram, numKernelLines, kernelProgram,
buildOptions, gCompilationMode);
}
int create_single_kernel_helper_with_build_options(
cl_context context, cl_program *outProgram, cl_kernel *outKernel,
unsigned int numKernelLines, const char **kernelProgram,
const char *kernelName, const char *buildOptions)
{
return create_single_kernel_helper(context, outProgram, outKernel,
numKernelLines, kernelProgram,
kernelName, buildOptions);
}
// Creates and builds OpenCL C/C++ program, and creates a kernel
int create_single_kernel_helper(cl_context context, cl_program *outProgram,
cl_kernel *outKernel,
unsigned int numKernelLines,
const char **kernelProgram,
const char *kernelName,
const char *buildOptions)
{
// For the logic that automatically adds -cl-std it is much cleaner if the
// build options have RAII. This buffer will store the potentially updated
// build options, in which case buildOptions will point at the string owned
// by this buffer.
std::string build_options_internal{ buildOptions ? buildOptions : "" };
// Check the build options for the -cl-std option.
if (!buildOptions || !strstr(buildOptions, "-cl-std"))
{
// If the build option isn't present add it using the latest OpenCL-C
// version supported by the device. This allows calling code to force a
// particular CL C version if it is required, but also means that
// callers need not specify a version if they want to assume the most
// recent CL C.
auto version = get_max_OpenCL_C_for_context(context);
std::string cl_std{};
if (version >= Version(3, 0))
{
cl_std = "-cl-std=CL3.0";
}
else if (version >= Version(2, 0) && version < Version(3, 0))
{
cl_std = "-cl-std=CL2.0";
}
else
{
// If the -cl-std build option is not specified, the highest OpenCL
// C 1.x language version supported by each device is used when
// compiling the program for each device.
cl_std = "";
}
build_options_internal += ' ';
build_options_internal += cl_std;
buildOptions = build_options_internal.c_str();
}
int error = create_single_kernel_helper_create_program(
context, outProgram, numKernelLines, kernelProgram, buildOptions);
if (error != CL_SUCCESS)
{
log_error("Create program failed: %d, line: %d\n", error, __LINE__);
return error;
}
// Remove offline-compiler-only build options
std::string newBuildOptions;
if (buildOptions != NULL)
{
newBuildOptions = buildOptions;
std::string offlineCompierOptions[] = {
"-cl-fp16-enable", "-cl-fp64-enable", "-cl-zero-init-local-mem-vars"
};
for (auto &s : offlineCompierOptions)
{
std::string::size_type i = newBuildOptions.find(s);
if (i != std::string::npos) newBuildOptions.erase(i, s.length());
}
}
// Build program and create kernel
return build_program_create_kernel_helper(
context, outProgram, outKernel, numKernelLines, kernelProgram,
kernelName, newBuildOptions.c_str());
}
// Builds OpenCL C/C++ program and creates
int build_program_create_kernel_helper(
cl_context context, cl_program *outProgram, cl_kernel *outKernel,
unsigned int numKernelLines, const char **kernelProgram,
const char *kernelName, const char *buildOptions)
{
int error;
/* Compile the program */
int buildProgramFailed = 0;
int printedSource = 0;
error = clBuildProgram(*outProgram, 0, NULL, buildOptions, NULL, NULL);
if (error != CL_SUCCESS)
{
unsigned int i;
print_error(error, "clBuildProgram failed");
buildProgramFailed = 1;
printedSource = 1;
log_error("Build options: %s\n", buildOptions);
log_error("Original source is: ------------\n");
for (i = 0; i < numKernelLines; i++) log_error("%s", kernelProgram[i]);
}
// Verify the build status on all devices
cl_uint deviceCount = 0;
error = clGetProgramInfo(*outProgram, CL_PROGRAM_NUM_DEVICES,
sizeof(deviceCount), &deviceCount, NULL);
if (error != CL_SUCCESS)
{
print_error(error, "clGetProgramInfo CL_PROGRAM_NUM_DEVICES failed");
return error;
}
if (deviceCount == 0)
{
log_error("No devices found for program.\n");
return -1;
}
cl_device_id *devices =
(cl_device_id *)malloc(deviceCount * sizeof(cl_device_id));
if (NULL == devices) return -1;
BufferOwningPtr<cl_device_id> devicesBuf(devices);
memset(devices, 0, deviceCount * sizeof(cl_device_id));
error = clGetProgramInfo(*outProgram, CL_PROGRAM_DEVICES,
sizeof(cl_device_id) * deviceCount, devices, NULL);
if (error != CL_SUCCESS)
{
print_error(error, "clGetProgramInfo CL_PROGRAM_DEVICES failed");
return error;
}
cl_uint z;
bool buildFailed = false;
for (z = 0; z < deviceCount; z++)
{
char deviceName[4096] = "";
error = clGetDeviceInfo(devices[z], CL_DEVICE_NAME, sizeof(deviceName),
deviceName, NULL);
if (error != CL_SUCCESS || deviceName[0] == '\0')
{
log_error("Device \"%d\" failed to return a name\n", z);
print_error(error, "clGetDeviceInfo CL_DEVICE_NAME failed");
}
cl_build_status buildStatus;
error = clGetProgramBuildInfo(*outProgram, devices[z],
CL_PROGRAM_BUILD_STATUS,
sizeof(buildStatus), &buildStatus, NULL);
if (error != CL_SUCCESS)
{
print_error(error,
"clGetProgramBuildInfo CL_PROGRAM_BUILD_STATUS failed");
return error;
}
if (buildStatus == CL_BUILD_SUCCESS && buildProgramFailed
&& deviceCount == 1)
{
buildFailed = true;
log_error("clBuildProgram returned an error, but buildStatus is "
"marked as CL_BUILD_SUCCESS.\n");
}
if (buildStatus != CL_BUILD_SUCCESS)
{
char statusString[64] = "";
if (buildStatus == (cl_build_status)CL_BUILD_SUCCESS)
sprintf(statusString, "CL_BUILD_SUCCESS");
else if (buildStatus == (cl_build_status)CL_BUILD_NONE)
sprintf(statusString, "CL_BUILD_NONE");
else if (buildStatus == (cl_build_status)CL_BUILD_ERROR)
sprintf(statusString, "CL_BUILD_ERROR");
else if (buildStatus == (cl_build_status)CL_BUILD_IN_PROGRESS)
sprintf(statusString, "CL_BUILD_IN_PROGRESS");
else
sprintf(statusString, "UNKNOWN (%d)", buildStatus);
if (buildStatus != CL_BUILD_SUCCESS)
log_error(
"Build not successful for device \"%s\", status: %s\n",
deviceName, statusString);
size_t paramSize = 0;
error = clGetProgramBuildInfo(*outProgram, devices[z],
CL_PROGRAM_BUILD_LOG, 0, NULL,
&paramSize);
if (error != CL_SUCCESS)
{
print_error(
error, "clGetProgramBuildInfo CL_PROGRAM_BUILD_LOG failed");
return error;
}
std::string log;
log.resize(paramSize / sizeof(char));
error = clGetProgramBuildInfo(*outProgram, devices[z],
CL_PROGRAM_BUILD_LOG, paramSize,
&log[0], NULL);
if (error != CL_SUCCESS || log[0] == '\0')
{
log_error("Device %d (%s) failed to return a build log\n", z,
deviceName);
if (error)
{
print_error(
error,
"clGetProgramBuildInfo CL_PROGRAM_BUILD_LOG failed");
return error;
}
else
{
log_error("clGetProgramBuildInfo returned an empty log.\n");
return -1;
}
}
// In this case we've already printed out the code above.
if (!printedSource)
{
unsigned int i;
log_error("Original source is: ------------\n");
for (i = 0; i < numKernelLines; i++)
log_error("%s", kernelProgram[i]);
printedSource = 1;
}
log_error("Build log for device \"%s\" is: ------------\n",
deviceName);
log_error("%s\n", log.c_str());
log_error("\n----------\n");
return -1;
}
}
if (buildFailed)
{
return -1;
}
/* And create a kernel from it */
if (kernelName != NULL)
{
*outKernel = clCreateKernel(*outProgram, kernelName, &error);
if (*outKernel == NULL || error != CL_SUCCESS)
{
print_error(error, "Unable to create kernel");
return error;
}
}
return 0;
}
int get_max_allowed_work_group_size(cl_context context, cl_kernel kernel,
size_t *outMaxSize, size_t *outLimits)
{
cl_device_id *devices;
size_t size, maxCommonSize = 0;
int numDevices, i, j, error;
cl_uint numDims;
size_t outSize;
size_t sizeLimit[] = { 1, 1, 1 };
/* Assume fewer than 16 devices will be returned */
error = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &outSize);
test_error(error, "Unable to obtain list of devices size for context");
devices = (cl_device_id *)malloc(outSize);
BufferOwningPtr<cl_device_id> devicesBuf(devices);
error =
clGetContextInfo(context, CL_CONTEXT_DEVICES, outSize, devices, NULL);
test_error(error, "Unable to obtain list of devices for context");
numDevices = (int)(outSize / sizeof(cl_device_id));
for (i = 0; i < numDevices; i++)
{
error = clGetDeviceInfo(devices[i], CL_DEVICE_MAX_WORK_GROUP_SIZE,
sizeof(size), &size, NULL);
test_error(error, "Unable to obtain max work group size for device");
if (size < maxCommonSize || maxCommonSize == 0) maxCommonSize = size;
error = clGetKernelWorkGroupInfo(kernel, devices[i],
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(size), &size, NULL);
test_error(
error,
"Unable to obtain max work group size for device and kernel combo");
if (size < maxCommonSize || maxCommonSize == 0) maxCommonSize = size;
error = clGetDeviceInfo(devices[i], CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
sizeof(numDims), &numDims, NULL);
test_error(
error,
"clGetDeviceInfo failed for CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS");
sizeLimit[0] = 1;
error = clGetDeviceInfo(devices[i], CL_DEVICE_MAX_WORK_ITEM_SIZES,
numDims * sizeof(size_t), sizeLimit, NULL);
test_error(error,
"clGetDeviceInfo failed for CL_DEVICE_MAX_WORK_ITEM_SIZES");
if (outLimits != NULL)
{
if (i == 0)
{
for (j = 0; j < 3; j++) outLimits[j] = sizeLimit[j];
}
else
{
for (j = 0; j < (int)numDims; j++)
{
if (sizeLimit[j] < outLimits[j])
outLimits[j] = sizeLimit[j];
}
}
}
}
*outMaxSize = (unsigned int)maxCommonSize;
return 0;
}
extern int get_max_allowed_1d_work_group_size_on_device(cl_device_id device,
cl_kernel kernel,
size_t *outSize)
{
cl_uint maxDim;
size_t maxWgSize;
size_t *maxWgSizePerDim;
int error;
error = clGetKernelWorkGroupInfo(kernel, device, CL_KERNEL_WORK_GROUP_SIZE,
sizeof(size_t), &maxWgSize, NULL);
test_error(error,
"clGetKernelWorkGroupInfo CL_KERNEL_WORK_GROUP_SIZE failed");
error = clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
sizeof(cl_uint), &maxDim, NULL);
test_error(error,
"clGetDeviceInfo CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS failed");
maxWgSizePerDim = (size_t *)malloc(maxDim * sizeof(size_t));
if (!maxWgSizePerDim)
{
log_error("Unable to allocate maxWgSizePerDim\n");
return -1;
}
error = clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_SIZES,
maxDim * sizeof(size_t), maxWgSizePerDim, NULL);
if (error != CL_SUCCESS)
{
log_error("clGetDeviceInfo CL_DEVICE_MAX_WORK_ITEM_SIZES failed\n");
free(maxWgSizePerDim);
return error;
}
// "maxWgSize" is limited to that of the first dimension.
if (maxWgSize > maxWgSizePerDim[0])
{
maxWgSize = maxWgSizePerDim[0];
}
free(maxWgSizePerDim);
*outSize = maxWgSize;
return 0;
}
int get_max_common_work_group_size(cl_context context, cl_kernel kernel,
size_t globalThreadSize, size_t *outMaxSize)
{
size_t sizeLimit[3];
int error =
get_max_allowed_work_group_size(context, kernel, outMaxSize, sizeLimit);
if (error != 0) return error;
/* Now find the largest factor of globalThreadSize that is <= maxCommonSize
*/
/* Note for speed, we don't need to check the range of maxCommonSize, b/c
once it gets to 1, the modulo test will succeed and break the loop anyway
*/
for (;
(globalThreadSize % *outMaxSize) != 0 || (*outMaxSize > sizeLimit[0]);
(*outMaxSize)--)
;
return 0;
}
int get_max_common_2D_work_group_size(cl_context context, cl_kernel kernel,
size_t *globalThreadSizes,
size_t *outMaxSizes)
{
size_t sizeLimit[3];
size_t maxSize;
int error =
get_max_allowed_work_group_size(context, kernel, &maxSize, sizeLimit);
if (error != 0) return error;
/* Now find a set of factors, multiplied together less than maxSize, but
each a factor of the global sizes */
/* Simple case */
if (globalThreadSizes[0] * globalThreadSizes[1] <= maxSize)
{
if (globalThreadSizes[0] <= sizeLimit[0]
&& globalThreadSizes[1] <= sizeLimit[1])
{
outMaxSizes[0] = globalThreadSizes[0];
outMaxSizes[1] = globalThreadSizes[1];
return 0;
}
}
size_t remainingSize, sizeForThisOne;
remainingSize = maxSize;
int i, j;
for (i = 0; i < 2; i++)
{
if (globalThreadSizes[i] > remainingSize)
sizeForThisOne = remainingSize;
else
sizeForThisOne = globalThreadSizes[i];
for (; (globalThreadSizes[i] % sizeForThisOne) != 0
|| (sizeForThisOne > sizeLimit[i]);
sizeForThisOne--)
;
outMaxSizes[i] = sizeForThisOne;
remainingSize = maxSize;
for (j = 0; j <= i; j++) remainingSize /= outMaxSizes[j];
}
return 0;
}
int get_max_common_3D_work_group_size(cl_context context, cl_kernel kernel,
size_t *globalThreadSizes,
size_t *outMaxSizes)
{
size_t sizeLimit[3];
size_t maxSize;
int error =
get_max_allowed_work_group_size(context, kernel, &maxSize, sizeLimit);
if (error != 0) return error;
/* Now find a set of factors, multiplied together less than maxSize, but
each a factor of the global sizes */
/* Simple case */
if (globalThreadSizes[0] * globalThreadSizes[1] * globalThreadSizes[2]
<= maxSize)
{
if (globalThreadSizes[0] <= sizeLimit[0]
&& globalThreadSizes[1] <= sizeLimit[1]
&& globalThreadSizes[2] <= sizeLimit[2])
{
outMaxSizes[0] = globalThreadSizes[0];
outMaxSizes[1] = globalThreadSizes[1];
outMaxSizes[2] = globalThreadSizes[2];
return 0;
}
}
size_t remainingSize, sizeForThisOne;
remainingSize = maxSize;
int i, j;
for (i = 0; i < 3; i++)
{
if (globalThreadSizes[i] > remainingSize)
sizeForThisOne = remainingSize;
else
sizeForThisOne = globalThreadSizes[i];
for (; (globalThreadSizes[i] % sizeForThisOne) != 0
|| (sizeForThisOne > sizeLimit[i]);
sizeForThisOne--)
;
outMaxSizes[i] = sizeForThisOne;
remainingSize = maxSize;
for (j = 0; j <= i; j++) remainingSize /= outMaxSizes[j];
}
return 0;
}
/* Helper to determine if a device supports an image format */
int is_image_format_supported(cl_context context, cl_mem_flags flags,
cl_mem_object_type image_type,
const cl_image_format *fmt)
{
cl_image_format *list;
cl_uint count = 0;
cl_int err = clGetSupportedImageFormats(context, flags, image_type, 128,
NULL, &count);
if (count == 0) return 0;
list = (cl_image_format *)malloc(count * sizeof(cl_image_format));
if (NULL == list)
{
log_error("Error: unable to allocate %ld byte buffer for image format "
"list at %s:%d (err = %d)\n",
count * sizeof(cl_image_format), __FILE__, __LINE__, err);
return 0;
}
BufferOwningPtr<cl_image_format> listBuf(list);
cl_int error = clGetSupportedImageFormats(context, flags, image_type, count,
list, NULL);
if (error)
{
log_error("Error: failed to obtain supported image type list at %s:%d "
"(err = %d)\n",
__FILE__, __LINE__, err);
return 0;
}
// iterate looking for a match.
cl_uint i;
for (i = 0; i < count; i++)
{
if (fmt->image_channel_data_type == list[i].image_channel_data_type
&& fmt->image_channel_order == list[i].image_channel_order)
break;
}
return (i < count) ? 1 : 0;
}
size_t get_pixel_bytes(const cl_image_format *fmt);
size_t get_pixel_bytes(const cl_image_format *fmt)
{
size_t chanCount;
switch (fmt->image_channel_order)
{
case CL_R:
case CL_A:
case CL_Rx:
case CL_INTENSITY:
case CL_LUMINANCE:
case CL_DEPTH: chanCount = 1; break;
case CL_RG:
case CL_RA:
case CL_RGx: chanCount = 2; break;
case CL_RGB:
case CL_RGBx:
case CL_sRGB:
case CL_sRGBx: chanCount = 3; break;
case CL_RGBA:
case CL_ARGB:
case CL_BGRA:
case CL_sBGRA:
case CL_sRGBA:
#ifdef CL_1RGB_APPLE
case CL_1RGB_APPLE:
#endif
#ifdef CL_BGR1_APPLE
case CL_BGR1_APPLE:
#endif
chanCount = 4;
break;
default:
log_error("Unknown channel order at %s:%d!\n", __FILE__, __LINE__);
abort();
break;
}
switch (fmt->image_channel_data_type)
{
case CL_UNORM_SHORT_565:
case CL_UNORM_SHORT_555: return 2;
case CL_UNORM_INT_101010: return 4;
case CL_SNORM_INT8:
case CL_UNORM_INT8:
case CL_SIGNED_INT8:
case CL_UNSIGNED_INT8: return chanCount;
case CL_SNORM_INT16:
case CL_UNORM_INT16:
case CL_HALF_FLOAT:
case CL_SIGNED_INT16:
case CL_UNSIGNED_INT16:
#ifdef CL_SFIXED14_APPLE
case CL_SFIXED14_APPLE:
#endif
return chanCount * 2;
case CL_SIGNED_INT32:
case CL_UNSIGNED_INT32:
case CL_FLOAT: return chanCount * 4;
default:
log_error("Unknown channel data type at %s:%d!\n", __FILE__,
__LINE__);
abort();
}
return 0;
}
test_status verifyImageSupport(cl_device_id device)
{
int result = checkForImageSupport(device);
if (result == 0)
{
return TEST_PASS;
}
if (result == CL_IMAGE_FORMAT_NOT_SUPPORTED)
{
log_error("SKIPPED: Device does not supported images as required by "
"this test!\n");
return TEST_SKIP;
}
return TEST_FAIL;
}
int checkForImageSupport(cl_device_id device)
{
cl_uint i;
int error;
/* Check the device props to see if images are supported at all first */
error =
clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof(i), &i, NULL);
test_error(error, "Unable to query device for image support");
if (i == 0)
{
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
/* So our support is good */
return 0;
}
int checkFor3DImageSupport(cl_device_id device)
{
cl_uint i;
int error;
/* Check the device props to see if images are supported at all first */
error =
clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof(i), &i, NULL);
test_error(error, "Unable to query device for image support");
if (i == 0)
{
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
char profile[128];
error = clGetDeviceInfo(device, CL_DEVICE_PROFILE, sizeof(profile), profile,
NULL);
test_error(error, "Unable to query device for CL_DEVICE_PROFILE");
if (0 == strcmp(profile, "EMBEDDED_PROFILE"))
{
size_t width = -1L;
size_t height = -1L;
size_t depth = -1L;
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH,
sizeof(width), &width, NULL);
test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_WIDTH");
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT,
sizeof(height), &height, NULL);
test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_HEIGHT");
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH,
sizeof(depth), &depth, NULL);
test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_DEPTH");
if (0 == (height | width | depth)) return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
/* So our support is good */
return 0;
}
int checkForReadWriteImageSupport(cl_device_id device)
{
if (checkForImageSupport(device))
{
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
auto device_cl_version = get_device_cl_version(device);
if (device_cl_version >= Version(3, 0))
{
// In OpenCL 3.0, Read-Write images are optional.
// Check if they are supported.
cl_uint are_rw_images_supported{};
test_error(
clGetDeviceInfo(device, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS,
sizeof(are_rw_images_supported),
&are_rw_images_supported, nullptr),
"clGetDeviceInfo failed for CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS\n");
if (0 == are_rw_images_supported)
{
log_info("READ_WRITE_IMAGE tests skipped, not supported.\n");
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
}
// READ_WRITE images are not supported on 1.X devices.
else if (device_cl_version < Version(2, 0))
{
log_info("READ_WRITE_IMAGE tests skipped, Opencl 2.0+ is requried.");
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
}
// Support for read-write image arguments is required
// for an 2.X device if the device supports images.
/* So our support is good */
return 0;
}
size_t get_min_alignment(cl_context context)
{
static cl_uint align_size = 0;
if (0 == align_size)
{
cl_device_id *devices;
size_t devices_size = 0;
cl_uint result = 0;
cl_int error;
int i;
error = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL,
&devices_size);
test_error_ret(error, "clGetContextInfo failed", 0);
devices = (cl_device_id *)malloc(devices_size);
if (devices == NULL)
{
print_error(error, "malloc failed");
return 0;
}
error = clGetContextInfo(context, CL_CONTEXT_DEVICES, devices_size,
(void *)devices, NULL);
test_error_ret(error, "clGetContextInfo failed", 0);
for (i = 0; i < (int)(devices_size / sizeof(cl_device_id)); i++)
{
cl_uint alignment = 0;
error = clGetDeviceInfo(devices[i], CL_DEVICE_MEM_BASE_ADDR_ALIGN,
sizeof(cl_uint), (void *)&alignment, NULL);
if (error == CL_SUCCESS)
{
alignment >>= 3; // convert bits to bytes
result = (alignment > result) ? alignment : result;
}
else
print_error(error, "clGetDeviceInfo failed");
}
align_size = result;
free(devices);
}
return align_size;
}
cl_device_fp_config get_default_rounding_mode(cl_device_id device)
{
char profileStr[128] = "";
cl_device_fp_config single = 0;
int error = clGetDeviceInfo(device, CL_DEVICE_SINGLE_FP_CONFIG,
sizeof(single), &single, NULL);
if (error)
test_error_ret(error, "Unable to get device CL_DEVICE_SINGLE_FP_CONFIG",
0);
if (single & CL_FP_ROUND_TO_NEAREST) return CL_FP_ROUND_TO_NEAREST;
if (0 == (single & CL_FP_ROUND_TO_ZERO))
test_error_ret(-1,
"FAILURE: device must support either "
"CL_DEVICE_SINGLE_FP_CONFIG or CL_FP_ROUND_TO_NEAREST",
0);
// Make sure we are an embedded device before allowing a pass
if ((error = clGetDeviceInfo(device, CL_DEVICE_PROFILE, sizeof(profileStr),
&profileStr, NULL)))
test_error_ret(error, "FAILURE: Unable to get CL_DEVICE_PROFILE", 0);
if (strcmp(profileStr, "EMBEDDED_PROFILE"))
test_error_ret(error,
"FAILURE: non-EMBEDDED_PROFILE devices must support "
"CL_FP_ROUND_TO_NEAREST",
0);
return CL_FP_ROUND_TO_ZERO;
}
int checkDeviceForQueueSupport(cl_device_id device,
cl_command_queue_properties prop)
{
cl_command_queue_properties realProps;
cl_int error = clGetDeviceInfo(device, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES,
sizeof(realProps), &realProps, NULL);
test_error_ret(error, "FAILURE: Unable to get device queue properties", 0);
return (realProps & prop) ? 1 : 0;
}
int printDeviceHeader(cl_device_id device)
{
char deviceName[512], deviceVendor[512], deviceVersion[512],
cLangVersion[512];
int error;
error = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(deviceName),
deviceName, NULL);
test_error(error, "Unable to get CL_DEVICE_NAME for device");
error = clGetDeviceInfo(device, CL_DEVICE_VENDOR, sizeof(deviceVendor),
deviceVendor, NULL);
test_error(error, "Unable to get CL_DEVICE_VENDOR for device");
error = clGetDeviceInfo(device, CL_DEVICE_VERSION, sizeof(deviceVersion),
deviceVersion, NULL);
test_error(error, "Unable to get CL_DEVICE_VERSION for device");
error = clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_VERSION,
sizeof(cLangVersion), cLangVersion, NULL);
test_error(error, "Unable to get CL_DEVICE_OPENCL_C_VERSION for device");
log_info("Compute Device Name = %s, Compute Device Vendor = %s, Compute "
"Device Version = %s%s%s\n",
deviceName, deviceVendor, deviceVersion,
(error == CL_SUCCESS) ? ", CL C Version = " : "",
(error == CL_SUCCESS) ? cLangVersion : "");
auto version = get_device_cl_version(device);
if (version >= Version(3, 0))
{
auto ctsVersion = get_device_info_string(
device, CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED);
log_info("Device latest conformance version passed: %s\n",
ctsVersion.c_str());
}
return CL_SUCCESS;
}
Version get_device_cl_c_version(cl_device_id device)
{
auto device_cl_version = get_device_cl_version(device);
// The second special case is OpenCL-1.0 where CL_DEVICE_OPENCL_C_VERSION
// did not exist, but since this is just the first version we can
// return 1.0.
if (device_cl_version == Version{ 1, 0 })
{
return Version{ 1, 0 };
}
// Otherwise we know we have a 1.1 <= device_version <= 2.0 where all CL C
// versions are backwards compatible, hence querying with the
// CL_DEVICE_OPENCL_C_VERSION query must return the most recent supported
// OpenCL C version.
size_t opencl_c_version_size_in_bytes{};
auto error = clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_VERSION, 0, nullptr,
&opencl_c_version_size_in_bytes);
test_error_ret(error,
"clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_VERSION\n",
(Version{ -1, 0 }));
std::string opencl_c_version(opencl_c_version_size_in_bytes, '\0');
error =
clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_VERSION,
opencl_c_version.size(), &opencl_c_version[0], nullptr);
test_error_ret(error,
"clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_VERSION\n",
(Version{ -1, 0 }));
// Scrape out the major, minor pair from the string.
auto major = opencl_c_version[opencl_c_version.find('.') - 1];
auto minor = opencl_c_version[opencl_c_version.find('.') + 1];
return Version{ major - '0', minor - '0' };
}
Version get_device_latest_cl_c_version(cl_device_id device)
{
auto device_cl_version = get_device_cl_version(device);
// If the device version >= 3.0 it must support the
// CL_DEVICE_OPENCL_C_ALL_VERSIONS query from which we can extract the most
// recent CL C version supported by the device.
if (device_cl_version >= Version{ 3, 0 })
{
size_t opencl_c_all_versions_size_in_bytes{};
auto error =
clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_ALL_VERSIONS, 0, nullptr,
&opencl_c_all_versions_size_in_bytes);
test_error_ret(
error, "clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_ALL_VERSIONS",
(Version{ -1, 0 }));
std::vector<cl_name_version> name_versions(
opencl_c_all_versions_size_in_bytes / sizeof(cl_name_version));
error = clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_ALL_VERSIONS,
opencl_c_all_versions_size_in_bytes,
name_versions.data(), nullptr);
test_error_ret(
error, "clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_ALL_VERSIONS",
(Version{ -1, 0 }));
Version max_supported_cl_c_version{};
for (const auto &name_version : name_versions)
{
Version current_version{ CL_VERSION_MAJOR(name_version.version),
CL_VERSION_MINOR(name_version.version) };
max_supported_cl_c_version =
(current_version > max_supported_cl_c_version)
? current_version
: max_supported_cl_c_version;
}
return max_supported_cl_c_version;
}
return get_device_cl_c_version(device);
}
Version get_max_OpenCL_C_for_context(cl_context context)
{
// Get all the devices in the context and find the maximum
// universally supported OpenCL C version.
size_t devices_size_in_bytes{};
auto error = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, nullptr,
&devices_size_in_bytes);
test_error_ret(error, "clGetDeviceInfo failed for CL_CONTEXT_DEVICES",
(Version{ -1, 0 }));
std::vector<cl_device_id> devices(devices_size_in_bytes
/ sizeof(cl_device_id));
error = clGetContextInfo(context, CL_CONTEXT_DEVICES, devices_size_in_bytes,
devices.data(), nullptr);
auto current_version = get_device_latest_cl_c_version(devices[0]);
std::for_each(std::next(devices.begin()), devices.end(),
[&current_version](cl_device_id device) {
auto device_version =
get_device_latest_cl_c_version(device);
// OpenCL 3.0 is not backwards compatible with 2.0.
// If we have 3.0 and 2.0 in the same driver we
// use 1.2.
if (((device_version >= Version(2, 0)
&& device_version < Version(3, 0))
&& current_version >= Version(3, 0))
|| (device_version >= Version(3, 0)
&& (current_version >= Version(2, 0)
&& current_version < Version(3, 0))))
{
current_version = Version(1, 2);
}
else
{
current_version =
(std::min)(device_version, current_version);
}
});
return current_version;
}
bool device_supports_cl_c_version(cl_device_id device, Version version)
{
auto device_cl_version = get_device_cl_version(device);
// In general, a device does not support an OpenCL C version if it is <=
// CL_DEVICE_OPENCL_C_VERSION AND it does not appear in the
// CL_DEVICE_OPENCL_C_ALL_VERSIONS query.
// If the device version >= 3.0 it must support the
// CL_DEVICE_OPENCL_C_ALL_VERSIONS query, and the version of OpenCL C being
// used must appear in the query result if it's <=
// CL_DEVICE_OPENCL_C_VERSION.
if (device_cl_version >= Version{ 3, 0 })
{
size_t opencl_c_all_versions_size_in_bytes{};
auto error =
clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_ALL_VERSIONS, 0, nullptr,
&opencl_c_all_versions_size_in_bytes);
test_error_ret(
error, "clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_ALL_VERSIONS",
(false));
std::vector<cl_name_version> name_versions(
opencl_c_all_versions_size_in_bytes / sizeof(cl_name_version));
error = clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_ALL_VERSIONS,
opencl_c_all_versions_size_in_bytes,
name_versions.data(), nullptr);
test_error_ret(
error, "clGetDeviceInfo failed for CL_DEVICE_OPENCL_C_ALL_VERSIONS",
(false));
for (const auto &name_version : name_versions)
{
Version current_version{ CL_VERSION_MAJOR(name_version.version),
CL_VERSION_MINOR(name_version.version) };
if (current_version == version)
{
return true;
}
}
}
return version <= get_device_cl_c_version(device);
}
bool poll_until(unsigned timeout_ms, unsigned interval_ms,
std::function<bool()> fn)
{
unsigned time_spent_ms = 0;
bool ret = false;
while (time_spent_ms < timeout_ms)
{
ret = fn();
if (ret)
{
break;
}
usleep(interval_ms * 1000);
time_spent_ms += interval_ms;
}
return ret;
}
bool device_supports_double(cl_device_id device)
{
if (is_extension_available(device, "cl_khr_fp64"))
{
return true;
}
else
{
cl_device_fp_config double_fp_config;
cl_int err = clGetDeviceInfo(device, CL_DEVICE_DOUBLE_FP_CONFIG,
sizeof(double_fp_config),
&double_fp_config, nullptr);
test_error(err,
"clGetDeviceInfo for CL_DEVICE_DOUBLE_FP_CONFIG failed");
return double_fp_config != 0;
}
}
bool device_supports_half(cl_device_id device)
{
return is_extension_available(device, "cl_khr_fp16");
}
View Git Blame Copy Permalink