You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1464 lines
56 KiB
1464 lines
56 KiB
//
|
|
// Copyright (c) 2017-2019 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 "harness/compat.h"
|
|
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include "harness/testHarness.h"
|
|
#include "harness/errorHelpers.h"
|
|
#include "harness/kernelHelpers.h"
|
|
|
|
static int dump_supported_formats;
|
|
|
|
typedef struct
|
|
{
|
|
cl_device_type device_type;
|
|
const char* device_type_name;
|
|
unsigned num_devices;
|
|
cl_device_id* devices;
|
|
// more infos here
|
|
} device_info;
|
|
|
|
device_info device_infos[] = {
|
|
{ CL_DEVICE_TYPE_DEFAULT, "CL_DEVICE_TYPE_DEFAULT", -1, NULL },
|
|
{ CL_DEVICE_TYPE_CPU, "CL_DEVICE_TYPE_CPU", -1, NULL },
|
|
{ CL_DEVICE_TYPE_GPU, "CL_DEVICE_TYPE_GPU", -1, NULL },
|
|
{ CL_DEVICE_TYPE_ACCELERATOR, "CL_DEVICE_TYPE_ACCELERATOR", -1, NULL },
|
|
{ CL_DEVICE_TYPE_ALL, "CL_DEVICE_TYPE_ALL", -1, NULL },
|
|
};
|
|
|
|
// config types
|
|
enum
|
|
{
|
|
type_cl_device_type,
|
|
type_cl_device_fp_config,
|
|
type_cl_device_mem_cache_type,
|
|
type_cl_local_mem_type,
|
|
type_cl_device_exec_capabilities,
|
|
type_cl_command_queue_properties,
|
|
type_cl_device_id,
|
|
type_cl_device_affinity_domain,
|
|
type_cl_uint,
|
|
type_size_t,
|
|
type_size_t_arr,
|
|
type_cl_ulong,
|
|
type_string,
|
|
type_cl_device_svm_capabilities,
|
|
type_cl_device_atomic_capabilities,
|
|
type_cl_device_device_enqueue_capabilities,
|
|
type_cl_name_version_array,
|
|
type_cl_name_version,
|
|
};
|
|
|
|
typedef union {
|
|
cl_device_type type;
|
|
cl_device_fp_config fp_config;
|
|
cl_device_mem_cache_type mem_cache_type;
|
|
cl_device_local_mem_type local_mem_type;
|
|
cl_device_exec_capabilities exec_capabilities;
|
|
cl_command_queue_properties queue_properties;
|
|
cl_device_id device_id;
|
|
cl_device_affinity_domain affinity_domain;
|
|
cl_int uint;
|
|
size_t sizet;
|
|
size_t sizet_arr[3];
|
|
cl_ulong ull;
|
|
char* string;
|
|
cl_device_svm_capabilities svmCapabilities;
|
|
cl_device_atomic_capabilities atomicCapabilities;
|
|
cl_device_device_enqueue_capabilities deviceEnqueueCapabilities;
|
|
cl_name_version* cl_name_version_array;
|
|
cl_name_version cl_name_version_single;
|
|
} config_data;
|
|
|
|
struct _version
|
|
{
|
|
int major;
|
|
int minor;
|
|
};
|
|
typedef struct _version version_t;
|
|
|
|
struct _extensions
|
|
{
|
|
int cl_khr_fp64;
|
|
int cl_khr_fp16;
|
|
};
|
|
typedef struct _extensions extensions_t;
|
|
|
|
// Compare two versions, return -1 (the first is lesser), 0 (equal), 1 (the
|
|
// first is greater).
|
|
int vercmp(version_t a, version_t b)
|
|
{
|
|
if (a.major < b.major || (a.major == b.major && a.minor < b.minor))
|
|
{
|
|
return -1;
|
|
}
|
|
else if (a.major == b.major && a.minor == b.minor)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
version_t version; // Opcode is introduced in this version of OpenCL spec.
|
|
cl_device_info opcode;
|
|
const char* opcode_name;
|
|
int config_type;
|
|
config_data config;
|
|
size_t opcode_ret_size;
|
|
} config_info;
|
|
|
|
#define CONFIG_INFO(major, minor, opcode, type) \
|
|
{ \
|
|
{ major, minor }, opcode, #opcode, type_##type, { 0 } \
|
|
}
|
|
|
|
config_info image_buffer_config_infos[] = {
|
|
#ifdef CL_DEVICE_IMAGE_PITCH_ALIGNMENT
|
|
CONFIG_INFO(1, 2, CL_DEVICE_IMAGE_PITCH_ALIGNMENT, cl_uint),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, cl_uint),
|
|
#endif
|
|
};
|
|
|
|
config_info config_infos[] = {
|
|
// `CL_DEVICE_VERSION' must be the first item in the list! It's version must
|
|
// be 0, 0.
|
|
CONFIG_INFO(0, 0, CL_DEVICE_VERSION, string),
|
|
// `CL_DEVICE_EXTENSIONS' must be the second!
|
|
CONFIG_INFO(1, 1, CL_DEVICE_EXTENSIONS, string),
|
|
|
|
CONFIG_INFO(1, 1, CL_DEVICE_TYPE, cl_device_type),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_VENDOR_ID, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_WORK_ITEM_SIZES, size_t_arr),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_WORK_GROUP_SIZE, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, cl_uint),
|
|
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_ADDRESS_BITS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_READ_IMAGE_ARGS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE2D_MAX_WIDTH, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE2D_MAX_HEIGHT, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE3D_MAX_WIDTH, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE3D_MAX_DEPTH, size_t),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, size_t),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_IMAGE_SUPPORT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_PARAMETER_SIZE, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_SAMPLERS, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_IMAGE_PITCH_ALIGNMENT, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, cl_uint),
|
|
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_SINGLE_FP_CONFIG, cl_device_fp_config),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_DOUBLE_FP_CONFIG, cl_device_fp_config),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE,
|
|
cl_device_mem_cache_type),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong),
|
|
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_MAX_CONSTANT_ARGS, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_LOCAL_MEM_TYPE, cl_local_mem_type),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_HOST_UNIFIED_MEMORY, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_t),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_ENDIAN_LITTLE, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_AVAILABLE, cl_uint),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_COMPILER_AVAILABLE, cl_uint),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_LINKER_AVAILABLE, cl_uint),
|
|
|
|
CONFIG_INFO(1, 2, CL_DEVICE_BUILT_IN_KERNELS, string),
|
|
|
|
CONFIG_INFO(1, 2, CL_DEVICE_PRINTF_BUFFER_SIZE, size_t),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, cl_uint),
|
|
|
|
CONFIG_INFO(1, 2, CL_DEVICE_PARENT_DEVICE, cl_device_id),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_PARTITION_MAX_SUB_DEVICES, cl_uint),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_PARTITION_AFFINITY_DOMAIN,
|
|
cl_device_affinity_domain),
|
|
CONFIG_INFO(1, 2, CL_DEVICE_REFERENCE_COUNT, cl_uint),
|
|
|
|
CONFIG_INFO(1, 1, CL_DEVICE_EXECUTION_CAPABILITIES,
|
|
cl_device_exec_capabilities),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES,
|
|
cl_command_queue_properties),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_NAME, string),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_VENDOR, string),
|
|
CONFIG_INFO(1, 1, CL_DRIVER_VERSION, string),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_PROFILE, string),
|
|
CONFIG_INFO(1, 1, CL_DEVICE_OPENCL_C_VERSION, string),
|
|
|
|
CONFIG_INFO(2, 0, CL_DEVICE_MAX_PIPE_ARGS, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_PIPE_MAX_PACKET_SIZE, cl_uint),
|
|
|
|
CONFIG_INFO(2, 0, CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_t),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_t),
|
|
|
|
CONFIG_INFO(2, 0, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES,
|
|
cl_command_queue_properties),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES,
|
|
cl_command_queue_properties),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_MAX_ON_DEVICE_QUEUES, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_MAX_ON_DEVICE_EVENTS, cl_uint),
|
|
|
|
CONFIG_INFO(2, 0, CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, cl_uint),
|
|
CONFIG_INFO(2, 0, CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, cl_uint),
|
|
|
|
CONFIG_INFO(2, 0, CL_DEVICE_SVM_CAPABILITIES, cl_device_svm_capabilities),
|
|
|
|
CONFIG_INFO(2, 1, CL_DEVICE_IL_VERSION, string),
|
|
CONFIG_INFO(2, 1, CL_DEVICE_MAX_NUM_SUB_GROUPS, cl_uint),
|
|
CONFIG_INFO(2, 1, CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS,
|
|
cl_uint),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES,
|
|
cl_device_atomic_capabilities),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_ATOMIC_FENCE_CAPABILITIES,
|
|
cl_device_atomic_capabilities),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, cl_uint),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_t),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT,
|
|
cl_uint),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, cl_uint),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_OPENCL_C_FEATURES, cl_name_version_array),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES,
|
|
cl_device_device_enqueue_capabilities),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_PIPE_SUPPORT, cl_uint),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_NUMERIC_VERSION, cl_name_version),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_EXTENSIONS_WITH_VERSION, cl_name_version_array),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_OPENCL_C_ALL_VERSIONS, cl_name_version_array),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_ILS_WITH_VERSION, cl_name_version_array),
|
|
CONFIG_INFO(3, 0, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION,
|
|
cl_name_version_array),
|
|
};
|
|
|
|
#define ENTRY(major, minor, T) \
|
|
{ \
|
|
{ major, minor }, T, #T \
|
|
}
|
|
struct image_type_entry
|
|
{
|
|
version_t
|
|
version; // Image type is introduced in this version of OpenCL spec.
|
|
cl_mem_object_type val;
|
|
const char* str;
|
|
};
|
|
static const struct image_type_entry image_types[] = {
|
|
ENTRY(1, 2, CL_MEM_OBJECT_IMAGE1D),
|
|
ENTRY(1, 2, CL_MEM_OBJECT_IMAGE1D_BUFFER),
|
|
ENTRY(1, 0, CL_MEM_OBJECT_IMAGE2D),
|
|
ENTRY(1, 0, CL_MEM_OBJECT_IMAGE3D),
|
|
ENTRY(1, 2, CL_MEM_OBJECT_IMAGE1D_ARRAY),
|
|
ENTRY(1, 2, CL_MEM_OBJECT_IMAGE2D_ARRAY)
|
|
};
|
|
|
|
struct supported_flags_entry
|
|
{
|
|
version_t
|
|
version; // Memory flag is introduced in this version of OpenCL spec.
|
|
cl_mem_flags val;
|
|
const char* str;
|
|
};
|
|
|
|
static const struct supported_flags_entry supported_flags[] = {
|
|
ENTRY(1, 0, CL_MEM_READ_ONLY), ENTRY(1, 0, CL_MEM_WRITE_ONLY),
|
|
ENTRY(1, 0, CL_MEM_READ_WRITE), ENTRY(2, 0, CL_MEM_KERNEL_READ_AND_WRITE)
|
|
};
|
|
|
|
int getImageInfo(cl_device_id device, const version_t& version)
|
|
{
|
|
cl_context ctx;
|
|
cl_int err;
|
|
cl_uint i, num_supported;
|
|
cl_image_format* formats;
|
|
int num_errors;
|
|
int ii, ni = sizeof(image_types) / sizeof(image_types[0]);
|
|
int fi, nf = sizeof(supported_flags) / sizeof(supported_flags[0]);
|
|
|
|
ctx = clCreateContext(NULL, 1, &device, notify_callback, NULL, &err);
|
|
if (!ctx)
|
|
{
|
|
print_error(err, "Unable to create context from device");
|
|
return 1;
|
|
}
|
|
|
|
num_errors = 0;
|
|
for (ii = 0; ii < ni; ++ii)
|
|
{
|
|
if (vercmp(version, image_types[ii].version) < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
log_info("\t%s supported formats:\n", image_types[ii].str);
|
|
for (fi = 0; fi < nf; ++fi)
|
|
{
|
|
if (vercmp(version, supported_flags[fi].version) < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
err = clGetSupportedImageFormats(ctx, supported_flags[fi].val,
|
|
image_types[ii].val, 5000, NULL,
|
|
&num_supported);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
print_error(err, "clGetSupportedImageFormats failed");
|
|
++num_errors;
|
|
continue;
|
|
}
|
|
|
|
log_info("\t\t%s: %u supported formats\n", supported_flags[fi].str,
|
|
num_supported);
|
|
|
|
if (num_supported == 0 || dump_supported_formats == 0) continue;
|
|
|
|
formats = (cl_image_format*)malloc(num_supported
|
|
* sizeof(cl_image_format));
|
|
if (formats == NULL)
|
|
{
|
|
log_error("malloc failed\n");
|
|
clReleaseContext(ctx);
|
|
return num_errors + 1;
|
|
}
|
|
|
|
err = clGetSupportedImageFormats(ctx, supported_flags[fi].val,
|
|
image_types[ii].val, num_supported,
|
|
formats, NULL);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
print_error(err, "clGetSupportedImageFormats failed");
|
|
++num_errors;
|
|
free(formats);
|
|
continue;
|
|
}
|
|
|
|
for (i = 0; i < num_supported; ++i)
|
|
log_info(
|
|
"\t\t\t%s / %s\n",
|
|
GetChannelOrderName(formats[i].image_channel_order),
|
|
GetChannelTypeName(formats[i].image_channel_data_type));
|
|
|
|
free(formats);
|
|
}
|
|
}
|
|
|
|
err = clReleaseContext(ctx);
|
|
if (err)
|
|
{
|
|
print_error(err, "Failed to release context\n");
|
|
++num_errors;
|
|
}
|
|
|
|
return num_errors;
|
|
}
|
|
int getPlatformConfigInfo(cl_platform_id platform, config_info* info)
|
|
{
|
|
int err = CL_SUCCESS;
|
|
int size_err = 0;
|
|
size_t config_size_set;
|
|
size_t config_size_ret;
|
|
switch (info->config_type)
|
|
{
|
|
case type_string:
|
|
err = clGetPlatformInfo(platform, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
info->config.string = NULL;
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
info->config.string = (char*)malloc(config_size_set);
|
|
err = clGetPlatformInfo(platform, info->opcode, config_size_set,
|
|
info->config.string, &config_size_ret);
|
|
size_err = config_size_set != config_size_ret;
|
|
}
|
|
break;
|
|
case type_cl_name_version_array:
|
|
err = clGetPlatformInfo(platform, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
info->config.cl_name_version_array = NULL;
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
info->config.cl_name_version_array = (cl_name_version*)malloc(
|
|
config_size_set * sizeof(cl_name_version));
|
|
err = clGetPlatformInfo(platform, info->opcode, config_size_set,
|
|
info->config.cl_name_version_array,
|
|
&config_size_ret);
|
|
size_err = config_size_set != config_size_ret;
|
|
info->opcode_ret_size = config_size_ret;
|
|
}
|
|
break;
|
|
case type_cl_name_version:
|
|
err = clGetPlatformInfo(platform, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
err = clGetPlatformInfo(platform, info->opcode, config_size_set,
|
|
&info->config.cl_name_version_single,
|
|
&config_size_ret);
|
|
}
|
|
size_err = config_size_set != config_size_ret;
|
|
break;
|
|
default:
|
|
log_error("Unknown config type: %d\n", info->config_type);
|
|
break;
|
|
}
|
|
if (err || size_err)
|
|
log_error("\tFailed clGetPlatformInfo for %s.\n", info->opcode_name);
|
|
if (err) print_error(err, "\t\tclGetPlatformInfo failed.");
|
|
if (size_err) log_error("\t\tWrong size return from clGetPlatformInfo.\n");
|
|
return err || size_err;
|
|
}
|
|
|
|
int getConfigInfo(cl_device_id device, config_info* info)
|
|
{
|
|
int err = CL_SUCCESS;
|
|
int size_err = 0;
|
|
size_t config_size_set;
|
|
size_t config_size_ret;
|
|
switch (info->config_type)
|
|
{
|
|
case type_cl_device_type:
|
|
err =
|
|
clGetDeviceInfo(device, info->opcode, sizeof(info->config.type),
|
|
&info->config.type, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.type);
|
|
break;
|
|
case type_cl_device_fp_config:
|
|
err = clGetDeviceInfo(device, info->opcode,
|
|
sizeof(info->config.fp_config),
|
|
&info->config.fp_config, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.fp_config);
|
|
break;
|
|
case type_cl_device_mem_cache_type:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.mem_cache_type),
|
|
&info->config.mem_cache_type, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.mem_cache_type);
|
|
break;
|
|
case type_cl_local_mem_type:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.local_mem_type),
|
|
&info->config.local_mem_type, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.local_mem_type);
|
|
break;
|
|
case type_cl_device_exec_capabilities:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.exec_capabilities),
|
|
&info->config.exec_capabilities, &config_size_ret);
|
|
size_err =
|
|
config_size_ret != sizeof(info->config.exec_capabilities);
|
|
break;
|
|
case type_cl_command_queue_properties:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.queue_properties),
|
|
&info->config.queue_properties, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.queue_properties);
|
|
break;
|
|
case type_cl_device_id:
|
|
err = clGetDeviceInfo(device, info->opcode,
|
|
sizeof(info->config.device_id),
|
|
&info->config.device_id, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.device_id);
|
|
break;
|
|
case type_cl_device_affinity_domain:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.affinity_domain),
|
|
&info->config.affinity_domain, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.affinity_domain);
|
|
break;
|
|
case type_cl_uint:
|
|
err =
|
|
clGetDeviceInfo(device, info->opcode, sizeof(info->config.uint),
|
|
&info->config.uint, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.uint);
|
|
break;
|
|
case type_size_t_arr:
|
|
err = clGetDeviceInfo(device, info->opcode,
|
|
sizeof(info->config.sizet_arr),
|
|
&info->config.sizet_arr, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.sizet_arr);
|
|
break;
|
|
case type_size_t:
|
|
err = clGetDeviceInfo(device, info->opcode,
|
|
sizeof(info->config.sizet),
|
|
&info->config.sizet, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.sizet);
|
|
break;
|
|
case type_cl_ulong:
|
|
err =
|
|
clGetDeviceInfo(device, info->opcode, sizeof(info->config.ull),
|
|
&info->config.ull, &config_size_ret);
|
|
size_err = config_size_ret != sizeof(info->config.ull);
|
|
break;
|
|
case type_string:
|
|
err = clGetDeviceInfo(device, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
info->config.string = NULL;
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
info->config.string = (char*)malloc(config_size_set);
|
|
err = clGetDeviceInfo(device, info->opcode, config_size_set,
|
|
info->config.string, &config_size_ret);
|
|
size_err = config_size_set != config_size_ret;
|
|
}
|
|
break;
|
|
case type_cl_device_svm_capabilities:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.svmCapabilities),
|
|
&info->config.svmCapabilities, &config_size_ret);
|
|
break;
|
|
case type_cl_device_device_enqueue_capabilities:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode,
|
|
sizeof(info->config.deviceEnqueueCapabilities),
|
|
&info->config.deviceEnqueueCapabilities, &config_size_ret);
|
|
break;
|
|
case type_cl_device_atomic_capabilities:
|
|
err = clGetDeviceInfo(
|
|
device, info->opcode, sizeof(info->config.atomicCapabilities),
|
|
&info->config.atomicCapabilities, &config_size_ret);
|
|
break;
|
|
case type_cl_name_version_array:
|
|
err = clGetDeviceInfo(device, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
info->config.cl_name_version_array = NULL;
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
info->config.cl_name_version_array = (cl_name_version*)malloc(
|
|
config_size_set * sizeof(cl_name_version));
|
|
err = clGetDeviceInfo(device, info->opcode, config_size_set,
|
|
info->config.cl_name_version_array,
|
|
&config_size_ret);
|
|
size_err = config_size_set != config_size_ret;
|
|
info->opcode_ret_size = config_size_ret;
|
|
}
|
|
break;
|
|
case type_cl_name_version:
|
|
err = clGetDeviceInfo(device, info->opcode, 0, NULL,
|
|
&config_size_set);
|
|
if (err == CL_SUCCESS && config_size_set > 0)
|
|
{
|
|
err = clGetDeviceInfo(device, info->opcode, config_size_set,
|
|
&info->config.cl_name_version_single,
|
|
&config_size_ret);
|
|
}
|
|
size_err = config_size_set != config_size_ret;
|
|
break;
|
|
default:
|
|
log_error("Unknown config type: %d\n", info->config_type);
|
|
break;
|
|
}
|
|
if (err || size_err)
|
|
log_error("\tFailed clGetDeviceInfo for %s.\n", info->opcode_name);
|
|
if (err) print_error(err, "\t\tclGetDeviceInfo failed.");
|
|
if (size_err) log_error("\t\tWrong size return from clGetDeviceInfo.\n");
|
|
return err || size_err;
|
|
}
|
|
|
|
void dumpConfigInfo(config_info* info)
|
|
{
|
|
// We should not error if we find an unknown configuration since vendors
|
|
// may specify their own options beyond the list in the specification.
|
|
switch (info->config_type)
|
|
{
|
|
case type_cl_device_type:
|
|
log_info("\t%s == %s|%s|%s|%s\n", info->opcode_name,
|
|
(info->config.fp_config & CL_DEVICE_TYPE_CPU)
|
|
? "CL_DEVICE_TYPE_CPU"
|
|
: "",
|
|
(info->config.fp_config & CL_DEVICE_TYPE_GPU)
|
|
? "CL_DEVICE_TYPE_GPU"
|
|
: "",
|
|
(info->config.fp_config & CL_DEVICE_TYPE_ACCELERATOR)
|
|
? "CL_DEVICE_TYPE_ACCELERATOR"
|
|
: "",
|
|
(info->config.fp_config & CL_DEVICE_TYPE_DEFAULT)
|
|
? "CL_DEVICE_TYPE_DEFAULT"
|
|
: "");
|
|
{
|
|
cl_device_type all_device_types = CL_DEVICE_TYPE_CPU
|
|
| CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR
|
|
| CL_DEVICE_TYPE_DEFAULT;
|
|
if (info->config.fp_config & ~all_device_types)
|
|
{
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.fp_config & ~all_device_types));
|
|
}
|
|
}
|
|
break;
|
|
case type_cl_device_fp_config:
|
|
log_info(
|
|
"\t%s == %s|%s|%s|%s|%s|%s|%s\n", info->opcode_name,
|
|
(info->config.fp_config & CL_FP_DENORM) ? "CL_FP_DENORM" : "",
|
|
(info->config.fp_config & CL_FP_INF_NAN) ? "CL_FP_INF_NAN" : "",
|
|
(info->config.fp_config & CL_FP_ROUND_TO_NEAREST)
|
|
? "CL_FP_ROUND_TO_NEAREST"
|
|
: "",
|
|
(info->config.fp_config & CL_FP_ROUND_TO_ZERO)
|
|
? "CL_FP_ROUND_TO_ZERO"
|
|
: "",
|
|
(info->config.fp_config & CL_FP_ROUND_TO_INF)
|
|
? "CL_FP_ROUND_TO_INF"
|
|
: "",
|
|
(info->config.fp_config & CL_FP_FMA) ? "CL_FP_FMA" : "",
|
|
(info->config.fp_config & CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT)
|
|
? "CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT"
|
|
: "");
|
|
{
|
|
cl_device_fp_config all_fp_config = CL_FP_DENORM | CL_FP_INF_NAN
|
|
| CL_FP_ROUND_TO_NEAREST | CL_FP_ROUND_TO_ZERO
|
|
| CL_FP_ROUND_TO_INF | CL_FP_FMA
|
|
| CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT;
|
|
if (info->config.fp_config & ~all_fp_config)
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.fp_config & ~all_fp_config));
|
|
}
|
|
break;
|
|
case type_cl_device_mem_cache_type:
|
|
switch (info->config.mem_cache_type)
|
|
{
|
|
case CL_NONE:
|
|
log_info("\t%s == CL_NONE\n", info->opcode_name);
|
|
break;
|
|
case CL_READ_ONLY_CACHE:
|
|
log_info("\t%s == CL_READ_ONLY_CACHE\n", info->opcode_name);
|
|
break;
|
|
case CL_READ_WRITE_CACHE:
|
|
log_info("\t%s == CL_READ_WRITE_CACHE\n",
|
|
info->opcode_name);
|
|
break;
|
|
default:
|
|
log_error("ERROR: %s out of range, %d\n", info->opcode_name,
|
|
info->config.mem_cache_type);
|
|
break;
|
|
}
|
|
break;
|
|
case type_cl_local_mem_type:
|
|
switch (info->config.local_mem_type)
|
|
{
|
|
case CL_NONE:
|
|
log_info("\t%s == CL_NONE\n", info->opcode_name);
|
|
break;
|
|
case CL_LOCAL:
|
|
log_info("\t%s == CL_LOCAL\n", info->opcode_name);
|
|
break;
|
|
case CL_GLOBAL:
|
|
log_info("\t%s == CL_GLOBAL\n", info->opcode_name);
|
|
break;
|
|
default:
|
|
log_info("WARNING: %s out of range, %d\n",
|
|
info->opcode_name, info->config.local_mem_type);
|
|
break;
|
|
}
|
|
break;
|
|
case type_cl_device_exec_capabilities:
|
|
log_info("\t%s == %s|%s\n", info->opcode_name,
|
|
(info->config.exec_capabilities & CL_EXEC_KERNEL)
|
|
? "CL_EXEC_KERNEL"
|
|
: "",
|
|
(info->config.exec_capabilities & CL_EXEC_NATIVE_KERNEL)
|
|
? "CL_EXEC_NATIVE_KERNEL"
|
|
: "");
|
|
{
|
|
cl_device_exec_capabilities all_exec_cap =
|
|
CL_EXEC_KERNEL | CL_EXEC_NATIVE_KERNEL;
|
|
if (info->config.exec_capabilities & ~all_exec_cap)
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.exec_capabilities & ~all_exec_cap));
|
|
}
|
|
break;
|
|
case type_cl_command_queue_properties:
|
|
log_info("\t%s == %s|%s\n", info->opcode_name,
|
|
(info->config.queue_properties
|
|
& CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
|
|
? "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE"
|
|
: "",
|
|
(info->config.queue_properties & CL_QUEUE_PROFILING_ENABLE)
|
|
? "CL_QUEUE_PROFILING_ENABLE"
|
|
: "");
|
|
{
|
|
cl_command_queue_properties all_queue_properties =
|
|
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE
|
|
| CL_QUEUE_PROFILING_ENABLE;
|
|
if (info->config.queue_properties & ~all_queue_properties)
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.exec_capabilities
|
|
& ~all_queue_properties));
|
|
}
|
|
break;
|
|
case type_cl_device_id:
|
|
log_info("\t%s == %ld\n", info->opcode_name,
|
|
(intptr_t)info->config.device_id);
|
|
break;
|
|
case type_cl_device_affinity_domain:
|
|
log_info(
|
|
"\t%s == %s|%s|%s|%s|%s|%s\n", info->opcode_name,
|
|
(info->config.affinity_domain & CL_DEVICE_AFFINITY_DOMAIN_NUMA)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_NUMA"
|
|
: "",
|
|
(info->config.affinity_domain
|
|
& CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE"
|
|
: "",
|
|
(info->config.affinity_domain
|
|
& CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE"
|
|
: "",
|
|
(info->config.affinity_domain
|
|
& CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE"
|
|
: "",
|
|
(info->config.affinity_domain
|
|
& CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE"
|
|
: "",
|
|
(info->config.affinity_domain
|
|
& CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE)
|
|
? "CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE"
|
|
: "");
|
|
{
|
|
cl_device_affinity_domain all_affinity_domain =
|
|
CL_DEVICE_AFFINITY_DOMAIN_NUMA
|
|
| CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE
|
|
| CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE
|
|
| CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE
|
|
| CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE
|
|
| CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE;
|
|
if (info->config.affinity_domain & ~all_affinity_domain)
|
|
log_error(
|
|
"ERROR: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.affinity_domain & ~all_affinity_domain));
|
|
}
|
|
break;
|
|
case type_cl_uint:
|
|
log_info("\t%s == %u\n", info->opcode_name, info->config.uint);
|
|
break;
|
|
case type_size_t_arr:
|
|
log_info("\t%s == %zu %zu %zu\n", info->opcode_name,
|
|
info->config.sizet_arr[0], info->config.sizet_arr[1],
|
|
info->config.sizet_arr[2]);
|
|
break;
|
|
case type_size_t:
|
|
log_info("\t%s == %zu\n", info->opcode_name, info->config.sizet);
|
|
break;
|
|
case type_cl_ulong:
|
|
log_info("\t%s == %" PRIu64 "\n", info->opcode_name,
|
|
info->config.ull);
|
|
break;
|
|
case type_string:
|
|
log_info("\t%s == \"%s\"\n", info->opcode_name,
|
|
info->config.string ? info->config.string : "");
|
|
break;
|
|
case type_cl_device_svm_capabilities:
|
|
log_info(
|
|
"\t%s == %s|%s|%s|%s\n", info->opcode_name,
|
|
(info->config.svmCapabilities
|
|
& CL_DEVICE_SVM_COARSE_GRAIN_BUFFER)
|
|
? "CL_DEVICE_SVM_COARSE_GRAIN_BUFFER"
|
|
: "",
|
|
(info->config.svmCapabilities & CL_DEVICE_SVM_FINE_GRAIN_BUFFER)
|
|
? "CL_DEVICE_SVM_FINE_GRAIN_BUFFER"
|
|
: "",
|
|
(info->config.svmCapabilities & CL_DEVICE_SVM_FINE_GRAIN_SYSTEM)
|
|
? "CL_DEVICE_SVM_FINE_GRAIN_SYSTEM"
|
|
: "",
|
|
(info->config.svmCapabilities & CL_DEVICE_SVM_ATOMICS)
|
|
? "CL_DEVICE_SVM_ATOMICS"
|
|
: "");
|
|
{
|
|
cl_device_svm_capabilities all_svm_capabilities =
|
|
CL_DEVICE_SVM_COARSE_GRAIN_BUFFER
|
|
| CL_DEVICE_SVM_FINE_GRAIN_BUFFER
|
|
| CL_DEVICE_SVM_FINE_GRAIN_SYSTEM | CL_DEVICE_SVM_ATOMICS;
|
|
if (info->config.svmCapabilities & ~all_svm_capabilities)
|
|
log_info(
|
|
"WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.svmCapabilities & ~all_svm_capabilities));
|
|
}
|
|
break;
|
|
case type_cl_device_device_enqueue_capabilities:
|
|
log_info("\t%s == %s|%s\n", info->opcode_name,
|
|
(info->config.deviceEnqueueCapabilities
|
|
& CL_DEVICE_QUEUE_SUPPORTED)
|
|
? "CL_DEVICE_QUEUE_SUPPORTED"
|
|
: "",
|
|
(info->config.deviceEnqueueCapabilities
|
|
& CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT)
|
|
? "CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT"
|
|
: "");
|
|
{
|
|
cl_device_device_enqueue_capabilities
|
|
all_device_enqueue_capabilities = CL_DEVICE_QUEUE_SUPPORTED
|
|
| CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT;
|
|
if (info->config.deviceEnqueueCapabilities
|
|
& ~all_device_enqueue_capabilities)
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.deviceEnqueueCapabilities
|
|
& ~all_device_enqueue_capabilities));
|
|
}
|
|
break;
|
|
case type_cl_device_atomic_capabilities:
|
|
log_info("\t%s == %s|%s|%s|%s|%s|%s|%s\n", info->opcode_name,
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_ORDER_RELAXED)
|
|
? "CL_DEVICE_ATOMIC_ORDER_RELAXED"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_ORDER_ACQ_REL)
|
|
? "CL_DEVICE_ATOMIC_ORDER_ACQ_REL"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_ORDER_SEQ_CST)
|
|
? "CL_DEVICE_ATOMIC_ORDER_SEQ_CST"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM)
|
|
? "CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP)
|
|
? "CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_SCOPE_DEVICE)
|
|
? "CL_DEVICE_ATOMIC_SCOPE_DEVICE"
|
|
: "",
|
|
(info->config.atomicCapabilities
|
|
& CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES)
|
|
? "CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES"
|
|
: "");
|
|
{
|
|
cl_device_atomic_capabilities all_atomic_capabilities =
|
|
CL_DEVICE_ATOMIC_ORDER_RELAXED
|
|
| CL_DEVICE_ATOMIC_ORDER_ACQ_REL
|
|
| CL_DEVICE_ATOMIC_ORDER_SEQ_CST
|
|
| CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM
|
|
| CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP
|
|
| CL_DEVICE_ATOMIC_SCOPE_DEVICE
|
|
| CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES;
|
|
if (info->config.atomicCapabilities & ~all_atomic_capabilities)
|
|
log_info("WARNING: %s unknown bits found 0x%08" PRIX64,
|
|
info->opcode_name,
|
|
(info->config.atomicCapabilities
|
|
& ~all_atomic_capabilities));
|
|
}
|
|
break;
|
|
case type_cl_name_version_array: {
|
|
int number_of_version_items = info->opcode_ret_size
|
|
/ sizeof(*info->config.cl_name_version_array);
|
|
log_info("\t%s supported name and version:\n", info->opcode_name);
|
|
if (number_of_version_items == 0)
|
|
{
|
|
log_info("\t\t\"\"\n");
|
|
}
|
|
else
|
|
{
|
|
for (int f = 0; f < number_of_version_items; f++)
|
|
{
|
|
cl_name_version new_version_item =
|
|
info->config.cl_name_version_array[f];
|
|
cl_version new_version_major =
|
|
CL_VERSION_MAJOR_KHR(new_version_item.version);
|
|
cl_version new_version_minor =
|
|
CL_VERSION_MINOR_KHR(new_version_item.version);
|
|
cl_version new_version_patch =
|
|
CL_VERSION_PATCH_KHR(new_version_item.version);
|
|
log_info("\t\t\"%s\" %d.%d.%d\n", new_version_item.name,
|
|
CL_VERSION_MAJOR_KHR(new_version_item.version),
|
|
CL_VERSION_MINOR_KHR(new_version_item.version),
|
|
CL_VERSION_PATCH_KHR(new_version_item.version));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case type_cl_name_version:
|
|
log_info("\t%s == %d.%d.%d\n", info->opcode_name,
|
|
CL_VERSION_MAJOR_KHR(
|
|
info->config.cl_name_version_single.version),
|
|
CL_VERSION_MINOR_KHR(
|
|
info->config.cl_name_version_single.version),
|
|
CL_VERSION_PATCH_KHR(
|
|
info->config.cl_name_version_single.version));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void print_platform_string_selector(cl_platform_id platform,
|
|
const char* selector_name,
|
|
cl_platform_info selector)
|
|
{
|
|
// Currently all the selectors are strings
|
|
size_t size = 0;
|
|
char* value;
|
|
int err;
|
|
|
|
if ((err = clGetPlatformInfo(platform, selector, 0, NULL, &size)))
|
|
{
|
|
log_error("FAILURE: Unable to get platform info size for %s.\n",
|
|
selector_name);
|
|
exit(-1);
|
|
}
|
|
|
|
if (size == 0)
|
|
{
|
|
log_error("FAILURE: The size of %s was returned to be zero.\n",
|
|
selector_name);
|
|
exit(-1);
|
|
}
|
|
|
|
value = (char*)malloc(size);
|
|
if (NULL == value)
|
|
{
|
|
log_error("Internal test failure: Unable to allocate %zu bytes\n",
|
|
size);
|
|
exit(-1);
|
|
}
|
|
|
|
memset(value, -1, size);
|
|
if ((err = clGetPlatformInfo(platform, selector, size, value, NULL)))
|
|
{
|
|
log_error("FAILURE: Unable to get platform info for %s.\n",
|
|
selector_name);
|
|
free(value);
|
|
exit(-1);
|
|
}
|
|
|
|
if (value[size - 1] != '\0')
|
|
{
|
|
log_error("FAILURE: platform info for %s is either not NUL terminated, "
|
|
"or the size is wrong.\n",
|
|
selector_name);
|
|
free(value);
|
|
exit(-1);
|
|
}
|
|
|
|
log_info("\t%s: %s\n", selector_name, value);
|
|
free(value);
|
|
}
|
|
|
|
int parseVersion(char const* str, version_t* version)
|
|
{
|
|
int rc = -1;
|
|
version->major = 0;
|
|
version->minor = 0;
|
|
if (strncmp(str, "OpenCL 1.2", 10) == 0 && (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 1;
|
|
version->minor = 2;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 1.0", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 1;
|
|
version->minor = 0;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 1.1", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 1;
|
|
version->minor = 1;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 2.0", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 2;
|
|
version->minor = 0;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 2.1", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 2;
|
|
version->minor = 1;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 2.2", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 2;
|
|
version->minor = 2;
|
|
rc = 0;
|
|
}
|
|
else if (strncmp(str, "OpenCL 3.0", 10) == 0
|
|
&& (str[10] == 0 || str[10] == ' '))
|
|
{
|
|
version->major = 3;
|
|
version->minor = 0;
|
|
rc = 0;
|
|
}
|
|
else
|
|
{
|
|
log_error("ERROR: Unexpected version string: `%s'.\n", str);
|
|
};
|
|
return rc;
|
|
}
|
|
|
|
int parseExtensions(char const* str, extensions_t* extensions)
|
|
{
|
|
char const* begin = NULL;
|
|
char const* space = NULL;
|
|
size_t length = 0;
|
|
|
|
memset(extensions, 0, sizeof(extensions_t));
|
|
|
|
begin = str;
|
|
while (begin[0] != 0)
|
|
{
|
|
space = strchr(begin, ' '); // Find space position.
|
|
if (space != NULL)
|
|
{ // Calculate length of word.
|
|
length = space - begin;
|
|
}
|
|
else
|
|
{
|
|
length = strlen(begin);
|
|
}
|
|
if (strncmp(begin, "cl_khr_fp64", length) == 0)
|
|
{
|
|
extensions->cl_khr_fp64 = 1;
|
|
}
|
|
if (strncmp(begin, "cl_khr_fp16", length) == 0)
|
|
{
|
|
extensions->cl_khr_fp16 = 1;
|
|
}
|
|
begin += length; // Skip word.
|
|
if (begin[0] == ' ')
|
|
{ // Skip space, if any.
|
|
begin += 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int getConfigInfos(cl_device_id device)
|
|
{
|
|
int total_errors = 0;
|
|
unsigned onConfigInfo;
|
|
version_t version = { 0, 0 }; // Version of the device. Will get real value
|
|
// on the first loop iteration.
|
|
version_t const ver11 = { 1, 1 }; // Version 1.1.
|
|
extensions_t extensions = { 0 };
|
|
int get; // Boolean flag: true = get property, false = skip it.
|
|
int err;
|
|
for (onConfigInfo = 0;
|
|
onConfigInfo < sizeof(config_infos) / sizeof(config_infos[0]);
|
|
onConfigInfo++)
|
|
{
|
|
config_info info = config_infos[onConfigInfo];
|
|
// Get a property only if device version is equal or greater than
|
|
// property version.
|
|
get = (vercmp(version, info.version) >= 0);
|
|
if (info.opcode == CL_DEVICE_DOUBLE_FP_CONFIG
|
|
&& vercmp(version, ver11) <= 0)
|
|
{
|
|
// CL_DEVICE_DOUBLE_FP_CONFIG is a special case. It was introduced
|
|
// in OpenCL 1.1, but device is required to report it only if
|
|
// doubles are supported. So, before querying it on device
|
|
// version 1.1, we have to check doubles are sopported. In
|
|
// OpenCL 1.2 CL_DEVICE_DOUBLE_FP_CONFIG should be reported
|
|
// unconditionally.
|
|
get = extensions.cl_khr_fp64;
|
|
};
|
|
if (info.opcode == CL_DEVICE_HALF_FP_CONFIG)
|
|
{
|
|
// CL_DEVICE_HALF_FP_CONFIG should be reported only when cl_khr_fp16
|
|
// extension is available
|
|
get = extensions.cl_khr_fp16;
|
|
};
|
|
if (get)
|
|
{
|
|
err = getConfigInfo(device, &info);
|
|
if (!err)
|
|
{
|
|
dumpConfigInfo(&info);
|
|
if (info.opcode == CL_DEVICE_VERSION)
|
|
{
|
|
err = parseVersion(info.config.string, &version);
|
|
if (err)
|
|
{
|
|
total_errors++;
|
|
free(info.config.string);
|
|
break;
|
|
}
|
|
}
|
|
else if (info.opcode == CL_DEVICE_EXTENSIONS)
|
|
{
|
|
err = parseExtensions(info.config.string, &extensions);
|
|
if (err)
|
|
{
|
|
total_errors++;
|
|
free(info.config.string);
|
|
break;
|
|
}
|
|
}
|
|
if (info.config_type == type_string)
|
|
{
|
|
free(info.config.string);
|
|
}
|
|
if (info.config_type == type_cl_name_version_array)
|
|
{
|
|
free(info.config.cl_name_version_array);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
total_errors++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
log_info("\tSkipped: %s.\n", info.opcode_name);
|
|
}
|
|
}
|
|
|
|
if (is_extension_available(device, "cl_khr_image2d_from_buffer"))
|
|
{
|
|
for (onConfigInfo = 0; onConfigInfo < sizeof(image_buffer_config_infos)
|
|
/ sizeof(image_buffer_config_infos[0]);
|
|
onConfigInfo++)
|
|
{
|
|
config_info info = image_buffer_config_infos[onConfigInfo];
|
|
get = (vercmp(version, info.version) >= 0);
|
|
if (get)
|
|
{
|
|
err = getConfigInfo(device, &info);
|
|
if (!err)
|
|
{
|
|
dumpConfigInfo(&info);
|
|
}
|
|
else
|
|
{
|
|
total_errors++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
total_errors += getImageInfo(device, version);
|
|
|
|
return total_errors;
|
|
}
|
|
|
|
config_info config_platform_infos[] = {
|
|
// CL_PLATFORM_VERSION has to be first defined with version 0 0.
|
|
CONFIG_INFO(0, 0, CL_PLATFORM_VERSION, string),
|
|
CONFIG_INFO(1, 1, CL_PLATFORM_PROFILE, string),
|
|
CONFIG_INFO(1, 1, CL_PLATFORM_NAME, string),
|
|
CONFIG_INFO(1, 1, CL_PLATFORM_VENDOR, string),
|
|
CONFIG_INFO(1, 1, CL_PLATFORM_EXTENSIONS, string),
|
|
CONFIG_INFO(3, 0, CL_PLATFORM_EXTENSIONS_WITH_VERSION,
|
|
cl_name_version_array),
|
|
CONFIG_INFO(3, 0, CL_PLATFORM_NUMERIC_VERSION, cl_name_version)
|
|
};
|
|
|
|
int getPlatformCapabilities(cl_platform_id platform)
|
|
{
|
|
int total_errors = 0;
|
|
version_t version = { 0, 0 }; // Version of the device. Will get real value
|
|
// on the first loop iteration.
|
|
int err;
|
|
for (unsigned onConfigInfo = 0; onConfigInfo
|
|
< sizeof(config_platform_infos) / sizeof(config_platform_infos[0]);
|
|
onConfigInfo++)
|
|
{
|
|
config_info info = config_platform_infos[onConfigInfo];
|
|
|
|
if (vercmp(version, info.version) >= 0)
|
|
{
|
|
err = getPlatformConfigInfo(platform, &info);
|
|
if (!err)
|
|
{
|
|
dumpConfigInfo(&info);
|
|
if (info.opcode == CL_PLATFORM_VERSION)
|
|
{
|
|
err = parseVersion(info.config.string, &version);
|
|
if (err)
|
|
{
|
|
total_errors++;
|
|
free(info.config.string);
|
|
break;
|
|
}
|
|
}
|
|
if (info.config_type == type_string)
|
|
{
|
|
free(info.config.string);
|
|
}
|
|
if (info.config_type == type_cl_name_version_array)
|
|
{
|
|
free(info.config.cl_name_version_array);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
total_errors++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
log_info("\tSkipped: %s.\n", info.opcode_name);
|
|
}
|
|
}
|
|
return total_errors;
|
|
}
|
|
|
|
int test_computeinfo(cl_device_id deviceID, cl_context context,
|
|
cl_command_queue ignoreQueue, int num_elements)
|
|
{
|
|
int err;
|
|
int total_errors = 0;
|
|
cl_platform_id platform;
|
|
|
|
err = clGetPlatformIDs(1, &platform, NULL);
|
|
test_error(err, "clGetPlatformIDs failed");
|
|
|
|
// print platform info
|
|
log_info("\nclGetPlatformInfo:\n------------------\n");
|
|
err = getPlatformCapabilities(platform);
|
|
test_error(err, "getPlatformCapabilities failed");
|
|
log_info("\n");
|
|
|
|
// Check to see if this test is being run on a specific device
|
|
char* device_type_env = getenv("CL_DEVICE_TYPE");
|
|
char* device_index_env = getenv("CL_DEVICE_INDEX");
|
|
|
|
if (device_type_env || device_index_env)
|
|
{
|
|
|
|
cl_device_type device_type = CL_DEVICE_TYPE_DEFAULT;
|
|
size_t device_type_idx = 0;
|
|
size_t device_index = 0;
|
|
|
|
// Check to see if a device type was specified.
|
|
if (device_type_env)
|
|
{
|
|
if (!strcmp(device_type_env, "default")
|
|
|| !strcmp(device_type_env, "CL_DEVICE_TYPE_DEFAULT"))
|
|
{
|
|
device_type = CL_DEVICE_TYPE_DEFAULT;
|
|
device_type_idx = 0;
|
|
}
|
|
else if (!strcmp(device_type_env, "cpu")
|
|
|| !strcmp(device_type_env, "CL_DEVICE_TYPE_CPU"))
|
|
{
|
|
device_type = CL_DEVICE_TYPE_CPU;
|
|
device_type_idx = 1;
|
|
}
|
|
else if (!strcmp(device_type_env, "gpu")
|
|
|| !strcmp(device_type_env, "CL_DEVICE_TYPE_GPU"))
|
|
{
|
|
device_type = CL_DEVICE_TYPE_GPU;
|
|
device_type_idx = 2;
|
|
}
|
|
else if (!strcmp(device_type_env, "accelerator")
|
|
|| !strcmp(device_type_env, "CL_DEVICE_TYPE_ACCELERATOR"))
|
|
{
|
|
device_type = CL_DEVICE_TYPE_ACCELERATOR;
|
|
device_type_idx = 3;
|
|
}
|
|
else
|
|
{
|
|
log_error("CL_DEVICE_TYPE=\"%s\" is invalid\n",
|
|
device_type_env);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Check to see if a device index was specified
|
|
if (device_index_env) device_index = atoi(device_index_env);
|
|
|
|
// Look up the device
|
|
cl_uint num_devices;
|
|
err = clGetDeviceIDs(platform, device_type, 0, NULL, &num_devices);
|
|
if (err)
|
|
{
|
|
log_error("No devices of type %s found.\n", device_type_env);
|
|
return -1;
|
|
}
|
|
|
|
if (device_index >= num_devices)
|
|
{
|
|
log_error("CL_DEVICE_INDEX=%d is greater than the number of "
|
|
"matching devices %d\n",
|
|
(unsigned)device_index, num_devices);
|
|
return -1;
|
|
}
|
|
|
|
if (num_devices == 0)
|
|
{
|
|
log_error("No devices of type %s found.\n", device_type_env);
|
|
return -1;
|
|
}
|
|
|
|
cl_device_id* devices =
|
|
(cl_device_id*)malloc(num_devices * sizeof(cl_device_id));
|
|
err = clGetDeviceIDs(platform, device_type, num_devices, devices, NULL);
|
|
if (err)
|
|
{
|
|
log_error("No devices of type %s found.\n", device_type_env);
|
|
free(devices);
|
|
return -1;
|
|
}
|
|
|
|
cl_device_id device = devices[device_index];
|
|
free(devices);
|
|
|
|
log_info("%s Device %d of %d Info:\n",
|
|
device_infos[device_type_idx].device_type_name,
|
|
(unsigned)device_index + 1, num_devices);
|
|
total_errors += getConfigInfos(device);
|
|
log_info("\n");
|
|
}
|
|
|
|
// Otherwise iterate over all of the devices in the platform
|
|
else
|
|
{
|
|
// print device info
|
|
int onInfo;
|
|
for (onInfo = 0;
|
|
onInfo < sizeof(device_infos) / sizeof(device_infos[0]); onInfo++)
|
|
{
|
|
log_info("Getting device IDs for %s devices\n",
|
|
device_infos[onInfo].device_type_name);
|
|
err = clGetDeviceIDs(platform, device_infos[onInfo].device_type, 0,
|
|
NULL, &device_infos[onInfo].num_devices);
|
|
if (err == CL_DEVICE_NOT_FOUND)
|
|
{
|
|
log_info("No devices of type %s found.\n",
|
|
device_infos[onInfo].device_type_name);
|
|
continue;
|
|
}
|
|
test_error(err, "clGetDeviceIDs failed");
|
|
|
|
log_info("Found %d %s devices:\n", device_infos[onInfo].num_devices,
|
|
device_infos[onInfo].device_type_name);
|
|
if (device_infos[onInfo].num_devices)
|
|
{
|
|
device_infos[onInfo].devices = (cl_device_id*)malloc(
|
|
sizeof(cl_device_id) * device_infos[onInfo].num_devices);
|
|
err = clGetDeviceIDs(platform, device_infos[onInfo].device_type,
|
|
device_infos[onInfo].num_devices,
|
|
device_infos[onInfo].devices, NULL);
|
|
test_error(err, "clGetDeviceIDs failed");
|
|
}
|
|
|
|
int onDevice;
|
|
for (onDevice = 0; onDevice < device_infos[onInfo].num_devices;
|
|
onDevice++)
|
|
{
|
|
log_info("%s Device %d of %d Info:\n",
|
|
device_infos[onInfo].device_type_name, onDevice + 1,
|
|
device_infos[onInfo].num_devices);
|
|
total_errors +=
|
|
getConfigInfos(device_infos[onInfo].devices[onDevice]);
|
|
log_info("\n");
|
|
}
|
|
|
|
if (device_infos[onInfo].num_devices)
|
|
{
|
|
free(device_infos[onInfo].devices);
|
|
}
|
|
}
|
|
}
|
|
|
|
return total_errors;
|
|
}
|
|
|
|
extern int test_extended_versioning(cl_device_id, cl_context, cl_command_queue,
|
|
int);
|
|
extern int test_device_uuid(cl_device_id, cl_context, cl_command_queue, int);
|
|
|
|
extern int test_conformance_version(cl_device_id, cl_context, cl_command_queue,
|
|
int);
|
|
|
|
test_definition test_list[] = {
|
|
ADD_TEST(computeinfo),
|
|
ADD_TEST(extended_versioning),
|
|
ADD_TEST(device_uuid),
|
|
ADD_TEST_VERSION(conformance_version, Version(3, 0)),
|
|
};
|
|
|
|
const int test_num = ARRAY_SIZE(test_list);
|
|
|
|
int main(int argc, const char** argv)
|
|
{
|
|
const char** argList = (const char**)calloc(argc, sizeof(char*));
|
|
if (NULL == argList)
|
|
{
|
|
log_error("Failed to allocate memory for argList array.\n");
|
|
return 1;
|
|
}
|
|
|
|
argList[0] = argv[0];
|
|
size_t argCount = 1;
|
|
|
|
for (int i = 1; i < argc; i++)
|
|
{
|
|
if (strcmp(argv[1], "-v") == 0)
|
|
{
|
|
dump_supported_formats = 1;
|
|
}
|
|
else
|
|
{
|
|
argList[argCount] = argv[i];
|
|
argCount++;
|
|
}
|
|
}
|
|
|
|
return runTestHarness(argCount, argList, test_num, test_list, true, 0);
|
|
}
|