Victor Zhang
1924 строки
69 KiB
C
1924 строки
69 KiB
C
/* Modifications Copyright(C) 2022 Advanced Micro Devices, Inc.
|
|
* All rights reserved.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#ifndef CL_USE_DEPRECATED_OPENCL_1_0_APIS
|
|
#define CL_USE_DEPRECATED_OPENCL_1_0_APIS
|
|
#endif
|
|
|
|
#ifndef CL_USE_DEPRECATED_OPENCL_1_1_APIS
|
|
#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
|
|
#endif
|
|
|
|
// Need to rename all CL API functions to prevent ICD loader functions calling
|
|
// themselves via the dispatch table. Include this before cl headers.
|
|
#include "rename_api.h"
|
|
|
|
#include <CL/cl.h>
|
|
#include <platform/icd_test_log.h>
|
|
#include "icd_structs.h"
|
|
|
|
#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clIcdGetPlatformIDsKHR(cl_uint, cl_platform_id *, cl_uint *);
|
|
|
|
struct _cl_platform_id
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
const char *profile;
|
|
const char *version;
|
|
const char *name;
|
|
const char *vendor;
|
|
const char *extensions;
|
|
const char *suffix;
|
|
};
|
|
|
|
struct _cl_device_id
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_context
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_command_queue
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_mem
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_program
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_kernel
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_event
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
struct _cl_sampler
|
|
{
|
|
CLIicdDispatchTable* dispatch;
|
|
};
|
|
|
|
static CLIicdDispatchTable* dispatchTable = NULL;
|
|
static cl_platform_id platform = NULL;
|
|
static cl_bool initialized = CL_FALSE;
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetPlatformIDs(cl_uint num_entries ,
|
|
cl_platform_id * platforms ,
|
|
cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetPlatformIDs(%u, %p, %p)\n",
|
|
num_entries,
|
|
platforms,
|
|
num_platforms);
|
|
return_value = clIcdGetPlatformIDsKHR(num_entries, platforms, num_platforms);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetPlatformInfo(cl_platform_id platform,
|
|
cl_platform_info param_name,
|
|
size_t param_value_size,
|
|
void * param_value,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int ret = CL_SUCCESS;
|
|
const char *returnString = NULL;
|
|
size_t returnStringLength = 0;
|
|
/*test_icd_stub_log("clGetPlatformInfo(%p, %u, %u, %p, %p)\n",
|
|
platform,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);*/
|
|
|
|
// validate the arguments
|
|
if (param_value_size == 0 && param_value != NULL) {
|
|
ret = CL_INVALID_VALUE;
|
|
goto done;
|
|
}
|
|
// select the string to return
|
|
switch(param_name) {
|
|
case CL_PLATFORM_PROFILE:
|
|
returnString = platform->profile;
|
|
break;
|
|
case CL_PLATFORM_VERSION:
|
|
returnString = platform->version;
|
|
break;
|
|
case CL_PLATFORM_NAME:
|
|
returnString = platform->name;
|
|
break;
|
|
case CL_PLATFORM_VENDOR:
|
|
returnString = platform->vendor;
|
|
break;
|
|
case CL_PLATFORM_EXTENSIONS:
|
|
returnString = platform->extensions;
|
|
break;
|
|
case CL_PLATFORM_ICD_SUFFIX_KHR:
|
|
returnString = platform->suffix;
|
|
break;
|
|
default:
|
|
ret = CL_INVALID_VALUE;
|
|
goto done;
|
|
}
|
|
|
|
// make sure the buffer passed in is big enough for the result
|
|
returnStringLength = strlen(returnString)+1;
|
|
if (param_value_size && param_value_size < returnStringLength) {
|
|
ret = CL_INVALID_VALUE;
|
|
goto done;
|
|
}
|
|
|
|
// pass the data back to the user
|
|
if (param_value) {
|
|
memcpy(param_value, returnString, returnStringLength);
|
|
}
|
|
if (param_value_size_ret) {
|
|
*param_value_size_ret = returnStringLength;
|
|
}
|
|
|
|
done:
|
|
/*test_icd_stub_log("Value returned: %d\n",
|
|
return_value);*/
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Device APIs */
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetDeviceIDs(cl_platform_id platform,
|
|
cl_device_type device_type,
|
|
cl_uint num_entries,
|
|
cl_device_id * devices,
|
|
cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int ret = CL_SUCCESS;
|
|
|
|
if ((num_entries > 1 || num_entries < 0) && devices != NULL) {
|
|
ret = CL_INVALID_VALUE;
|
|
goto done;
|
|
}
|
|
|
|
if (devices != NULL) {
|
|
cl_device_id obj = (cl_device_id) malloc(sizeof(*obj));
|
|
obj->dispatch = dispatchTable;
|
|
devices[0] = obj;
|
|
}
|
|
if (num_devices) {
|
|
*num_devices = 1;
|
|
}
|
|
|
|
done:
|
|
test_icd_stub_log("clGetDeviceIDs(%p, %x, %u, %p, %p)\n",
|
|
platform,
|
|
device_type,
|
|
num_entries,
|
|
devices,
|
|
num_devices);
|
|
test_icd_stub_log("Value returned: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetDeviceInfo(cl_device_id device,
|
|
cl_device_info param_name,
|
|
size_t param_value_size,
|
|
void * param_value,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetDeviceInfo(%p, %u, %u, %p, %p)\n",
|
|
device,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clCreateSubDevices(cl_device_id in_device,
|
|
const cl_device_partition_property *properties,
|
|
cl_uint num_entries,
|
|
cl_device_id *out_devices,
|
|
cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
|
|
test_icd_stub_log("clCreateSubDevices(%p, %p, %u, %p, %p)\n",
|
|
in_device,
|
|
properties,
|
|
num_entries,
|
|
out_devices,
|
|
num_devices);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainDevice(%p)\n", device);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
|
|
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseDevice(%p)\n", device);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
/* Context APIs */
|
|
CL_API_ENTRY cl_context CL_API_CALL
|
|
clCreateContext(const cl_context_properties * properties,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * devices,
|
|
void (CL_CALLBACK * pfn_notify)(const char *, const void *, size_t, void *),
|
|
void * user_data,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_context obj = (cl_context) malloc(sizeof(struct _cl_context));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateContext(%p, %u, %p, %p, %p, %p)\n",
|
|
properties,
|
|
num_devices,
|
|
devices,
|
|
pfn_notify,
|
|
user_data,
|
|
errcode_ret);
|
|
pfn_notify(NULL, NULL, 0, NULL);
|
|
test_icd_stub_log("createcontext_callback(%p, %p, %u, %p)\n",
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_context CL_API_CALL
|
|
clCreateContextFromType(const cl_context_properties * properties,
|
|
cl_device_type device_type,
|
|
void (CL_CALLBACK * pfn_notify)(const char *, const void *, size_t, void *),
|
|
void * user_data,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_context obj = (cl_context) malloc(sizeof(struct _cl_context));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateContextFromType(%p, %x, %p, %p, %p)\n",
|
|
properties,
|
|
device_type,
|
|
pfn_notify,
|
|
user_data,
|
|
errcode_ret);
|
|
pfn_notify(NULL, NULL, 0, NULL);
|
|
|
|
test_icd_stub_log ("createcontext_callback(%p, %p, %u, %p)\n",
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL);
|
|
|
|
test_icd_stub_log("Value returned: %p\n",
|
|
obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainContext(%p)\n", context);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseContext(%p)\n", context);
|
|
free(context);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetContextInfo(cl_context context,
|
|
cl_context_info param_name,
|
|
size_t param_value_size,
|
|
void * param_value,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetContextInfo(%p, %u, %u, %p, %p)\n",
|
|
context,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Command Queue APIs */
|
|
CL_API_ENTRY cl_command_queue CL_API_CALL
|
|
clCreateCommandQueue(cl_context context,
|
|
cl_device_id device,
|
|
cl_command_queue_properties properties,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_command_queue obj = (cl_command_queue) malloc(sizeof(struct _cl_command_queue));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateCommandQueue(%p, %p, %x, %p)\n",
|
|
context,
|
|
device,
|
|
properties,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetCommandQueueProperty(cl_command_queue command_queue ,
|
|
cl_command_queue_properties properties ,
|
|
cl_bool enable ,
|
|
cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetCommandQueueProperty(%p, %p, %u, %p)\n",
|
|
command_queue,
|
|
properties,
|
|
enable,
|
|
old_properties);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainCommandQueue(%p)\n", command_queue);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseCommandQueue(%p)\n", command_queue);
|
|
free(command_queue);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetCommandQueueInfo(cl_command_queue command_queue ,
|
|
cl_command_queue_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetCommandQueueInfo(%p, %u, %u, %p, %p)\n",
|
|
command_queue,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
|
|
/* Memory Object APIs */
|
|
CL_API_ENTRY cl_mem CL_API_CALL
|
|
clCreateBuffer(cl_context context ,
|
|
cl_mem_flags flags ,
|
|
size_t size ,
|
|
void * host_ptr ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateBuffer(%p, %x, %u, %p, %p)\n",
|
|
context,
|
|
flags,
|
|
size,
|
|
host_ptr,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_mem CL_API_CALL
|
|
clCreateSubBuffer(cl_mem buffer ,
|
|
cl_mem_flags flags ,
|
|
cl_buffer_create_type buffer_create_type ,
|
|
const void * buffer_create_info ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateSubBuffer(%p, %x, %u, %p, %p)\n",
|
|
buffer,
|
|
flags,
|
|
buffer_create_type,
|
|
buffer_create_info,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_mem CL_API_CALL
|
|
clCreateImage(cl_context context,
|
|
cl_mem_flags flags,
|
|
const cl_image_format * image_format,
|
|
const cl_image_desc * image_desc,
|
|
void * host_ptr,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateImage(%p, %x, %p, %p, %p, %p)\n",
|
|
context,
|
|
flags,
|
|
image_format,
|
|
image_desc,
|
|
host_ptr,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_mem CL_API_CALL
|
|
clCreateImage2D(cl_context context ,
|
|
cl_mem_flags flags ,
|
|
const cl_image_format * image_format ,
|
|
size_t image_width ,
|
|
size_t image_height ,
|
|
size_t image_row_pitch ,
|
|
void * host_ptr ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateImage2D(%p, %x, %p, %u, %u, %u, %p, %p)\n",
|
|
context,
|
|
flags,
|
|
image_format,
|
|
image_width,
|
|
image_height,
|
|
image_row_pitch,
|
|
host_ptr,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_mem CL_API_CALL
|
|
clCreateImage3D(cl_context context,
|
|
cl_mem_flags flags,
|
|
const cl_image_format * image_format,
|
|
size_t image_width,
|
|
size_t image_height ,
|
|
size_t image_depth ,
|
|
size_t image_row_pitch ,
|
|
size_t image_slice_pitch ,
|
|
void * host_ptr ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateImage3D(%p, %x, %p, %u, %u, %u, %u, %u, %p, %p)\n",
|
|
context,
|
|
flags,
|
|
image_format,
|
|
image_width,
|
|
image_height,
|
|
image_depth,
|
|
image_row_pitch,
|
|
image_slice_pitch,
|
|
host_ptr,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainMemObject(%p)\n", memobj);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseMemObject(%p)\n", memobj);
|
|
free(memobj);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetSupportedImageFormats(cl_context context,
|
|
cl_mem_flags flags,
|
|
cl_mem_object_type image_type ,
|
|
cl_uint num_entries ,
|
|
cl_image_format * image_formats ,
|
|
cl_uint * num_image_formats) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetSupportedImageFormats(%p, %x, %u, %u, %p, %p)\n",
|
|
context,
|
|
flags,
|
|
image_type,
|
|
num_entries,
|
|
image_formats,
|
|
num_image_formats);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetMemObjectInfo(cl_mem memobj ,
|
|
cl_mem_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetMemObjectInfo(%p, %u, %u, %p, %p)\n",
|
|
memobj,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetImageInfo(cl_mem image ,
|
|
cl_image_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetImageInfo(%p, %u, %u, %p, %p)\n",
|
|
image,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetMemObjectDestructorCallback(cl_mem memobj ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_mem memobj , void* user_data),
|
|
void * user_data) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetMemObjectDestructorCallback(%p, %p, %p)\n",
|
|
memobj,
|
|
pfn_notify,
|
|
user_data);
|
|
pfn_notify(memobj, NULL);
|
|
test_icd_stub_log("setmemobjectdestructor_callback(%p, %p)\n",
|
|
memobj,
|
|
NULL);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Sampler APIs */
|
|
CL_API_ENTRY cl_sampler CL_API_CALL
|
|
clCreateSampler(cl_context context ,
|
|
cl_bool normalized_coords ,
|
|
cl_addressing_mode addressing_mode ,
|
|
cl_filter_mode filter_mode ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_sampler obj = (cl_sampler) malloc(sizeof(struct _cl_sampler));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateSampler(%p, %u, %u, %u, %p)\n",
|
|
context,
|
|
normalized_coords,
|
|
addressing_mode,
|
|
filter_mode,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainSampler(%p)\n", sampler);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseSampler(%p)\n", sampler);
|
|
free(sampler);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetSamplerInfo(cl_sampler sampler ,
|
|
cl_sampler_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetSamplerInfo(%p, %u, %u, %p, %p)\n",
|
|
sampler,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Program Object APIs */
|
|
CL_API_ENTRY cl_program CL_API_CALL
|
|
clCreateProgramWithSource(cl_context context ,
|
|
cl_uint count ,
|
|
const char ** strings ,
|
|
const size_t * lengths ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateProgramWithSource(%p, %u, %p, %p, %p)\n",
|
|
context,
|
|
count,
|
|
strings,
|
|
lengths,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_program CL_API_CALL
|
|
clCreateProgramWithBinary(cl_context context ,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * device_list ,
|
|
const size_t * lengths ,
|
|
const unsigned char ** binaries ,
|
|
cl_int * binary_status ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateProgramWithBinary(%p, %u, %p, %p, %p, %p, %p)\n",
|
|
context,
|
|
num_devices,
|
|
device_list,
|
|
lengths,
|
|
binaries,
|
|
binary_status,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_program CL_API_CALL
|
|
clCreateProgramWithBuiltInKernels(cl_context context ,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * device_list ,
|
|
const char * kernel_names ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateProgramWithBuiltInKernels(%p, %u, %p, %p, %p)\n",
|
|
context,
|
|
num_devices,
|
|
device_list,
|
|
kernel_names,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainProgram(%p)\n",
|
|
program);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseProgram(%p)\n", program);
|
|
free(program);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clBuildProgram(cl_program program ,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * device_list ,
|
|
const char * options ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_program program , void * user_data),
|
|
void * user_data) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clBuildProgram(%p, %u, %p, %p, %p, %p)\n",
|
|
program,
|
|
num_devices,
|
|
device_list,
|
|
options,
|
|
pfn_notify,
|
|
user_data);
|
|
pfn_notify(program, NULL);
|
|
test_icd_stub_log("program_callback(%p, %p)\n", program, NULL);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clUnloadCompiler()\n");
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clCompileProgram(cl_program program ,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * device_list ,
|
|
const char * options ,
|
|
cl_uint num_input_headers ,
|
|
const cl_program * input_headers,
|
|
const char ** header_include_names ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_program program , void * user_data),
|
|
void * user_data) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clCompileProgram(%p, %u, %p, %p, %u, %p, %p, %p)\n",
|
|
program,
|
|
num_devices,
|
|
device_list,
|
|
options,
|
|
num_input_headers,
|
|
header_include_names,
|
|
pfn_notify,
|
|
user_data);
|
|
pfn_notify(program, NULL);
|
|
test_icd_stub_log("program_callback(%p, %p)\n", program, NULL);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_program CL_API_CALL
|
|
clLinkProgram(cl_context context ,
|
|
cl_uint num_devices ,
|
|
const cl_device_id * device_list ,
|
|
const char * options ,
|
|
cl_uint num_input_programs ,
|
|
const cl_program * input_programs ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_program program , void * user_data),
|
|
void * user_data ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_program obj = (cl_program) malloc(sizeof(cl_program));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clLinkProgram(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n",
|
|
context,
|
|
num_devices,
|
|
device_list,
|
|
options,
|
|
num_input_programs,
|
|
input_programs,
|
|
pfn_notify,
|
|
user_data,
|
|
errcode_ret);
|
|
pfn_notify(obj, NULL);
|
|
test_icd_stub_log("program_callback(%p, %p)\n", obj, NULL);
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clUnloadPlatformCompiler(%p)\n", platform);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetProgramInfo(cl_program program ,
|
|
cl_program_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetProgramInfo(%p, %u, %u, %p, %p)\n",
|
|
program,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetProgramBuildInfo(cl_program program ,
|
|
cl_device_id device ,
|
|
cl_program_build_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetProgramBuildInfo(%p, %p, %u, %u, %p, %p)\n",
|
|
program,
|
|
device,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Kernel Object APIs */
|
|
CL_API_ENTRY cl_kernel CL_API_CALL
|
|
clCreateKernel(cl_program program ,
|
|
const char * kernel_name ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_kernel obj = (cl_kernel) malloc(sizeof(struct _cl_kernel));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateKernel(%p, %p, %p)\n",
|
|
program,
|
|
kernel_name,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clCreateKernelsInProgram(cl_program program ,
|
|
cl_uint num_kernels ,
|
|
cl_kernel * kernels ,
|
|
cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clCreateKernelsInProgram(%p, %u, %p, %p)\n",
|
|
program,
|
|
num_kernels,
|
|
kernels,
|
|
num_kernels_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainKernel(%p)\n", kernel);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseKernel(%p)\n", kernel);
|
|
free(kernel);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetKernelArg(cl_kernel kernel ,
|
|
cl_uint arg_index ,
|
|
size_t arg_size ,
|
|
const void * arg_value) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetKernelArg(%p, %u, %u, %p)\n",
|
|
kernel,
|
|
arg_index,
|
|
arg_size,
|
|
arg_value);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetKernelInfo(cl_kernel kernel ,
|
|
cl_kernel_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetKernelInfo(%p, %u, %u, %p, %p)\n",
|
|
kernel,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetKernelArgInfo(cl_kernel kernel ,
|
|
cl_uint arg_indx ,
|
|
cl_kernel_arg_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetKernelArgInfo(%p, %u, %u, %u, %p, %p)\n",
|
|
kernel,
|
|
arg_indx,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetKernelWorkGroupInfo(cl_kernel kernel ,
|
|
cl_device_id device ,
|
|
cl_kernel_work_group_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetKernelWorkGroupInfo(%p, %p, %u, %u, %p, %p)\n",
|
|
kernel,
|
|
device,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Event Object APIs */
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clWaitForEvents(cl_uint num_events ,
|
|
const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clWaitForEvents(%u, %p)\n",
|
|
num_events,
|
|
event_list);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetEventInfo(cl_event event ,
|
|
cl_event_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetEventInfo(%p, %u, %u, %p, %p)\n",
|
|
event,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_event CL_API_CALL
|
|
clCreateUserEvent(cl_context context ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_event obj = (cl_event) malloc(sizeof(struct _cl_event));
|
|
obj->dispatch = dispatchTable;
|
|
test_icd_stub_log("clCreateUserEvent(%p, %p)\n", context, errcode_ret);
|
|
test_icd_stub_log("Value returned: %p\n", obj);
|
|
return obj;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clRetainEvent(%p)\n", event);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clReleaseEvent(%p)\n", event);
|
|
free(event);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetUserEventStatus(cl_event event ,
|
|
cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetUserEventStatus(%p, %d)\n",
|
|
event,
|
|
execution_status);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetEventCallback(cl_event event ,
|
|
cl_int command_exec_callback_type ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *),
|
|
void * user_data) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetEventCallback(%p, %d, %p, %p)\n",
|
|
event,
|
|
command_exec_callback_type,
|
|
pfn_notify,
|
|
user_data);
|
|
pfn_notify(event, command_exec_callback_type, NULL);
|
|
test_icd_stub_log("setevent_callback(%p, %d, %p)\n",
|
|
event,
|
|
command_exec_callback_type,
|
|
NULL);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Profiling APIs */
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetEventProfilingInfo(cl_event event ,
|
|
cl_profiling_info param_name ,
|
|
size_t param_value_size ,
|
|
void * param_value ,
|
|
size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clGetEventProfilingInfo(%p, %u, %u, %p, %p)\n",
|
|
event,
|
|
param_name,
|
|
param_value_size,
|
|
param_value,
|
|
param_value_size_ret);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Flush and Finish APIs */
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clFlush(%p)\n", command_queue);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clFinish(%p)\n", command_queue);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
/* Enqueued Commands APIs */
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueReadBuffer(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
cl_bool blocking_read ,
|
|
size_t offset ,
|
|
size_t cb ,
|
|
void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueReadBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
blocking_read,
|
|
offset,
|
|
cb,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list, event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueReadBufferRect(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
cl_bool blocking_read ,
|
|
const size_t * buffer_origin ,
|
|
const size_t * host_origin ,
|
|
const size_t * region ,
|
|
size_t buffer_row_pitch ,
|
|
size_t buffer_slice_pitch ,
|
|
size_t host_row_pitch ,
|
|
size_t host_slice_pitch ,
|
|
void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueReadBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
blocking_read,
|
|
buffer_origin,
|
|
host_origin,
|
|
region,
|
|
buffer_row_pitch,
|
|
buffer_slice_pitch,
|
|
host_row_pitch,
|
|
host_slice_pitch,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueWriteBuffer(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
cl_bool blocking_write ,
|
|
size_t offset ,
|
|
size_t cb ,
|
|
const void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueWriteBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
blocking_write,
|
|
offset,
|
|
cb,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueWriteBufferRect(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
cl_bool blocking_write ,
|
|
const size_t * buffer_origin ,
|
|
const size_t * host_origin ,
|
|
const size_t * region ,
|
|
size_t buffer_row_pitch ,
|
|
size_t buffer_slice_pitch ,
|
|
size_t host_row_pitch ,
|
|
size_t host_slice_pitch ,
|
|
const void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueWriteBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
blocking_write,
|
|
buffer_origin,
|
|
host_origin,
|
|
region,
|
|
buffer_row_pitch,
|
|
buffer_slice_pitch,
|
|
host_row_pitch,
|
|
host_slice_pitch,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueCopyBuffer(cl_command_queue command_queue ,
|
|
cl_mem src_buffer ,
|
|
cl_mem dst_buffer ,
|
|
size_t src_offset ,
|
|
size_t dst_offset ,
|
|
size_t cb ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueCopyBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
|
|
command_queue,
|
|
src_buffer,
|
|
dst_buffer,
|
|
src_offset,
|
|
dst_offset,
|
|
cb,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueCopyBufferRect(cl_command_queue command_queue ,
|
|
cl_mem src_buffer ,
|
|
cl_mem dst_buffer ,
|
|
const size_t * src_origin ,
|
|
const size_t * dst_origin ,
|
|
const size_t * region ,
|
|
size_t src_row_pitch ,
|
|
size_t src_slice_pitch ,
|
|
size_t dst_row_pitch ,
|
|
size_t dst_slice_pitch ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_1
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueCopyBufferRect(%p, %p, %p, %p, %p, %p, %u, %u, %u, %u, %u, %p, %p)\n",
|
|
command_queue,
|
|
src_buffer,
|
|
dst_buffer,
|
|
src_origin,
|
|
dst_origin,
|
|
region,
|
|
src_row_pitch,
|
|
src_slice_pitch,
|
|
dst_row_pitch,
|
|
dst_slice_pitch,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueFillBuffer(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
const void * pattern ,
|
|
size_t pattern_size ,
|
|
size_t offset ,
|
|
size_t cb ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueFillBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
pattern,
|
|
pattern_size,
|
|
offset,
|
|
cb,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueFillImage(cl_command_queue command_queue ,
|
|
cl_mem image ,
|
|
const void * fill_color ,
|
|
const size_t * origin ,
|
|
const size_t * region ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueFillImage(%p, %p, %p, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
image,
|
|
fill_color,
|
|
origin,
|
|
region,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueReadImage(cl_command_queue command_queue ,
|
|
cl_mem image ,
|
|
cl_bool blocking_read ,
|
|
const size_t * origin ,
|
|
const size_t * region ,
|
|
size_t row_pitch ,
|
|
size_t slice_pitch ,
|
|
void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueReadImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
image,
|
|
blocking_read,
|
|
origin,
|
|
region,
|
|
row_pitch,
|
|
slice_pitch,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueWriteImage(cl_command_queue command_queue ,
|
|
cl_mem image ,
|
|
cl_bool blocking_write ,
|
|
const size_t * origin ,
|
|
const size_t * region ,
|
|
size_t input_row_pitch ,
|
|
size_t input_slice_pitch ,
|
|
const void * ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueWriteImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
image,
|
|
blocking_write,
|
|
origin,
|
|
region,
|
|
input_row_pitch,
|
|
input_slice_pitch,
|
|
ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueCopyImage(cl_command_queue command_queue ,
|
|
cl_mem src_image ,
|
|
cl_mem dst_image ,
|
|
const size_t * src_origin ,
|
|
const size_t * dst_origin ,
|
|
const size_t * region ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueCopyImage(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
src_image,
|
|
dst_image,
|
|
src_origin,
|
|
dst_origin,
|
|
region,
|
|
num_events_in_wait_list,
|
|
event_wait_list ,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueCopyImageToBuffer(cl_command_queue command_queue ,
|
|
cl_mem src_image ,
|
|
cl_mem dst_buffer ,
|
|
const size_t * src_origin ,
|
|
const size_t * region ,
|
|
size_t dst_offset ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueCopyImageToBuffer(%p, %p, %p, %p, %p, %u, %u, %p, %p)\n",
|
|
command_queue,
|
|
src_image,
|
|
dst_buffer,
|
|
src_origin,
|
|
region,
|
|
dst_offset,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueCopyBufferToImage(cl_command_queue command_queue ,
|
|
cl_mem src_buffer ,
|
|
cl_mem dst_image ,
|
|
size_t src_offset ,
|
|
const size_t * dst_origin ,
|
|
const size_t * region ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueCopyBufferToImage(%p, %p, %p, %u, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
src_buffer,
|
|
dst_image,
|
|
src_offset,
|
|
dst_origin,
|
|
region,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY void * CL_API_CALL
|
|
clEnqueueMapBuffer(cl_command_queue command_queue ,
|
|
cl_mem buffer ,
|
|
cl_bool blocking_map ,
|
|
cl_map_flags map_flags ,
|
|
size_t offset ,
|
|
size_t cb ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
void *return_value = (void *) malloc(sizeof(void *));
|
|
test_icd_stub_log("clEnqueueMapBuffer(%p, %p, %u, %x, %u, %u, %u, %p, %p, %p)\n",
|
|
command_queue,
|
|
buffer,
|
|
blocking_map,
|
|
map_flags,
|
|
offset,
|
|
cb,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY void * CL_API_CALL
|
|
clEnqueueMapImage(cl_command_queue command_queue ,
|
|
cl_mem image ,
|
|
cl_bool blocking_map ,
|
|
cl_map_flags map_flags ,
|
|
const size_t * origin ,
|
|
const size_t * region ,
|
|
size_t * image_row_pitch ,
|
|
size_t * image_slice_pitch ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event ,
|
|
cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
void *return_value = (void *) malloc(sizeof(void *));
|
|
test_icd_stub_log("clEnqueueMapImage(%p, %p, %u, %x, %p, %p, %p, %p, %u, %p, %p, %p)\n",
|
|
command_queue,
|
|
image,
|
|
blocking_map,
|
|
map_flags,
|
|
origin,
|
|
region,
|
|
image_row_pitch,
|
|
image_slice_pitch,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event,
|
|
errcode_ret);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueUnmapMemObject(cl_command_queue command_queue ,
|
|
cl_mem memobj ,
|
|
void * mapped_ptr ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueUnmapMemObject(%p, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
memobj,
|
|
mapped_ptr,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueMigrateMemObjects(cl_command_queue command_queue ,
|
|
cl_uint num_mem_objects ,
|
|
const cl_mem * mem_objects ,
|
|
cl_mem_migration_flags flags ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueMigrateMemObjects(%p, %u, %p, %x, %u, %p, %p)\n",
|
|
command_queue,
|
|
num_mem_objects,
|
|
mem_objects,
|
|
flags,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueNDRangeKernel(cl_command_queue command_queue ,
|
|
cl_kernel kernel ,
|
|
cl_uint work_dim ,
|
|
const size_t * global_work_offset ,
|
|
const size_t * global_work_size ,
|
|
const size_t * local_work_size ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueNDRangeKernel(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
kernel,
|
|
work_dim,
|
|
global_work_offset,
|
|
global_work_size,
|
|
local_work_size,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueTask(cl_command_queue command_queue ,
|
|
cl_kernel kernel ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueTask(%p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
kernel,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueNativeKernel(cl_command_queue command_queue ,
|
|
void (CL_CALLBACK *user_func)(void *),
|
|
void * args ,
|
|
size_t cb_args ,
|
|
cl_uint num_mem_objects ,
|
|
const cl_mem * mem_list ,
|
|
const void ** args_mem_loc ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueNativeKernel(%p, %p, %p, %u, %u, %p, %p, %u, %p, %p)\n",
|
|
command_queue,
|
|
user_func,
|
|
args,
|
|
cb_args,
|
|
num_mem_objects,
|
|
mem_list,
|
|
args_mem_loc,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY void * CL_API_CALL
|
|
clGetExtensionFunctionAddressForPlatform(cl_platform_id platform ,
|
|
const char * func_name) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
void *return_value = (void *) malloc(sizeof(void *));
|
|
test_icd_stub_log("clGetExtensionFunctionAddressForPlatform(%p, %p)\n",
|
|
platform,
|
|
func_name);
|
|
|
|
test_icd_stub_log("Value returned: %p\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueMarkerWithWaitList(cl_command_queue command_queue ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_2
|
|
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueMarkerWithWaitList(%p, %u, %p, %p)\n",
|
|
command_queue,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueBarrierWithWaitList(cl_command_queue command_queue ,
|
|
cl_uint num_events_in_wait_list ,
|
|
const cl_event * event_wait_list ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueBarrierWithWaitList(%p, %u, %p, %p)\n",
|
|
command_queue,
|
|
num_events_in_wait_list,
|
|
event_wait_list,
|
|
event);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetPrintfCallback(cl_context context ,
|
|
void (CL_CALLBACK * pfn_notify)(cl_context program ,
|
|
cl_uint printf_data_len ,
|
|
char * printf_data_ptr ,
|
|
void * user_data),
|
|
void * user_data) CL_API_SUFFIX__VERSION_1_2
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clSetPrintfCallback(%p, %p, %p)\n",
|
|
context,
|
|
pfn_notify,
|
|
user_data);
|
|
pfn_notify(context, 0, NULL, NULL);
|
|
test_icd_stub_log("setprintf_callback(%p, %u, %p, %p)\n",
|
|
context,
|
|
0,
|
|
NULL,
|
|
NULL);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueMarker(cl_command_queue command_queue ,
|
|
cl_event * event) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueMarker(%p, %p)\n", command_queue, event);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueWaitForEvents(cl_command_queue command_queue ,
|
|
cl_uint num_events ,
|
|
const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueWaitForEvents(%p, %u, %p)\n",
|
|
command_queue,
|
|
num_events,
|
|
event_list);
|
|
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueBarrier(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
|
|
{
|
|
cl_int return_value = CL_OUT_OF_RESOURCES;
|
|
test_icd_stub_log("clEnqueueBarrier(%p)\n", command_queue);
|
|
test_icd_stub_log("Value returned: %d\n", return_value);
|
|
return return_value;
|
|
}
|
|
|
|
extern cl_int cliIcdDispatchTableCreate(CLIicdDispatchTable **outDispatchTable);
|
|
|
|
CL_API_ENTRY cl_int CL_API_CALL
|
|
clIcdGetPlatformIDsKHR(cl_uint num_entries,
|
|
cl_platform_id * platforms,
|
|
cl_uint * num_platforms)
|
|
{
|
|
cl_int result = CL_SUCCESS;
|
|
if (!initialized) {
|
|
result = cliIcdDispatchTableCreate(&dispatchTable);
|
|
platform = (cl_platform_id) malloc(sizeof(struct _cl_platform_id));
|
|
memset(platform, 0, sizeof(struct _cl_platform_id));
|
|
|
|
platform->dispatch = dispatchTable;
|
|
platform->version = "OpenCL 1.2 Stub";
|
|
platform->vendor = "stubvendorxxx";
|
|
platform->profile = "stubprofilexxx";
|
|
platform->name = "ICD_LOADER_TEST_OPENCL_STUB";
|
|
platform->extensions = "cl_khr_icd cl_khr_gl cl_khr_d3d10";
|
|
platform->suffix = "ilts";
|
|
platform->dispatch = dispatchTable;
|
|
initialized = CL_TRUE;
|
|
}
|
|
|
|
if ((platforms && num_entries >1) ||
|
|
(platforms && num_entries <= 0) ||
|
|
(!platforms && num_entries >= 1)) {
|
|
result = CL_INVALID_VALUE;
|
|
goto Done;
|
|
}
|
|
|
|
if (platforms && num_entries == 1) {
|
|
platforms[0] = platform;
|
|
}
|
|
|
|
Done:
|
|
if (num_platforms) {
|
|
*num_platforms = 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|