diff --git a/projects/clr/opencl/CMakeLists.txt b/projects/clr/opencl/CMakeLists.txt index 113bb3ea8a..c424f38543 100644 --- a/projects/clr/opencl/CMakeLists.txt +++ b/projects/clr/opencl/CMakeLists.txt @@ -16,6 +16,7 @@ set(BUILD_SHARED_LIBS "Build shared libs" ON) add_subdirectory(khronos/icd) add_subdirectory(amdocl) add_subdirectory(tools/clinfo) +add_subdirectory(tools/cltrace) # get date information based on UTC # use the last two digits of year + week number + day in the week as OPENCL_VERSION_GITDATE @@ -47,6 +48,9 @@ get_target_property(OPENCL_LIB_VERSION_STRING OpenCL VERSION) install(PROGRAMS $ DESTINATION bin COMPONENT MAIN) +install(PROGRAMS $ + DESTINATION lib + COMPONENT MAIN) install(PROGRAMS $ DESTINATION lib COMPONENT MAIN) diff --git a/projects/clr/opencl/tools/cltrace/CMakeLists.txt b/projects/clr/opencl/tools/cltrace/CMakeLists.txt new file mode 100644 index 0000000000..da4e62e3c6 --- /dev/null +++ b/projects/clr/opencl/tools/cltrace/CMakeLists.txt @@ -0,0 +1,18 @@ +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + +if(CMAKE_BUILD_TYPE MATCHES "^Debug$") + add_definitions(-DDEBUG) +endif() + +set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-Bsymbolic -Wl,--unresolved-symbols=report-all -Wl,--version-script=${CMAKE_SOURCE_DIR}/tools/cltrace/cltrace.map") + +include_directories(${CMAKE_SOURCE_DIR}) +include_directories(${CMAKE_SOURCE_DIR}/khronos/headers/opencl2.2) +include_directories(${VDI_DIR}/include) + +add_definitions(-DHAVE_CL2_HPP -DCL_TARGET_OPENCL_VERSION=220) + +add_library(cltrace cltrace.cpp) + +target_link_libraries(cltrace OpenCL) diff --git a/projects/clr/opencl/tools/cltrace/cltrace.cpp b/projects/clr/opencl/tools/cltrace/cltrace.cpp new file mode 100644 index 0000000000..21b555a2b7 --- /dev/null +++ b/projects/clr/opencl/tools/cltrace/cltrace.cpp @@ -0,0 +1,4440 @@ +// +// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved. +// + +#include +#include + +#if defined(CL_VERSION_2_0) +/* Deprecated in OpenCL 2.0 */ +# define CL_DEVICE_QUEUE_PROPERTIES 0x102A +# define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035 +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#include +#include +#include +#else +#include +#include +#endif + +#define CASE(x) case x: return #x; + +std::ofstream clTraceLog; +std::streambuf *cerrStreamBufSave; + +// A call record with links for the checker +struct Rec { + Rec *next; + Rec *prev; + std::ostringstream *sp; + int visits; + + Rec() : sp(0) { } + Rec(std::ostringstream *ps) : sp(ps), visits(0) { } +}; + +// This is the head of the checker Rec list +static Rec recs; + +// About how many times per second the checker runs +static const int checks_per_second = 10; + +// Some OS independent synchronization for the checker Rec list +#ifdef _MSC_VER +#define CHECKERTYPE static void +#define CHECKERRETURN return +static CRITICAL_SECTION recsCS[1]; + +static inline void +initRecs(void) +{ + InitializeCriticalSection(recsCS); + recs.next = &recs; + recs.prev = &recs; +} + +static inline void +lockRecs(void) +{ + EnterCriticalSection(recsCS); +} + +static inline void +unlockRecs(void) +{ + LeaveCriticalSection(recsCS); +} + +static inline void +waitRecs(void) +{ + Sleep(1000/checks_per_second); +} +#else +#define CHECKERTYPE static void * +#define CHECKERRETURN return NULL +static pthread_mutex_t recsMtx = PTHREAD_MUTEX_INITIALIZER; + +static inline void +initRecs(void) +{ + recs.next = &recs; + recs.prev = &recs; +} + +static inline void +lockRecs(void) +{ + pthread_mutex_lock(&recsMtx); +} + +static inline void +unlockRecs(void) +{ + pthread_mutex_unlock(&recsMtx); +} + +static inline void +waitRecs(void) +{ + usleep(1000000/checks_per_second); +} +#endif + +// Link into checker Rec list +static inline void +addRec(Rec *r) +{ + lockRecs(); + r->next = recs.next; + r->prev = &recs; + recs.next->prev = r; + recs.next = r; + unlockRecs(); +} + +// unlink from checker Rec list +static inline void +delRec(Rec *r) +{ + lockRecs(); + r->next->prev = r->prev; + r->prev->next = r->next; + unlockRecs(); +} + +// This is the checker thread function +CHECKERTYPE +checker(void *) +{ + Rec *b; + Rec *e = &recs; + + for (;;) { + // Wait for a while + waitRecs(); + + std::ostringstream ss; + int go = 0; + + lockRecs(); + for (b=recs.next; b!=e; b=b->next) { + ++b->visits; + if (b->visits == 2) { + // This record has been on the list for a while + // we'll log it in case the thread has hung + ss << "Waiting for " << b->sp->str() << std::endl; + go = 1; + } + } + unlockRecs(); + + if (go) + std::cerr << ss.str(); + } + CHECKERRETURN; +} + +#ifdef _MSC_VER +static cl_int +startChecker(void) +{ + uintptr_t h = _beginthread(checker, 0, NULL); + return h == 0; +} +#else +static cl_int +startChecker(void) +{ + int e; + pthread_t tid; + pthread_attr_t pa; + + e = pthread_attr_init(&pa); + if (e) return e; + + e = pthread_attr_setdetachstate(&pa, PTHREAD_CREATE_DETACHED); + if (e) return e; + + e = pthread_create(&tid, &pa, checker, NULL); + return e; +} +#endif + +template +std::string +getDecimalString(T value) +{ + std::ostringstream ss; + ss << value; + return ss.str(); +} + +template +std::string +getDecimalString(T* value) +{ + if (value == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << '&' << *value; + return ss.str(); +} + +template +std::string +getHexString(T value) +{ + std::ostringstream ss; + ss << "0x" << std::hex << value; + return ss.str(); +} + +template +std::string +getHexString(T* value) +{ + if (value == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << "&0x" << std::hex << *value; + return ss.str(); +} + +template +std::string +getHexString(T** value) +{ + if (value == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << "&" << *value; + return ss.str(); +} + +template <> +std::string +getHexString(void *value) +{ + return getHexString(reinterpret_cast(value)); +} + +static std::string +getMemoryString(const void* ptr, size_t size) +{ + switch (size) { + case 1: return getHexString((const char*)ptr); + case 2: return getHexString((const short*)ptr); + case 4: return getHexString((const int*)ptr); + case 8: return getHexString((const long long*)ptr); + default: break; + } + std::ostringstream ss; + ss << "&" << ptr; + return ss.str(); +} + +static std::string +getBoolString(cl_bool b) +{ + return (b == CL_TRUE) ? "CL_TRUE" : "CL_FALSE"; +} + +static std::string +getNDimString(const size_t* nd, size_t dims) +{ + if (nd == NULL) { + return "NULL"; + } + if (dims == 0) { + return "[]"; + } + + std::ostringstream ss; + ss << '[' << nd[0]; + if (dims > 1) { + ss << ',' << nd[1]; + if (dims > 2) { + ss << ',' << nd[2]; + } + } + ss << ']'; + return ss.str(); +} + +static std::string +getErrorString(cl_int errcode) +{ + switch(errcode) { + CASE(CL_SUCCESS); + CASE(CL_DEVICE_NOT_FOUND); + CASE(CL_DEVICE_NOT_AVAILABLE); + CASE(CL_COMPILER_NOT_AVAILABLE); + CASE(CL_MEM_OBJECT_ALLOCATION_FAILURE); + CASE(CL_OUT_OF_RESOURCES); + CASE(CL_OUT_OF_HOST_MEMORY); + CASE(CL_PROFILING_INFO_NOT_AVAILABLE); + CASE(CL_MEM_COPY_OVERLAP); + CASE(CL_IMAGE_FORMAT_MISMATCH); + CASE(CL_IMAGE_FORMAT_NOT_SUPPORTED); + CASE(CL_BUILD_PROGRAM_FAILURE); + CASE(CL_MAP_FAILURE); + CASE(CL_MISALIGNED_SUB_BUFFER_OFFSET); + CASE(CL_INVALID_VALUE); + CASE(CL_INVALID_DEVICE_TYPE); + CASE(CL_INVALID_PLATFORM); + CASE(CL_INVALID_DEVICE); + CASE(CL_INVALID_CONTEXT); + CASE(CL_INVALID_QUEUE_PROPERTIES); + CASE(CL_INVALID_COMMAND_QUEUE); + CASE(CL_INVALID_HOST_PTR); + CASE(CL_INVALID_MEM_OBJECT); + CASE(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR); + CASE(CL_INVALID_IMAGE_SIZE); + CASE(CL_INVALID_SAMPLER); + CASE(CL_INVALID_BINARY); + CASE(CL_INVALID_BUILD_OPTIONS); + CASE(CL_INVALID_PROGRAM); + CASE(CL_INVALID_PROGRAM_EXECUTABLE); + CASE(CL_INVALID_KERNEL_NAME); + CASE(CL_INVALID_KERNEL_DEFINITION); + CASE(CL_INVALID_KERNEL); + CASE(CL_INVALID_ARG_INDEX); + CASE(CL_INVALID_ARG_VALUE); + CASE(CL_INVALID_ARG_SIZE); + CASE(CL_INVALID_KERNEL_ARGS); + CASE(CL_INVALID_WORK_DIMENSION); + CASE(CL_INVALID_WORK_GROUP_SIZE); + CASE(CL_INVALID_WORK_ITEM_SIZE); + CASE(CL_INVALID_GLOBAL_OFFSET); + CASE(CL_INVALID_EVENT_WAIT_LIST); + CASE(CL_INVALID_EVENT); + CASE(CL_INVALID_OPERATION); + CASE(CL_INVALID_GL_OBJECT); + CASE(CL_INVALID_BUFFER_SIZE); + CASE(CL_INVALID_MIP_LEVEL); + CASE(CL_INVALID_GLOBAL_WORK_SIZE); + default: return getDecimalString(errcode); + } +} + +static std::string +getMemObjectTypeString(cl_mem_object_type type) +{ + switch(type) { + CASE(CL_MEM_OBJECT_BUFFER); + CASE(CL_MEM_OBJECT_IMAGE2D); + CASE(CL_MEM_OBJECT_IMAGE3D); + default: return getHexString(type); + } +} + +static std::string +getMemInfoString(cl_mem_info param_name) +{ + switch(param_name) { + CASE(CL_MEM_TYPE); + CASE(CL_MEM_FLAGS); + CASE(CL_MEM_SIZE); + CASE(CL_MEM_HOST_PTR); + CASE(CL_MEM_MAP_COUNT); + CASE(CL_MEM_REFERENCE_COUNT); + CASE(CL_MEM_CONTEXT); + CASE(CL_MEM_ASSOCIATED_MEMOBJECT); + CASE(CL_MEM_OFFSET); + default: return getHexString(param_name); + } +} + +static std::string +getImageInfoString(cl_image_info param_name) +{ + switch(param_name) { + CASE(CL_IMAGE_FORMAT); + CASE(CL_IMAGE_ELEMENT_SIZE); + CASE(CL_IMAGE_ROW_PITCH); + CASE(CL_IMAGE_SLICE_PITCH); + CASE(CL_IMAGE_WIDTH); + CASE(CL_IMAGE_HEIGHT); + CASE(CL_IMAGE_DEPTH); + default: return getHexString(param_name); + } +} + +static std::string +getErrorString(cl_int* errcode_ret) +{ + if (errcode_ret == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << '&' << getErrorString(*errcode_ret); + return ss.str(); +} + +static std::string +getHandlesString(const void* handles, cl_uint num_handles) +{ + if (handles == NULL) { + return "NULL"; + } + if (num_handles == 0) { + return "[]"; + } + + const cl_event* p = reinterpret_cast(handles); + + std::ostringstream ss; + ss << '['; + while (true) { + ss << *p++; + if (--num_handles == 0) { + break; + } + ss << ','; + } + ss << ']'; + return ss.str(); +} + +static std::string +getContextPropertyString(cl_context_properties cprop) +{ + switch(cprop) { + CASE(CL_CONTEXT_PLATFORM); + default: return getHexString(cprop); + } +} + +static std::string +getContextPropertiesString(const cl_context_properties* cprops) +{ + if (cprops == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << '{'; + while (*cprops != 0) { + ss << getContextPropertyString(cprops[0]) + << ',' << getHexString(cprops[1]) << ","; + cprops += 2; + } + ss << "NULL}"; + return ss.str(); +} + +static std::string +getCommandQueuePropertyString(cl_command_queue_properties property) +{ + if (property == 0) { + return "0"; + } + + std::ostringstream ss; + while (property) { + if (property & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) { + ss << "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE"; + property &= ~CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE; + } + else if (property & CL_QUEUE_PROFILING_ENABLE) { + ss << "CL_QUEUE_PROFILING_ENABLE"; + property &= ~CL_QUEUE_PROFILING_ENABLE; + } + else { + ss << "0x" << std::hex << (int)property; + property = 0; + } + if (property != 0) { + ss << '|'; + } + } + + return ss.str(); +} + +static std::string +getQueuePropertyString(const cl_queue_properties* qprops) +{ + if (qprops == NULL) { + return "NULL"; + } + + std::ostringstream ss; + cl_command_queue_properties property = 0; + unsigned int queueSize = 0; + + const struct QueueProperty { + cl_queue_properties name; + union { + cl_queue_properties raw; + cl_uint size; + } value; + } *p = reinterpret_cast(qprops); + + if (p != NULL) while(p->name != 0) { + switch(p->name) { + case CL_QUEUE_PROPERTIES: + property = static_cast(p->value.raw); + + if (property & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) { + ss << "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE"; + property &= ~CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE; + } + else if (property & CL_QUEUE_PROFILING_ENABLE) { + ss << "CL_QUEUE_PROFILING_ENABLE"; + property &= ~CL_QUEUE_PROFILING_ENABLE; + } + else { + ss << "0x" << std::hex << (int)property; + property = 0; + } + if (property != 0) { + ss << '|'; + } + break; + case CL_QUEUE_SIZE: // Unimplemented + queueSize = p->value.size; + ss << "QUEUE_SIZE "<origin << ',' << region->size << '}'; + } + else { + ss << getHexString(type) << ',' << info; + } + return ss.str(); +} + +static std::string +getChannelOrderString(cl_channel_order order) +{ + switch(order) { + CASE(CL_R); + CASE(CL_A); + CASE(CL_RG); + CASE(CL_RA); + CASE(CL_RGB); + CASE(CL_RGBA); + CASE(CL_BGRA); + CASE(CL_ARGB); + CASE(CL_INTENSITY); + CASE(CL_LUMINANCE); + CASE(CL_Rx); + CASE(CL_RGx); + CASE(CL_RGBx); + default: return getHexString(order); + } +} + +static std::string +getChannelTypeString(cl_channel_type type) +{ + switch(type) { + CASE(CL_SNORM_INT8); + CASE(CL_SNORM_INT16); + CASE(CL_UNORM_INT8); + CASE(CL_UNORM_INT16); + CASE(CL_UNORM_SHORT_565); + CASE(CL_UNORM_SHORT_555); + CASE(CL_UNORM_INT_101010); + CASE(CL_SIGNED_INT8); + CASE(CL_SIGNED_INT16); + CASE(CL_SIGNED_INT32); + CASE(CL_UNSIGNED_INT8); + CASE(CL_UNSIGNED_INT16); + CASE(CL_UNSIGNED_INT32); + CASE(CL_HALF_FLOAT); + CASE(CL_FLOAT); + default: return getHexString(type); + } +} + +static std::string +getImageFormatsString(const cl_image_format* format, size_t num_entries) +{ + if (format == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << '['; + while (true) { + ss << '{' << getChannelOrderString(format->image_channel_order) << ','; + ss << getChannelTypeString(format->image_channel_data_type) << '}'; + if (--num_entries == 0) { + break; + } + ss << ','; + } + ss << ']'; + return ss.str(); +} + +static std::string +getImageDescString(const cl_image_desc* image_desc) +{ + if (image_desc == NULL) { + return "NULL"; + } + + std::ostringstream ss; + ss << '{' << getMemObjectTypeString(image_desc->image_type) << ','; + ss << image_desc->image_width << ','; + ss << image_desc->image_height << ','; + ss << image_desc->image_depth << ','; + ss << image_desc->image_array_size << ','; + ss << image_desc->image_row_pitch << ','; + ss << image_desc->image_slice_pitch << ','; + ss << image_desc->num_mip_levels << ','; + ss << image_desc->num_samples << ','; + ss << image_desc->mem_object << '}'; + return ss.str(); +} + + +static std::string +getAddressingModeString(cl_addressing_mode mode) +{ + switch(mode) { + CASE(CL_ADDRESS_NONE); + CASE(CL_ADDRESS_CLAMP_TO_EDGE); + CASE(CL_ADDRESS_CLAMP); + CASE(CL_ADDRESS_REPEAT); + CASE(CL_ADDRESS_MIRRORED_REPEAT); + default: return getHexString(mode); + } +} + +std::string +getFilterModeString(cl_filter_mode mode) +{ + switch(mode) { + CASE(CL_FILTER_NEAREST); + CASE(CL_FILTER_LINEAR); + default: return getHexString(mode); + } +} + +static std::string +getSamplerInfoString(cl_sampler_info param_name) +{ + switch(param_name) { + CASE(CL_SAMPLER_REFERENCE_COUNT); + CASE(CL_SAMPLER_CONTEXT); + CASE(CL_SAMPLER_NORMALIZED_COORDS); + CASE(CL_SAMPLER_ADDRESSING_MODE); + CASE(CL_SAMPLER_FILTER_MODE); + default: return getHexString(param_name); + } +} + + +std::string +getDeviceTypeString(cl_device_type type) +{ + if (type == CL_DEVICE_TYPE_ALL) { + return "CL_DEVICE_TYPE_ALL"; + } + + std::ostringstream ss; + while (type) { + if (type & CL_DEVICE_TYPE_CPU) { + ss << "CL_DEVICE_TYPE_CPU"; + type &= ~CL_DEVICE_TYPE_CPU; + } + else if (type & CL_DEVICE_TYPE_GPU) { + ss << "CL_DEVICE_TYPE_GPU"; + type &= ~CL_DEVICE_TYPE_GPU; + } + else if (type & CL_DEVICE_TYPE_ACCELERATOR) { + ss << "CL_DEVICE_TYPE_ACCELERATOR"; + type &= ~CL_DEVICE_TYPE_ACCELERATOR; + } + else { + ss << "0x" << std::hex << (int)type; + type = 0; + } + if (type != 0) { + ss << '|'; + } + } + + return ss.str(); +} + +static std::string +getPlatformInfoString(cl_platform_info param_name) +{ + switch (param_name) { + CASE(CL_PLATFORM_PROFILE); + CASE(CL_PLATFORM_VERSION); + CASE(CL_PLATFORM_NAME); + CASE(CL_PLATFORM_VENDOR); + CASE(CL_PLATFORM_EXTENSIONS); + CASE(CL_PLATFORM_ICD_SUFFIX_KHR); + default: return getHexString(param_name); + } +} + + +static std::string +getKernelArgInfoString(cl_kernel_arg_info param_name) +{ + switch (param_name) { + CASE(CL_KERNEL_ARG_ADDRESS_QUALIFIER); + CASE(CL_KERNEL_ARG_ACCESS_QUALIFIER); + CASE(CL_KERNEL_ARG_TYPE_NAME); + CASE(CL_KERNEL_ARG_TYPE_QUALIFIER); + CASE(CL_KERNEL_ARG_NAME); + default: return getHexString(param_name); + } +} + +static std::string +getDeviceInfoString(cl_device_info param_name) +{ + switch (param_name) { + CASE(CL_DEVICE_TYPE); + CASE(CL_DEVICE_VENDOR_ID); + CASE(CL_DEVICE_MAX_COMPUTE_UNITS); + CASE(CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS); + CASE(CL_DEVICE_MAX_WORK_GROUP_SIZE); + CASE(CL_DEVICE_MAX_WORK_ITEM_SIZES); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE); + CASE(CL_DEVICE_MAX_CLOCK_FREQUENCY); + CASE(CL_DEVICE_ADDRESS_BITS); + CASE(CL_DEVICE_MAX_READ_IMAGE_ARGS); + CASE(CL_DEVICE_MAX_WRITE_IMAGE_ARGS); + CASE(CL_DEVICE_MAX_MEM_ALLOC_SIZE); + CASE(CL_DEVICE_IMAGE2D_MAX_WIDTH); + CASE(CL_DEVICE_IMAGE2D_MAX_HEIGHT); + CASE(CL_DEVICE_IMAGE3D_MAX_WIDTH); + CASE(CL_DEVICE_IMAGE3D_MAX_HEIGHT); + CASE(CL_DEVICE_IMAGE3D_MAX_DEPTH); + CASE(CL_DEVICE_IMAGE_SUPPORT); + CASE(CL_DEVICE_MAX_PARAMETER_SIZE); + CASE(CL_DEVICE_MAX_SAMPLERS); + CASE(CL_DEVICE_MEM_BASE_ADDR_ALIGN); + CASE(CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE); + CASE(CL_DEVICE_SINGLE_FP_CONFIG); + CASE(CL_DEVICE_GLOBAL_MEM_CACHE_TYPE); + CASE(CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE); + CASE(CL_DEVICE_GLOBAL_MEM_CACHE_SIZE); + CASE(CL_DEVICE_GLOBAL_MEM_SIZE); + CASE(CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE); + CASE(CL_DEVICE_MAX_CONSTANT_ARGS); + CASE(CL_DEVICE_LOCAL_MEM_TYPE); + CASE(CL_DEVICE_LOCAL_MEM_SIZE); + CASE(CL_DEVICE_ERROR_CORRECTION_SUPPORT); + CASE(CL_DEVICE_PROFILING_TIMER_RESOLUTION); + CASE(CL_DEVICE_ENDIAN_LITTLE); + CASE(CL_DEVICE_AVAILABLE); + CASE(CL_DEVICE_COMPILER_AVAILABLE); + CASE(CL_DEVICE_EXECUTION_CAPABILITIES); + CASE(CL_DEVICE_QUEUE_PROPERTIES); + CASE(CL_DEVICE_NAME); + CASE(CL_DEVICE_VENDOR); + CASE(CL_DRIVER_VERSION); + CASE(CL_DEVICE_PROFILE); + CASE(CL_DEVICE_VERSION); + CASE(CL_DEVICE_EXTENSIONS); + CASE(CL_DEVICE_PLATFORM); + CASE(CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF); + CASE(CL_DEVICE_HOST_UNIFIED_MEMORY); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_INT); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE); + CASE(CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF); + CASE(CL_DEVICE_OPENCL_C_VERSION); + default: return getHexString(param_name); + } +} + +static std::string +getContextInfoString(cl_context_info param_name) +{ + switch (param_name) { + CASE(CL_CONTEXT_REFERENCE_COUNT); + CASE(CL_CONTEXT_DEVICES); + CASE(CL_CONTEXT_PROPERTIES); + CASE(CL_CONTEXT_NUM_DEVICES); + default: return getHexString(param_name); + } +} + +static std::string +getCommandQueueInfoString(cl_command_queue_info param_name) +{ + switch (param_name) { + CASE(CL_QUEUE_CONTEXT); + CASE(CL_QUEUE_DEVICE); + CASE(CL_QUEUE_REFERENCE_COUNT); + CASE(CL_QUEUE_PROPERTIES); + default: return getHexString(param_name); + } +} + +static std::string +getProgramInfoString(cl_program_info param_name) +{ + switch (param_name) { + CASE(CL_PROGRAM_REFERENCE_COUNT); + CASE(CL_PROGRAM_CONTEXT); + CASE(CL_PROGRAM_NUM_DEVICES); + CASE(CL_PROGRAM_DEVICES); + CASE(CL_PROGRAM_SOURCE); + CASE(CL_PROGRAM_BINARY_SIZES); + CASE(CL_PROGRAM_BINARIES); + default: return getHexString(param_name); + } +} + +static std::string +getKernelInfoString(cl_kernel_info param_name) +{ + switch (param_name) { + CASE(CL_KERNEL_FUNCTION_NAME); + CASE(CL_KERNEL_NUM_ARGS); + CASE(CL_KERNEL_REFERENCE_COUNT); + CASE(CL_KERNEL_CONTEXT); + CASE(CL_KERNEL_PROGRAM); + default: return getHexString(param_name); + } +} + +static std::string +getKernelExecInfoString(cl_kernel_exec_info param_name) +{ + switch (param_name) { + CASE(CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM); + CASE(CL_KERNEL_EXEC_INFO_SVM_PTRS); + CASE(CL_KERNEL_EXEC_INFO_NEW_VCOP_AMD); + CASE(CL_KERNEL_EXEC_INFO_PFPA_VCOP_AMD); + default: return getHexString(param_name); + } +} + + +static std::string +getKernelWorkGroupInfoString(cl_kernel_work_group_info param_name) +{ + switch (param_name) { + CASE(CL_KERNEL_WORK_GROUP_SIZE); + CASE(CL_KERNEL_COMPILE_WORK_GROUP_SIZE); + CASE(CL_KERNEL_LOCAL_MEM_SIZE); + CASE(CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE); + CASE(CL_KERNEL_PRIVATE_MEM_SIZE); + default: return getHexString(param_name); + } +} + +static std::string +getProgramBuildInfoString(cl_program_build_info param_name) +{ + switch (param_name) { + CASE(CL_PROGRAM_BUILD_STATUS); + CASE(CL_PROGRAM_BUILD_OPTIONS); + CASE(CL_PROGRAM_BUILD_LOG); + default: return getHexString(param_name); + } +} + +static std::string +getEventInfoString(cl_event_info param_name) +{ + switch (param_name) { + CASE(CL_EVENT_COMMAND_QUEUE); + CASE(CL_EVENT_COMMAND_TYPE); + CASE(CL_EVENT_REFERENCE_COUNT); + CASE(CL_EVENT_COMMAND_EXECUTION_STATUS); + CASE(CL_EVENT_CONTEXT); + default: return getHexString(param_name); + } +} + +static std::string +getProfilingInfoString(cl_profiling_info param_name) +{ + switch (param_name) { + CASE(CL_PROFILING_COMMAND_QUEUED); + CASE(CL_PROFILING_COMMAND_SUBMIT); + CASE(CL_PROFILING_COMMAND_START); + CASE(CL_PROFILING_COMMAND_END); + default: return getHexString(param_name); + } +} + +static std::string +getCommandExecutionStatusString(cl_int param_name) +{ + switch (param_name) { + CASE(CL_COMPLETE); + CASE(CL_RUNNING); + CASE(CL_SUBMITTED); + CASE(CL_QUEUED); + default: return getHexString(param_name); + } +} + +static std::string +getStringString(const char* src) +{ + if (src == NULL) { + return "NULL"; + } + + std::string str(src); + + if (str.length() > 60) { + str = str.substr(0, 60).append("..."); + } + + size_t found = 0; + while (true) { + found = str.find_first_of("\n\r\t\"", found); + if (found == std::string::npos) { + break; + } + char subst[] = { '\\', '\0', '\0' }; + switch (str[found]) { + case '\n': subst[1] = 'n'; break; + case '\r': subst[1] = 'r'; break; + case '\t': subst[1] = 't'; break; + case '\"': subst[1] = '\"'; break; + default: ++found; continue; + } + str.replace(found, 1, subst); + found += 2; + } + + str.insert(size_t(0), size_t(1), '\"').append(1, '\"'); + return str; +} + +static std::string +getProgramSourceString( + const char** strings, const size_t* lengths, cl_uint count) +{ + if (strings == NULL) { + return "NULL"; + } + if (count == 0) { + return "[]"; + } + std::ostringstream ss; + ss << '['; + + for (cl_uint i = 0; i < count; ++i) { + std::string src; + if (lengths != NULL && lengths[i] != 0) { + src = std::string(strings[i], lengths[i]); + } + else { + src = strings[i]; + } + if (i != 0) { + ss << ','; + } + ss << getStringString(src.c_str()); + } + + ss << ']'; + return ss.str(); +} + +static cl_icd_dispatch_table original_dispatch; + +static cl_int CL_API_CALL +GetPlatformIDs( + cl_uint num_entries, + cl_platform_id * platforms, + cl_uint * num_platforms) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetPlatformIDs(" << num_entries << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetPlatformIDs( + num_entries, platforms, num_platforms); + delRec(&r); + + ss << getHandlesString(platforms, num_entries) << ','; + ss << getHexString(num_platforms) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetPlatformInfo( + cl_platform_id platform, + cl_platform_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetPlatformInfo(" << platform << ','; + ss << getPlatformInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetPlatformInfo( + platform, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetDeviceIDs( + cl_platform_id platform, + cl_device_type device_type, + cl_uint num_entries, + cl_device_id * devices, + cl_uint * num_devices) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetDeviceIDs(" << platform << ','; + ss << getDeviceTypeString(device_type) << ','; + ss << num_entries << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetDeviceIDs( + platform, device_type, num_entries, devices, num_devices); + delRec(&r); + + ss << getHandlesString(devices, num_entries) << ','; + ss << getDecimalString(num_devices) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetDeviceInfo( + cl_device_id device, + cl_device_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetDeviceInfo(" << device << ','; + ss << getDeviceInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetDeviceInfo( + device, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_context CL_API_CALL +CreateContext( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateContext("; + ss << getContextPropertiesString(properties) << ','; + ss << num_devices << ','; + ss << getHandlesString(devices, num_devices) << ','; + ss << pfn_notify << ',' << user_data << ','; + + addRec(&r); + cl_context ret = original_dispatch.CreateContext( + properties, num_devices, devices, pfn_notify, user_data, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_context CL_API_CALL +CreateContextFromType( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateContextFromType("; + ss << getContextPropertiesString(properties) << ','; + ss << getDeviceTypeString(device_type) << ','; + ss << pfn_notify << ',' << user_data << ','; + + addRec(&r); + cl_context ret = original_dispatch.CreateContextFromType( + properties, device_type, pfn_notify, user_data, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainContext(cl_context context) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainContext(" << context; + + addRec(&r); + cl_int ret = original_dispatch.RetainContext(context); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseContext(cl_context context) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseContext(" << context; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseContext(context); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetContextInfo( + cl_context context, + cl_context_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetContextInfo(" << context << ','; + ss << getContextInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetContextInfo( + context, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_command_queue CL_API_CALL +CreateCommandQueue( + cl_context context, + cl_device_id device, + cl_command_queue_properties properties, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateCommandQueue(" << context << ',' << device << ','; + ss << getCommandQueuePropertyString(properties) << ','; + + addRec(&r); + cl_command_queue ret = original_dispatch.CreateCommandQueue( + context, device, properties, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_command_queue CL_API_CALL +CreateCommandQueueWithProperties( + cl_context context, + cl_device_id device, + const cl_queue_properties * properties, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateCommandQueueWithProperties(" << context << ',' << device << ','; + ss << getQueuePropertyString(properties) << ','; + + addRec(&r); + cl_command_queue ret = original_dispatch.CreateCommandQueueWithProperties( + context, device, properties, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainCommandQueue(cl_command_queue command_queue) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainCommandQueue(" << command_queue; + + addRec(&r); + cl_int ret = original_dispatch.RetainCommandQueue(command_queue); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseCommandQueue(cl_command_queue command_queue) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseCommandQueue(" << command_queue; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseCommandQueue(command_queue); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetCommandQueueInfo( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetCommandQueueInfo(" << command_queue << ','; + ss << getCommandQueueInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetCommandQueueInfo( + command_queue, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetCommandQueueProperty( + cl_command_queue command_queue, + cl_command_queue_properties properties, + cl_bool enable, + cl_command_queue_properties * old_properties) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetCommandQueueProperty(" << command_queue << ','; + ss << getCommandQueuePropertyString(properties) << ','; + ss << enable << ','; + + addRec(&r); + cl_int ret = original_dispatch.SetCommandQueueProperty( + command_queue, properties, enable, old_properties); + delRec(&r); + + ss << getHexString(old_properties) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; + +} + +static cl_mem CL_API_CALL +CreateBuffer( + cl_context context, + cl_mem_flags flags, + size_t size, + void * host_ptr, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateBuffer(" << context << ','; + ss << getMemFlagsString(flags) << ',' << size << ',' << host_ptr << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateBuffer( + context, flags, size, host_ptr, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateSubBuffer( + cl_mem buffer, + cl_mem_flags flags, + cl_buffer_create_type buffer_create_type, + const void * buffer_create_info, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateSubBuffer(" << buffer << ','; + ss << getMemFlagsString(flags) << ','; + ss << getBufferCreateString(buffer_create_type, buffer_create_info) << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateSubBuffer( + buffer, flags, buffer_create_type, buffer_create_info, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateImage2D( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateImage2D(" << context << ','; + ss << getMemFlagsString(flags) << ','; + ss << getImageFormatsString(image_format, 1) << ','; + ss << image_width << ',' << image_height << ',' << image_row_pitch << ','; + ss << host_ptr << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateImage2D( + context, flags, image_format, image_width, image_height, + image_row_pitch, host_ptr, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + + +static cl_mem CL_API_CALL +CreateImage3D( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateImage3D(" << context << ','; + ss << getMemFlagsString(flags) << ','; + ss << getImageFormatsString(image_format, 1) << ','; + ss << image_width << ',' << image_height << ',' << image_depth << ','; + ss << image_row_pitch << ',' << image_slice_pitch << ','; + ss << host_ptr << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateImage3D( + context, flags, image_format, image_width, image_height, image_depth, + image_row_pitch, image_slice_pitch, host_ptr, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + + +static cl_int CL_API_CALL +RetainMemObject(cl_mem memobj) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainMemObject(" << memobj; + + addRec(&r); + cl_int ret = original_dispatch.RetainMemObject(memobj); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + + +static cl_int CL_API_CALL +ReleaseMemObject(cl_mem memobj) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseMemObject(" << memobj; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseMemObject(memobj); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetSupportedImageFormats( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetSupportedImageFormats(" << context << ','; + ss << getMemFlagsString(flags) << ','; + ss << getMemObjectTypeString(image_type) << ','; + ss << num_entries << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetSupportedImageFormats( + context, flags, image_type, num_entries, image_formats, + num_image_formats); + delRec(&r); + + ss << getImageFormatsString(image_formats, num_entries) << ','; + ss << getDecimalString(num_image_formats); + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetMemObjectInfo( + cl_mem memobj, + cl_mem_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetMemObjectInfo(" << memobj << ','; + ss << getMemInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetMemObjectInfo( + memobj, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetImageInfo( + cl_mem image, + cl_image_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetImageInfo(" << image << ','; + ss << getImageInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetImageInfo( + image, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetMemObjectDestructorCallback( + cl_mem memobj, + void (CL_CALLBACK * pfn_notify)( cl_mem memobj, void* user_data), + void * user_data) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetMemObjectDestructorCallback(" << memobj << ','; + ss << pfn_notify << ',' << user_data; + + addRec(&r); + cl_int ret = original_dispatch.SetMemObjectDestructorCallback( + memobj, pfn_notify, user_data); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_sampler CL_API_CALL +CreateSampler( + cl_context context, + cl_bool normalized_coords, + cl_addressing_mode addressing_mode, + cl_filter_mode filter_mode, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateSampler(" << context << ','; + ss << normalized_coords << ','; + ss << getAddressingModeString(addressing_mode) << ','; + ss << getFilterModeString(filter_mode) << ','; + + addRec(&r); + cl_sampler ret = original_dispatch.CreateSampler( + context, normalized_coords, addressing_mode, filter_mode, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainSampler(cl_sampler sampler) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainSampler(" << sampler; + + addRec(&r); + cl_int ret = original_dispatch.RetainSampler(sampler); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseSampler(cl_sampler sampler) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseSampler(" << sampler; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseSampler(sampler); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetSamplerInfo( + cl_sampler sampler, + cl_sampler_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetSamplerInfo(" << sampler << ','; + ss << getSamplerInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetSamplerInfo( + sampler, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_program CL_API_CALL +CreateProgramWithSource( + cl_context context, + cl_uint count, + const char ** strings, + const size_t * lengths, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateProgramWithSource(" << context << ',' << count << ','; + ss << getProgramSourceString(strings, lengths, count) << ','; + ss << lengths << ','; + + addRec(&r); + cl_program ret = original_dispatch.CreateProgramWithSource( + context, count, strings, lengths, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_program CL_API_CALL +CreateProgramWithBinary( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateProgramWithBinary(" << context << ','; + ss << num_devices << ',' << getHandlesString(device_list, num_devices); + ss << ',' << lengths << ',' << binaries << ','; + ss << binary_status << ','; + + addRec(&r); + cl_program ret = original_dispatch.CreateProgramWithBinary( + context, num_devices, device_list, lengths, + binaries, binary_status, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainProgram(cl_program program) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainProgram(" << program; + + addRec(&r); + cl_int ret = original_dispatch.RetainProgram(program); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseProgram(cl_program program) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseProgram(" << program; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseProgram(program); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +BuildProgram( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clBuildProgram(" << program << ','; + ss << num_devices << ',' << getHandlesString(device_list, num_devices); + ss << ',' << getStringString(options) << ','; + ss << pfn_notify << ',' << user_data; + + addRec(&r); + cl_int ret = original_dispatch.BuildProgram( + program, num_devices, device_list, options, pfn_notify, user_data); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +UnloadCompiler(void) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clUnloadCompiler("; + + addRec(&r); + cl_int ret = original_dispatch.UnloadCompiler(); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetProgramInfo( + cl_program program, + cl_program_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetProgramInfo(" << program << ','; + ss << getProgramInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetProgramInfo( + program, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetProgramBuildInfo( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetProgramBuildInfo(" << program << ',' << device << ','; + ss << getProgramBuildInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetProgramBuildInfo( + program, device, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_kernel CL_API_CALL +CreateKernel( + cl_program program, + const char * kernel_name, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateKernel(" << program << ','; + ss << getStringString(kernel_name) << ','; + + addRec(&r); + cl_kernel ret = original_dispatch.CreateKernel( + program, kernel_name, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +CreateKernelsInProgram( + cl_program program, + cl_uint num_kernels, + cl_kernel * kernels, + cl_uint * num_kernels_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateKernelInProgram(" << program << ','; + ss << num_kernels << ',' << kernels << ','; + + addRec(&r); + cl_int ret = original_dispatch.CreateKernelsInProgram( + program, num_kernels, kernels, num_kernels_ret); + delRec(&r); + + ss << getDecimalString(num_kernels_ret) << ','; + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainKernel(cl_kernel kernel) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainKernel(" << kernel; + + addRec(&r); + cl_int ret = original_dispatch.RetainKernel(kernel); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseKernel(cl_kernel kernel) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseKernel(" << kernel; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseKernel(kernel); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetKernelArg( + cl_kernel kernel, + cl_uint arg_index, + size_t arg_size, + const void * arg_value) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetKernelArg(" << kernel << ','; + ss << arg_index << ',' << arg_size << ','; + ss << getMemoryString(arg_value, arg_size); + + addRec(&r); + cl_int ret = original_dispatch.SetKernelArg( + kernel, arg_index, arg_size, arg_value); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetKernelInfo( + cl_kernel kernel, + cl_kernel_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetKernelInfo(" << kernel << ','; + ss << getKernelInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetKernelInfo( + kernel, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetKernelWorkGroupInfo( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetKernelWorkGroupInfo(" << kernel << ',' << device << ','; + ss << getKernelWorkGroupInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetKernelWorkGroupInfo( + kernel, device, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +WaitForEvents( + cl_uint num_events, + const cl_event * event_list) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clWaitForEvents(" << num_events << ','; + ss << getHandlesString(event_list, num_events); + + addRec(&r); + cl_int ret = original_dispatch.WaitForEvents( + num_events, event_list); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetEventInfo( + cl_event event, + cl_event_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetEventInfo(" << event << ','; + ss << getEventInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetEventInfo( + event, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_event CL_API_CALL +CreateUserEvent( + cl_context context, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateUserEvent(" << context << ','; + + addRec(&r); + cl_event ret = original_dispatch.CreateUserEvent( + context, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainEvent(cl_event event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainEvent(" << event; + + addRec(&r); + cl_int ret = original_dispatch.RetainEvent(event); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseEvent(cl_event event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clReleaseEvent(" << event; + + addRec(&r); + cl_int ret = original_dispatch.ReleaseEvent(event); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetUserEventStatus( + cl_event event, + cl_int execution_status) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetUserEventStatus(" << event << ',' << execution_status; + + addRec(&r); + cl_int ret = original_dispatch.SetUserEventStatus( + event, execution_status); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetEventCallback( + cl_event event, + cl_int command_exec_callback_type, + void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *), + void * user_data) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetEventCallback(" << event << ','; + ss << getCommandExecutionStatusString(command_exec_callback_type) << ','; + ss << pfn_notify << ',' << user_data; + + addRec(&r); + cl_int ret = original_dispatch.SetEventCallback( + event, command_exec_callback_type, pfn_notify, user_data); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetEventProfilingInfo( + cl_event event, + cl_profiling_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetEventProfilingInfo(" << event << ','; + ss << getProfilingInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetEventProfilingInfo( + event, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +Flush(cl_command_queue command_queue) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clFlush(" << command_queue; + + addRec(&r); + cl_int ret = original_dispatch.Flush(command_queue); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +Finish(cl_command_queue command_queue) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clFinish(" << command_queue; + + addRec(&r); + cl_int ret = original_dispatch.Finish(command_queue); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueReadBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueReadBuffer(" << command_queue << ','; + ss << buffer << ',' << getBoolString(blocking_read) << ','; + ss << offset << ',' << cb << ',' << ptr << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueReadBuffer( + command_queue, buffer, blocking_read, offset, cb, ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueReadBufferRect( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_read, + const size_t * buffer_offset, + const size_t * host_offset, + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueReadBufferRect(" << command_queue << ','; + ss << buffer << ',' << getBoolString(blocking_read) << ','; + ss << getNDimString(buffer_offset, 3) << ','; + ss << getNDimString(host_offset, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << buffer_row_pitch << ',' << buffer_slice_pitch << ','; + ss << host_row_pitch << ',' << host_slice_pitch << ','; + ss << ptr << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueReadBufferRect( + command_queue, buffer, blocking_read, + buffer_offset, host_offset, region, + buffer_row_pitch, buffer_slice_pitch, + host_row_pitch, host_slice_pitch, + ptr, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueWriteBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueWriteBuffer(" << command_queue << ','; + ss << buffer << ',' << getBoolString(blocking_write) << ','; + ss << offset << ',' << cb << ',' << ptr << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueWriteBuffer( + command_queue, buffer, blocking_write, offset, cb, ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueWriteBufferRect( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_write, + const size_t * buffer_offset, + const size_t * host_offset, + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueWriteBufferRect(" << command_queue << ','; + ss << buffer << ',' << getBoolString(blocking_write) << ','; + ss << getNDimString(buffer_offset, 3) << ','; + ss << getNDimString(host_offset, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << buffer_row_pitch << ',' << buffer_slice_pitch << ','; + ss << host_row_pitch << ',' << host_slice_pitch << ','; + ss << ptr << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueWriteBufferRect( + command_queue, buffer, blocking_write, + buffer_offset, host_offset, region, + buffer_row_pitch, buffer_slice_pitch, + host_row_pitch, host_slice_pitch, + ptr, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueCopyBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueCopyBuffer(" << command_queue << ','; + ss << src_buffer << ',' << dst_buffer << ','; + ss << src_offset << ',' << dst_offset << ',' << cb << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueCopyBuffer( + command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueCopyBufferRect( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueCopyBufferRect(" << command_queue << ','; + ss << src_buffer << ',' << dst_buffer << ','; + ss << getNDimString(src_origin, 3) << ','; + ss << getNDimString(dst_origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << src_row_pitch << ',' << src_slice_pitch << ','; + ss << dst_row_pitch << ',' << dst_slice_pitch << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueCopyBufferRect( + 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); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueReadImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueReadImage(" << command_queue << ','; + ss << image << ',' << getBoolString(blocking_read) << ','; + ss << getNDimString(origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << row_pitch << ',' << slice_pitch << ','; + ss << ptr << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueReadImage( + command_queue, image, blocking_read, origin, region, + row_pitch, slice_pitch, ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueWriteImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueWriteImage(" << command_queue << ','; + ss << image << ',' << getBoolString(blocking_write) << ','; + ss << getNDimString(origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << input_row_pitch << ',' << input_slice_pitch << ','; + ss << ptr << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueWriteImage( + command_queue, image, blocking_write, origin, region, + input_row_pitch, input_slice_pitch, ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueCopyImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueCopyImage(" << command_queue << ','; + ss << src_image << ',' << dst_image << ','; + ss << getNDimString(src_origin, 3) << ','; + ss << getNDimString(dst_origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueCopyImage( + command_queue, src_image, dst_image, src_origin, dst_origin, region, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueCopyImageToBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueCopyImageToBuffer(" << command_queue << ','; + ss << src_image << ',' << dst_buffer << ','; + ss << getNDimString(src_origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << dst_offset << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueCopyImageToBuffer( + command_queue, src_image, dst_buffer, src_origin, region, + dst_offset, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueCopyBufferToImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueCopyBufferToImage(" << command_queue << ','; + ss << src_buffer << ',' << dst_image << ',' << src_offset << ','; + ss << getNDimString(dst_origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueCopyBufferToImage( + command_queue, src_buffer, dst_image, src_offset, dst_origin, region, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static void * CL_API_CALL +EnqueueMapBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueMapBuffer(" << command_queue << ','; + ss << buffer << ',' << getBoolString(blocking_map) << ','; + ss << getMapFlagsString(map_flags) << ','; + ss << offset << ',' << cb << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + void* ret = original_dispatch.EnqueueMapBuffer( + command_queue, buffer, blocking_map, map_flags, offset, cb, + num_events_in_wait_list, event_wait_list, event, errcode_ret); + delRec(&r); + + ss << getHexString(event) << ',' << getErrorString(errcode_ret); + ss << ") = " << ret; + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static void * CL_API_CALL +EnqueueMapImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueMapImage(" << command_queue << ','; + ss << image << ',' << getBoolString(blocking_map) << ','; + ss << getMapFlagsString(map_flags) << ','; + ss << getNDimString(origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << image_row_pitch << ',' << image_slice_pitch << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + void* ret = original_dispatch.EnqueueMapImage( + 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); + delRec(&r); + + ss << getHexString(event) << ',' << getErrorString(errcode_ret); + ss << ") = " << ret; + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueUnmapMemObject( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueUnmapMemObject(" << command_queue << ','; + ss << memobj << ',' << mapped_ptr << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueUnmapMemObject( + command_queue, memobj, mapped_ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueNDRangeKernel( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueNDRangeKernel(" << command_queue << ','; + ss << kernel << ',' << work_dim << ','; + ss << getNDimString(global_work_offset, work_dim) << ','; + ss << getNDimString(global_work_size, work_dim) << ','; + ss << getNDimString(local_work_size, work_dim) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueNDRangeKernel( + command_queue, kernel, work_dim, + global_work_offset, global_work_size, local_work_size, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueTask(cl_command_queue command_queue, + cl_kernel kernel, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueTask(" << command_queue << ',' << kernel << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueTask( + command_queue, kernel, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueNativeKernel( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueNativeKernel(" << command_queue << ',' << user_func << ','; + ss << args << ',' << cb_args << ',' << num_mem_objects << ','; + ss << getHandlesString(mem_list, num_mem_objects) << ','; + ss << args_mem_loc << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueNativeKernel( + command_queue, user_func, args, cb_args, + num_mem_objects, mem_list, args_mem_loc, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueMarker( + cl_command_queue command_queue, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueMarker(" << command_queue << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueMarker(command_queue, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueWaitForEvents( + cl_command_queue command_queue, + cl_uint num_events, + const cl_event * event_list) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueWaitForEvents(" << command_queue << ','; + ss << num_events << ','; + ss << getHandlesString(event_list, num_events); + + addRec(&r); + cl_int ret = original_dispatch.EnqueueWaitForEvents( + command_queue, num_events, event_list); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueBarrier(cl_command_queue command_queue) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueBarrier(" << command_queue; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueBarrier(command_queue); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static void * CL_API_CALL +GetExtensionFunctionAddress(const char * func_name) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetExtensionFunctionAddress(" << func_name; + + addRec(&r); + void* ret = original_dispatch.GetExtensionFunctionAddress(func_name); + delRec(&r); + + ss << ") = " << ret; + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateFromGLBuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateFromGLBuffer(" << context << ','; + ss << getMemFlagsString(flags) << ',' << bufobj << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateFromGLBuffer( + context, flags, bufobj, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateFromGLTexture2D( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateFromGLTexture2D(" << context << ','; + ss << getMemFlagsString(flags) << ',' << target << ','; + ss << miplevel << ',' << texture << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateFromGLTexture2D( + context, flags, target, miplevel, texture, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateFromGLTexture3D( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateFromGLTexture3D(" << context << ','; + ss << getMemFlagsString(flags) << ',' << target << ','; + ss << miplevel << ',' << texture << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateFromGLTexture3D( + context, flags, target, miplevel, texture, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateFromGLRenderbuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint renderbuffer, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateFromGLRenderbuffer(" << context << ','; + ss << getMemFlagsString(flags) << ',' << renderbuffer << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateFromGLRenderbuffer( + context, flags, renderbuffer, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetGLObjectInfo( + cl_mem memobj, + cl_gl_object_type * gl_object_type, + cl_GLuint * gl_object_name) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetGLObjectInfo(" << memobj << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetGLObjectInfo( + memobj, gl_object_type, gl_object_name); + delRec(&r); + + ss << getHexString(gl_object_type) << ','; + ss << getDecimalString(gl_object_name) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetGLTextureInfo( + cl_mem memobj, + cl_gl_texture_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetGLTextureInfo(" << memobj << ','; + ss << param_name << ',' << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetGLTextureInfo( + memobj, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetGLContextInfoKHR( + const cl_context_properties * properties, + cl_gl_context_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetGLContextInfoKHR("; + ss << getContextPropertiesString(properties) << ','; + ss << param_name << ',' << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetGLContextInfoKHR( + properties, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueAcquireGLObjects( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem * mem_objects, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueAcquireGLObjects(" << command_queue << ','; + ss << num_objects << ',' << getHandlesString(mem_objects, num_objects); + ss << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueAcquireGLObjects( + command_queue, num_objects, mem_objects, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueReleaseGLObjects( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem * mem_objects, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueReleaseGLObjects(" << command_queue << ','; + ss << num_objects << ',' << getHandlesString(mem_objects, num_objects); + ss << ',' << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueReleaseGLObjects( + command_queue, num_objects, mem_objects, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +RetainDevice( + cl_device_id device) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clRetainDevice(" << device; + addRec(&r); + cl_int ret = original_dispatch.RetainDevice( + device); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +ReleaseDevice( + cl_device_id device) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "ReleaseDevice(" << device; + addRec(&r); + cl_int ret = original_dispatch.ReleaseDevice( + device); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateImage( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "CreateImage(" << context << ','; + ss << getMemFlagsString(flags) << ','; + ss << getImageFormatsString(image_format, 1) << ','; + ss << getImageDescString(image_desc) << ','; + ss << host_ptr << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateImage( + context, flags, image_format, image_desc, + host_ptr, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_program CL_API_CALL +CreateProgramWithBuiltInKernels( + cl_context context, + cl_uint num_devices, + const cl_device_id * device_list, + const char * kernel_names, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateProgramWithBuiltInKernels(" << context << ','; + ss << num_devices << ',' << getHandlesString(device_list, num_devices); + ss << ',' << kernel_names << ','; + + addRec(&r); + cl_program ret = original_dispatch.CreateProgramWithBuiltInKernels( + context, num_devices, device_list, kernel_names, + errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +CompileProgram( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCompileProgram(" << program << ','; + ss << num_devices << ',' << getHandlesString(device_list, num_devices); + ss << options << ','; + ss << num_devices << ',' << getHandlesString(input_headers, num_input_headers); + ss << header_include_names << ','; + ss << pfn_notify << ','; + + addRec(&r); + cl_int ret = original_dispatch.CompileProgram( + program, num_devices, device_list, options, num_input_headers, + input_headers, header_include_names, pfn_notify, user_data); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_program CL_API_CALL +LinkProgram( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clLinkProgram(" << context << ','; + ss << num_devices << ',' << getHandlesString(device_list, num_devices); + ss << options << ','; + ss << getHandlesString(input_programs, num_input_programs); + ss << pfn_notify << ',' << user_data << ','; + + addRec(&r); + cl_program ret = original_dispatch.LinkProgram( + context, num_devices, device_list, options, num_input_programs, + input_programs, pfn_notify, user_data, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +UnloadPlatformCompiler( + cl_platform_id platform) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clUnloadPlatformCompiler(" << platform << ','; + + addRec(&r); + cl_int ret = original_dispatch.UnloadPlatformCompiler( + platform); + delRec(&r); + + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetKernelArgInfo( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetKernelArgInfo(" << kernel << ','; + ss << arg_indx << ','; + ss << getKernelArgInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetKernelArgInfo( + kernel, arg_indx, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueFillBuffer( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueFillBuffer(" << command_queue << ','; + ss << buffer << ',' << pattern << ',' << pattern_size << ','; + ss << offset << ',' << cb << ',' ; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueFillBuffer( + command_queue, buffer, pattern, pattern_size, offset, cb, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueFillImage( + cl_command_queue command_queue, + cl_mem image, + const void * fill_color, + const size_t origin[3], + const size_t region[3], + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueFillImage(" << command_queue << ','; + ss << image << ',' << fill_color << ','; + ss << getNDimString(origin, 3) << ','; + ss << getNDimString(region, 3) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueFillImage( + command_queue, image, fill_color, origin, region, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event) << ','; + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueMigrateMemObjects( + 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) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueMigrateMemObjects(" << command_queue << ','; + ss << ',' << num_mem_objects << ','; + ss << getHandlesString(mem_objects, num_mem_objects) << ',' << flags << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueMigrateMemObjects( + command_queue, num_mem_objects, mem_objects, flags, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event) << ','; + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueMarkerWithWaitList( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueMarkerWithWaitList(" << command_queue << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueMarkerWithWaitList( + command_queue, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event) << ','; + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueBarrierWithWaitList( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueBarrierWithWaitList(" << command_queue << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueBarrierWithWaitList( + command_queue, num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event) << ','; + ss << ") = " << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static void * CL_API_CALL +GetExtensionFunctionAddressForPlatform( + cl_platform_id platform, + const char * function_name) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetExtensionFunctionAddressForPlatform(" << platform << ','; + ss << function_name << ','; + + addRec(&r); + void* ret = original_dispatch.GetExtensionFunctionAddressForPlatform( + platform, function_name); + delRec(&r); + + ss << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreateFromGLTexture( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateFromGLTexture(" << context << ','; + ss << getMemFlagsString(flags) << ',' << target << ','; + ss << miplevel << ',' << texture << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreateFromGLTexture( + context, flags, target, miplevel, texture, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_mem CL_API_CALL +CreatePipe( + cl_context context, + cl_mem_flags flags, + cl_uint pipePacketSize, + cl_uint pipeMaxPackets, + const cl_pipe_properties * props, + cl_int * errcode_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreatePipe(" << context << ','; + ss << getMemFlagsString(flags) << ',' << pipePacketSize << ','<< pipeMaxPackets << ',' << props << ','; + + addRec(&r); + cl_mem ret = original_dispatch.CreatePipe( + context, flags, pipePacketSize, pipeMaxPackets, props, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +GetPipeInfo( + cl_mem memobj, + cl_pipe_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clGetPipeInfo(" << memobj << ','; + ss << getMemInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.GetPipeInfo( + memobj, param_name, param_value_size, + param_value, param_value_size_ret); + delRec(&r); + + ss << getHexString(param_value) << ','; + ss << getHexString(param_value_size_ret) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static void* CL_API_CALL +SVMAlloc( + cl_context context, + cl_svm_mem_flags flags, + size_t size, + cl_uint alignment) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSVMAlloc(" << context << ','; + ss << getHexString(flags) << ','; + ss << getHexString(size) << ','; + ss << getHexString(alignment) << ") = "; + + addRec(&r); + void* ret = original_dispatch.SVMAlloc(context, flags, size, alignment); + delRec(&r); + + ss << ret << std::endl; + + std::cerr << ss.str(); + return ret; +} + +static void CL_API_CALL +SVMFree(cl_context context, void* svm_pointer) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSVMFree(" << context << ','; + ss << svm_pointer << ')'; + + addRec(&r); + original_dispatch.SVMFree(context, svm_pointer); + delRec(&r); + + ss << std::endl; + + std::cerr << ss.str(); +} + +static cl_int CL_API_CALL +EnqueueSVMFree( + cl_command_queue command_queue, + cl_uint num_svm_pointers, + void * svm_pointers[], + void (CL_CALLBACK * pfn_free_func)(cl_command_queue /*queue */, + cl_uint /* num_svm_pointers */, + void *[] /* svm_pointers */, + void * /* user_data */), + void * user_data, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueSVMMap(" << command_queue << ','; + ss << num_svm_pointers << ','; + ss << '['; + for (cl_uint i = 0; i < num_svm_pointers; ++i) { + ss << svm_pointers[i] << ','; + } + ss << "],"; + ss << pfn_free_func << ','; + ss << user_data << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueSVMFree( + command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + + +static cl_int CL_API_CALL +EnqueueSVMMemcpy( + cl_command_queue command_queue, + cl_bool blocking_copy, + void * dst_ptr, + const void * src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueSVMMemcpy(" << command_queue << ','; + ss << getBoolString(blocking_copy) << ','; + ss << dst_ptr << ','; + ss << src_ptr << ',' << getHexString(size) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueSVMMemcpy( + command_queue, blocking_copy, dst_ptr, src_ptr, size, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueSVMMemFill( + cl_command_queue command_queue, + void * svm_ptr, + const void * pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) CL_API_SUFFIX__VERSION_2_0 +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueSVMMemFill(" << command_queue << ','; + ss << svm_ptr << ','; + ss << pattern << ','; + ss << getHexString(pattern_size) << ',' << getHexString(size) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueSVMMemFill( + command_queue, svm_ptr, pattern, pattern_size, size, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueSVMMap( + cl_command_queue command_queue, + cl_bool blocking_map, + cl_map_flags flags, + void * svm_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueSVMMap(" << command_queue << ','; + ss << getBoolString(blocking_map) << ','; + ss << getMapFlagsString(flags) << ','; + ss << svm_ptr << ',' << getHexString(size) << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueSVMMap( + command_queue, blocking_map, flags, svm_ptr, size, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +EnqueueSVMUnmap( + cl_command_queue command_queue, + void * svm_ptr, + cl_uint num_events_in_wait_list, + const cl_event * event_wait_list, + cl_event * event) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clEnqueueSVMUnmap(" << command_queue << ','; + ss << svm_ptr << ','; + ss << num_events_in_wait_list << ','; + ss << getHandlesString(event_wait_list, num_events_in_wait_list) << ','; + + addRec(&r); + cl_int ret = original_dispatch.EnqueueSVMUnmap( + command_queue, svm_ptr, + num_events_in_wait_list, event_wait_list, event); + delRec(&r); + + ss << getHexString(event); + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_sampler CL_API_CALL +CreateSamplerWithProperties( + cl_context context, + const cl_sampler_properties * sampler_properties, + cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clCreateSamplerWithProperties(" << context << ','; + ss << "["; + + const struct SamplerProperty { + cl_sampler_properties name; + union { + cl_sampler_properties raw; + cl_bool normalizedCoords; + cl_addressing_mode addressingMode; + cl_filter_mode filterMode; + cl_float lod; + } value; + } *p = reinterpret_cast(sampler_properties); + + if (p != NULL) while (p->name != 0) { + ss << getSamplerInfoString((cl_sampler_info)p->name) << ':'; + switch (p->name) { + case CL_SAMPLER_NORMALIZED_COORDS: + ss << getBoolString(p->value.normalizedCoords) << ','; + break; + case CL_SAMPLER_ADDRESSING_MODE: + ss << getAddressingModeString(p->value.addressingMode) << ','; + break; + case CL_SAMPLER_FILTER_MODE: + ss << getFilterModeString(p->value.filterMode) << ','; + break; + case CL_SAMPLER_MIP_FILTER_MODE: + ss << getFilterModeString(p->value.filterMode) << ','; + break; + case CL_SAMPLER_LOD_MIN: + ss << p->value.lod << ','; + break; + case CL_SAMPLER_LOD_MAX: + ss << p->value.lod << ','; + break; + default: + break; + } + ++p; + } + + addRec(&r); + cl_sampler ret = original_dispatch.CreateSamplerWithProperties( + context, sampler_properties, errcode_ret); + delRec(&r); + + ss << getErrorString(errcode_ret) << ") = " << ret; + ss << ret << std::endl; + + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetKernelArgSVMPointer(cl_kernel kernel, cl_uint arg_index, const void *arg_value) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetKernelArgSVMPointer(" << kernel << ','; + ss << arg_index << ','; + ss << arg_value; + + addRec(&r); + cl_int ret = original_dispatch.SetKernelArgSVMPointer( + kernel, arg_index, arg_value); + delRec(&r); + + ss << ") = " << getErrorString(ret); + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_int CL_API_CALL +SetKernelExecInfo( + cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void* param_value) +{ + std::ostringstream ss; + Rec r(&ss); + + ss << "clSetKernelExecInfo(" << kernel << ','; + ss << getKernelExecInfoString(param_name) << ','; + ss << param_value_size << ','; + + addRec(&r); + cl_int ret = original_dispatch.SetKernelExecInfo( + kernel, param_name, param_value_size, + param_value); + delRec(&r); + + ss << getHexString(const_cast(param_value)) << ") = "; + ss << getErrorString(ret); + + ss << std::endl; + std::cerr << ss.str(); + return ret; +} + +static cl_icd_dispatch_table +modified_dispatch = { + /* OpenCL 1.0 */ + GetPlatformIDs, + GetPlatformInfo, + GetDeviceIDs, + GetDeviceInfo, + CreateContext, + CreateContextFromType, + RetainContext, + ReleaseContext, + GetContextInfo, + CreateCommandQueue, + RetainCommandQueue, + ReleaseCommandQueue, + GetCommandQueueInfo, + SetCommandQueueProperty, + CreateBuffer, + CreateImage2D, + CreateImage3D, + RetainMemObject, + ReleaseMemObject, + GetSupportedImageFormats, + GetMemObjectInfo, + GetImageInfo, + CreateSampler, + RetainSampler, + ReleaseSampler, + GetSamplerInfo, + CreateProgramWithSource, + CreateProgramWithBinary, + RetainProgram, + ReleaseProgram, + BuildProgram, + UnloadCompiler, + GetProgramInfo, + GetProgramBuildInfo, + CreateKernel, + CreateKernelsInProgram, + RetainKernel, + ReleaseKernel, + SetKernelArg, + GetKernelInfo, + GetKernelWorkGroupInfo, + WaitForEvents, + GetEventInfo, + RetainEvent, + ReleaseEvent, + GetEventProfilingInfo, + Flush, + Finish, + EnqueueReadBuffer, + EnqueueWriteBuffer, + EnqueueCopyBuffer, + EnqueueReadImage, + EnqueueWriteImage, + EnqueueCopyImage, + EnqueueCopyImageToBuffer, + EnqueueCopyBufferToImage, + EnqueueMapBuffer, + EnqueueMapImage, + EnqueueUnmapMemObject, + EnqueueNDRangeKernel, + EnqueueTask, + EnqueueNativeKernel, + EnqueueMarker, + EnqueueWaitForEvents, + EnqueueBarrier, + GetExtensionFunctionAddress, + CreateFromGLBuffer, + CreateFromGLTexture2D, + CreateFromGLTexture3D, + CreateFromGLRenderbuffer, + GetGLObjectInfo, + GetGLTextureInfo, + EnqueueAcquireGLObjects, + EnqueueReleaseGLObjects, + GetGLContextInfoKHR, + { NULL, NULL, NULL, NULL, NULL, NULL }, /* _reservedForD3D10KHR[6] */ + + /* OpenCL 1.1 */ + SetEventCallback, + CreateSubBuffer, + SetMemObjectDestructorCallback, + CreateUserEvent, + SetUserEventStatus, + EnqueueReadBufferRect, + EnqueueWriteBufferRect, + EnqueueCopyBufferRect, + { NULL, NULL, NULL }, /* _reservedForDeviceFissionEXT[3] */ + NULL, /* CreateEventFromGLsyncKHR */ + + /* OpenCL 1.2 */ + NULL, /* CreateSubDevices */ + RetainDevice, + ReleaseDevice, + CreateImage, + CreateProgramWithBuiltInKernels, + CompileProgram, + LinkProgram, + UnloadPlatformCompiler, + GetKernelArgInfo, + EnqueueFillBuffer, + EnqueueFillImage, + EnqueueMigrateMemObjects, + EnqueueMarkerWithWaitList, + EnqueueBarrierWithWaitList, + GetExtensionFunctionAddressForPlatform, + CreateFromGLTexture, + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* _reservedD3DExtensions[10] */ + { NULL, NULL, NULL, NULL }, /* _reservedEGLExtensions[4] */ + + /* OpenCL 2.0 */ + CreateCommandQueueWithProperties, + CreatePipe, + GetPipeInfo, + SVMAlloc, + SVMFree, + EnqueueSVMFree, + EnqueueSVMMemcpy, + EnqueueSVMMemFill, + EnqueueSVMMap, + EnqueueSVMUnmap, + CreateSamplerWithProperties, + SetKernelArgSVMPointer, + SetKernelExecInfo, + NULL, /* clGetKernelSubGroupInfoKHR */ + + /* OpenCL 2.1 */ + NULL, /* clCloneKernel */ + NULL, /* clCreateProgramWithILKHR */ + NULL, /* clEnqueueSVMMigrateMem */ + NULL, /* clGetDeviceAndHostTimer */ + NULL, /* clGetHostTimer */ + NULL, /* clGetKernelSubGroupInfo */ + NULL, /* clSetDefaultDeviceCommandQueue */ + + /* OpenCL 2.2 */ + NULL, /* clSetProgramReleaseCallback */ + NULL, /* clSetProgramSpecializationConstant */ +}; + +static void +cleanup(void) +{ + std::cerr.rdbuf(cerrStreamBufSave); +} + +#define SET_ORIGINAL_EXTENSION(DISPATCH) \ + memcpy(modified_dispatch._reservedFor##DISPATCH, \ + original_dispatch._reservedFor##DISPATCH, \ + sizeof(original_dispatch._reservedFor##DISPATCH)); + +#define SET_ORIGINAL(DISPATCH) \ + modified_dispatch.DISPATCH = original_dispatch.DISPATCH; + +cl_int CL_CALLBACK +vdiAgent_OnLoad(vdi_agent * agent) +{ + char *clTraceLogEnv; + + cl_int err = agent->GetICDDispatchTable( + agent, &original_dispatch, sizeof(original_dispatch)); + if (err != CL_SUCCESS) { + return err; + } + + clTraceLogEnv = getenv("CL_TRACE_OUTPUT"); + if(clTraceLogEnv!=NULL) { + std::string clTraceLogStr = clTraceLogEnv; + const std::size_t pidPos = clTraceLogStr.find("%pid%"); + if (pidPos != std::string::npos) { +#if defined(ATI_OS_WIN) + const std::int32_t pid = _getpid(); +#else + const std::int32_t pid = getpid(); +#endif + clTraceLogStr.replace(pidPos, 5, std::to_string(pid)); + } + clTraceLog.open(clTraceLogStr); + cerrStreamBufSave = std::cerr.rdbuf(clTraceLog.rdbuf()); + std::atexit(cleanup); + } + + cl_platform_id platform; + err = agent->GetPlatform(agent, &platform); + if (err != CL_SUCCESS) { + return err; + } + + char version[256]; + err = original_dispatch.GetPlatformInfo( + platform, CL_PLATFORM_VERSION, sizeof(version), version, NULL); + if (err != CL_SUCCESS) { + return err; + } + + std::cerr << "!!!" << std::endl << "!!! API trace for \"" + << version << "\"" << std::endl << "!!!" << std::endl; + + SET_ORIGINAL_EXTENSION(D3D10KHR); + SET_ORIGINAL_EXTENSION(DeviceFissionEXT); + SET_ORIGINAL(CreateEventFromGLsyncKHR); + SET_ORIGINAL(CreateSubDevices); + SET_ORIGINAL_EXTENSION(D3DExtensions); + SET_ORIGINAL_EXTENSION(EGLExtensions); + SET_ORIGINAL(GetKernelSubGroupInfoKHR); + SET_ORIGINAL(CloneKernel); + SET_ORIGINAL(CreateProgramWithILKHR); + SET_ORIGINAL(EnqueueSVMMigrateMem); + SET_ORIGINAL(GetDeviceAndHostTimer); + SET_ORIGINAL(GetHostTimer); + SET_ORIGINAL(GetKernelSubGroupInfo); + SET_ORIGINAL(SetDefaultDeviceCommandQueue); + SET_ORIGINAL(SetProgramReleaseCallback); + SET_ORIGINAL(SetProgramSpecializationConstant); + + err = agent->SetICDDispatchTable( + agent, &modified_dispatch, sizeof(modified_dispatch)); + if (err != CL_SUCCESS) { + return err; + } + + initRecs(); + err = startChecker(); + return err; +} + +void CL_CALLBACK +vdiAgent_OnUnload(vdi_agent * agent) +{ + clTraceLog.close(); +} diff --git a/projects/clr/opencl/tools/cltrace/cltrace.def b/projects/clr/opencl/tools/cltrace/cltrace.def new file mode 100644 index 0000000000..f978481dd8 --- /dev/null +++ b/projects/clr/opencl/tools/cltrace/cltrace.def @@ -0,0 +1,2 @@ +EXPORTS +vdiAgent_OnLoad diff --git a/projects/clr/opencl/tools/cltrace/cltrace.map b/projects/clr/opencl/tools/cltrace/cltrace.map new file mode 100644 index 0000000000..81c4556452 --- /dev/null +++ b/projects/clr/opencl/tools/cltrace/cltrace.map @@ -0,0 +1,7 @@ +CLTRACE_1.0 { +global: + vdiAgent_OnLoad; + vdiAgent_OnUnload; +local: + *; +};