cl_mem
piglit_cl_create_image(piglit_cl_context context, cl_mem_flags flags,
const cl_image_format *format,
const piglit_image_desc *desc)
{
cl_int errNo;
cl_mem image = NULL;
#ifdef CL_VERSION_1_2
if (piglit_cl_get_platform_version(context->platform_id) >= 12) {
image = clCreateImage(context->cl_ctx, flags, format, desc, NULL, &errNo);
} else
#endif
if (desc->image_type == CL_MEM_OBJECT_IMAGE2D) {
image = clCreateImage2D(context->cl_ctx, flags, format,
desc->image_width, desc->image_height, 0,
NULL, &errNo);
} else if (desc->image_type == CL_MEM_OBJECT_IMAGE3D) {
image = clCreateImage3D(context->cl_ctx, flags, format,
desc->image_width, desc->image_height,
desc->image_depth, 0, 0,
NULL, &errNo);
} else {
fprintf(stderr,
"Invalid image mem object type: %s\n",
piglit_cl_get_enum_name(desc->image_type));
}
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Could not create image: %s\n",
piglit_cl_get_error_name(errNo));
}
return image;
}
PIGLIT_CL_API_TEST_CONFIG_END
enum piglit_result
piglit_cl_test(const int argc,
const char** argv,
const struct piglit_cl_api_test_config* config,
const struct piglit_cl_api_test_env* env)
{
enum piglit_result result = PIGLIT_PASS;
int i;
cl_int errNo;
size_t param_value_size;
void* param_value;
bool found_invalid_platform = false;
cl_platform_id* platform_ids;
unsigned int num_platform_ids;
cl_platform_id invalid_platform_id;
int num_platform_infos =
PIGLIT_CL_ENUM_NUM(cl_platform_info, env->version);
const cl_platform_info *platform_infos =
PIGLIT_CL_ENUM_ARRAY(cl_platform_info);
/* Find invalid platform_id */
invalid_platform_id = 0;
num_platform_ids = piglit_cl_get_platform_ids(&platform_ids);
while(!found_invalid_platform) {
found_invalid_platform = true;
invalid_platform_id = (cl_platform_id)1;
for(i = 0; i < num_platform_ids; i++) {
if(invalid_platform_id == platform_ids[i]) {
found_invalid_platform = false;
break;
}
}
}
free(platform_ids);
/*** Normal usage ***/
for(i = 0; i < num_platform_infos; i++) {
printf("%s: ", piglit_cl_get_enum_name(platform_infos[i]));
errNo = clGetPlatformInfo(env->platform_id,
platform_infos[i],
0,
NULL,
¶m_value_size);
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Failed (error code: %s): Get size of %s.\n",
piglit_cl_get_error_name(errNo),
piglit_cl_get_enum_name(platform_infos[i]));
piglit_merge_result(&result, PIGLIT_FAIL);
continue;
}
param_value = malloc(param_value_size);
errNo = clGetPlatformInfo(env->platform_id,
platform_infos[i],
param_value_size,
param_value,
NULL);
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Failed (error code: %s): Get value of %s.\n",
piglit_cl_get_error_name(errNo),
piglit_cl_get_enum_name(platform_infos[i]));
piglit_merge_result(&result, PIGLIT_FAIL);
}
printf("%s\n", (char*)param_value);
free(param_value);
}
/*** Errors **/
/*
* CL_INVALID_VALUE if param_name is not one of the supported
* values or if size in bytes specified by param_value_size is
* less than size of return type and param_value is not a NULL
* value.
*/
errNo = clGetPlatformInfo(env->platform_id,
CL_PLATFORM_PROFILE,
1,
param_value,
NULL);
if(!piglit_cl_check_error(errNo, CL_INVALID_VALUE)) {
fprintf(stderr,
"Failed (error code: %s): Trigger CL_INVALID_VALUE if param_name is not one of the supported values.\n",
piglit_cl_get_error_name(errNo));
piglit_merge_result(&result, PIGLIT_FAIL);
}
errNo = clGetPlatformInfo(env->platform_id,
CL_DEVICE_NAME,
0,
NULL,
¶m_value_size);
if(!piglit_cl_check_error(errNo, CL_INVALID_VALUE)) {
fprintf(stderr,
"Failed (error code: %s): Trigger CL_INVALID_VALUE if size in bytes specified by param_value is less than size of return type and param_value is not a NULL value.\n",
piglit_cl_get_error_name(errNo));
piglit_merge_result(&result, PIGLIT_FAIL);
}
return result;
}
PIGLIT_CL_API_TEST_CONFIG_END
enum piglit_result
piglit_cl_test(const int argc,
const char** argv,
const struct piglit_cl_api_test_config* config,
const struct piglit_cl_api_test_env* env)
{
enum piglit_result result = PIGLIT_PASS;
int i;
cl_int errNo;
cl_command_queue command_queue = env->context->command_queues[0];
size_t param_value_size;
void* param_value;
int num_command_queue_infos =
PIGLIT_CL_ENUM_NUM(cl_command_queue_info, env->version);
const cl_command_queue_info *command_queue_infos =
PIGLIT_CL_ENUM_ARRAY(cl_command_queue_info);
/*** Normal usage ***/
for(i = 0; i < num_command_queue_infos; i++) {
printf("%s ", piglit_cl_get_enum_name(command_queue_infos[i]));
errNo = clGetCommandQueueInfo(command_queue,
command_queue_infos[i],
0,
NULL,
¶m_value_size);
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Failed (error code: %s): Get size of %s.\n",
piglit_cl_get_error_name(errNo),
piglit_cl_get_enum_name(command_queue_infos[i]));
piglit_merge_result(&result, PIGLIT_FAIL);
continue;
}
param_value = malloc(param_value_size);
errNo = clGetCommandQueueInfo(command_queue,
command_queue_infos[i],
param_value_size,
param_value,
NULL);
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Failed (error code: %s): Get value of %s.\n",
piglit_cl_get_error_name(errNo),
piglit_cl_get_enum_name(command_queue_infos[i]));
piglit_merge_result(&result, PIGLIT_FAIL);
}
//TODO: output returned values
printf("\n");
free(param_value);
}
/*** Errors ***/
/*
* CL_INVALID_VALUE if param_name is not one of the supported
* values or if size in bytes specified by param_value_size is
* less than size of return type and param_value is not a NULL
* value.
*/
errNo = clGetCommandQueueInfo(command_queue,
CL_PLATFORM_NAME,
0,
NULL,
¶m_value_size);
if(!piglit_cl_check_error(errNo, CL_INVALID_VALUE)) {
fprintf(stderr,
"Failed (error code: %s): Trigger CL_INVALID_VALUE if param_name is not one of the supported values.\n",
piglit_cl_get_error_name(errNo));
piglit_merge_result(&result, PIGLIT_FAIL);
}
errNo = clGetCommandQueueInfo(command_queue,
CL_QUEUE_REFERENCE_COUNT,
1,
param_value,
NULL);
if(!piglit_cl_check_error(errNo, CL_INVALID_VALUE)) {
fprintf(stderr,
"Failed (error code: %s): Trigger CL_INVALID_VALUE if size in bytes specified by param_value is less than size of return type and param_value is not a NULL value.\n",
piglit_cl_get_error_name(errNo));
piglit_merge_result(&result, PIGLIT_FAIL);
}
/*
* CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command queue.
*/
errNo = clGetCommandQueueInfo(NULL,
CL_QUEUE_CONTEXT,
0,
NULL,
¶m_value_size);
if(!piglit_cl_check_error(errNo, CL_INVALID_COMMAND_QUEUE)) {
fprintf(stderr,
"Failed (error code: %s): Trigger CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command queue.\n",
piglit_cl_get_error_name(errNo));
piglit_merge_result(&result, PIGLIT_FAIL);
}
return result;
}
static void*
piglit_cl_get_info(void* fn_ptr, void* obj, cl_uint param)
{
cl_int errNo;
size_t param_size;
void* param_ptr = NULL;
/* get param size */
if(fn_ptr == clGetPlatformInfo) {
errNo = clGetPlatformInfo(*(cl_platform_id*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetDeviceInfo) {
errNo = clGetDeviceInfo(*(cl_device_id*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetContextInfo) {
errNo = clGetContextInfo(*(cl_context*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetCommandQueueInfo) {
errNo = clGetCommandQueueInfo(*(cl_command_queue*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetMemObjectInfo) {
errNo = clGetMemObjectInfo(*(cl_mem*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetImageInfo) {
errNo = clGetImageInfo(*(cl_mem*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetSamplerInfo) {
errNo = clGetSamplerInfo(*(cl_sampler*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetProgramInfo) {
errNo = clGetProgramInfo(*(cl_program*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetProgramBuildInfo) {
errNo = clGetProgramBuildInfo(((struct _program_build_info_args*)obj)->program,
((struct _program_build_info_args*)obj)->device,
param, 0, NULL, ¶m_size);
} else if(fn_ptr == clGetKernelInfo) {
errNo = clGetKernelInfo(*(cl_kernel*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetKernelWorkGroupInfo) {
errNo = clGetKernelWorkGroupInfo(((struct _kernel_work_group_info_args*)obj)->kernel,
((struct _kernel_work_group_info_args*)obj)->device,
param, 0, NULL, ¶m_size);
} else if(fn_ptr == clGetEventInfo) {
errNo = clGetEventInfo(*(cl_event*)obj, param, 0, NULL,
¶m_size);
} else if(fn_ptr == clGetEventProfilingInfo) {
errNo = clGetEventProfilingInfo(*(cl_event*)obj, param, 0, NULL,
¶m_size);
} else {
fprintf(stderr,
"Trying to get %s information from undefined function.\n",
piglit_cl_get_enum_name(param));
piglit_report_result(PIGLIT_FAIL);
}
if(errNo == CL_SUCCESS) {
param_ptr = calloc(param_size, sizeof(char));
/* retrieve param */
if(fn_ptr == clGetPlatformInfo) {
errNo = clGetPlatformInfo(*(cl_platform_id*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetDeviceInfo) {
errNo = clGetDeviceInfo(*(cl_device_id*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetContextInfo) {
errNo = clGetContextInfo(*(cl_context*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetCommandQueueInfo) {
errNo = clGetCommandQueueInfo(*(cl_command_queue*)obj,
param, param_size, param_ptr, NULL);
} else if(fn_ptr == clGetMemObjectInfo) {
errNo = clGetMemObjectInfo(*(cl_mem*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetImageInfo) {
errNo = clGetImageInfo(*(cl_mem*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetSamplerInfo) {
errNo = clGetSamplerInfo(*(cl_sampler*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetProgramInfo) {
errNo = clGetProgramInfo(*(cl_program*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetProgramBuildInfo) {
errNo = clGetProgramBuildInfo(((struct _program_build_info_args*)obj)->program,
((struct _program_build_info_args*)obj)->device,
param, param_size, param_ptr, NULL);
} else if(fn_ptr == clGetKernelInfo) {
errNo = clGetKernelInfo(*(cl_kernel*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetKernelWorkGroupInfo) {
errNo = clGetKernelWorkGroupInfo(((struct _kernel_work_group_info_args*)obj)->kernel,
((struct _kernel_work_group_info_args*)obj)->device,
param, param_size, param_ptr, NULL);
} else if(fn_ptr == clGetEventInfo) {
errNo = clGetEventInfo(*(cl_event*)obj, param,
param_size, param_ptr, NULL);
} else if(fn_ptr == clGetEventProfilingInfo) {
errNo = clGetEventProfilingInfo(*(cl_event*)obj, param,
param_size, param_ptr, NULL);
}
if(errNo != CL_SUCCESS) {
free(param_ptr);
param_ptr = NULL;
}
}
if(param_ptr == NULL) {
fprintf(stderr,
"Unable to get %s information (Error: %s)\n",
piglit_cl_get_enum_name(param),
piglit_cl_get_error_name(errNo));
piglit_report_result(PIGLIT_FAIL);
}
return param_ptr;
}