// // 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 #include #include #include #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 has_cl_khr_fp64; int has_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]; 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->has_cl_khr_fp64 = 1; } if (strncmp(begin, "cl_khr_fp16", length) == 0) { extensions->has_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.has_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.has_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); extern int test_pci_bus_info(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)), ADD_TEST(pci_bus_info), }; 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); }