//
// Copyright (c) 2010 - 2021 Advanced Micro Devices, Inc. All rights reserved.
//

#include <CL/opencl.h>
#include <vdi_agent_amd.h>

#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 <string>
#include <sstream>
#include <fstream>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdint>

#ifdef _MSC_VER
#include <windows.h>
#include <intrin.h>
#include <process.h>
#else
#include <unistd.h>
#include <pthread.h>
#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 <typename T>
std::string
getDecimalString(T value)
{
    std::ostringstream ss;
    ss << value;
    return ss.str();
}

template <typename T>
std::string
getDecimalString(T* value)
{
    if (value == NULL) {
        return "NULL";
    }

    std::ostringstream ss;
    ss << '&' << *value;
    return ss.str();
}

template <typename T>
std::string
getHexString(T value)
{
    std::ostringstream ss;
    ss << "0x" << std::hex << value;
    return ss.str();
}

template <typename T>
std::string
getHexString(T* value)
{
    if (value == NULL) {
        return "NULL";
    }

    std::ostringstream ss;
    ss << "&0x" << std::hex << *value;
    return ss.str();
}

template <typename T>
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<intptr_t>(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<const cl_event*>(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<const QueueProperty*>(qprops);

    if (p != NULL) while(p->name != 0) {
        switch(p->name) {
        case CL_QUEUE_PROPERTIES:
            property = static_cast<cl_command_queue_properties>(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 " << queueSize;
            break;
#define CL_QUEUE_REAL_TIME_COMPUTE_UNITS_AMD 0x404f
        case CL_QUEUE_REAL_TIME_COMPUTE_UNITS_AMD:
            queueSize = p->value.size;
            ss << " RT_QUEUE " << queueSize;
            break;
#define CL_QUEUE_MEDIUM_PRIORITY_AMD 0x4050
        case CL_QUEUE_MEDIUM_PRIORITY_AMD:
            queueSize = p->value.size;
            ss << " MEDIUM_PRIORITY " << queueSize;
            break;
        default:
            break;
        }
        ++p;
    }

    return ss.str();
}

static std::string
getMemFlagsString(cl_mem_flags flags)
{
    if (flags == 0) {
        return "0";
    }

    std::ostringstream ss;
    while (flags) {
        if (flags & CL_MEM_READ_WRITE) {
            ss << "CL_MEM_READ_WRITE";
            flags &= ~CL_MEM_READ_WRITE;
        }
        else if (flags & CL_MEM_WRITE_ONLY) {
            ss << "CL_MEM_WRITE_ONLY";
            flags &= ~CL_MEM_WRITE_ONLY;
        }
        else if (flags & CL_MEM_READ_ONLY) {
            ss << "CL_MEM_READ_ONLY";
            flags &= ~CL_MEM_READ_ONLY;
        }
        else if (flags & CL_MEM_USE_HOST_PTR) {
            ss << "CL_MEM_USE_HOST_PTR";
            flags &= ~CL_MEM_USE_HOST_PTR;
        }
        else if (flags & CL_MEM_ALLOC_HOST_PTR) {
            ss << "CL_MEM_ALLOC_HOST_PTR";
            flags &= ~CL_MEM_ALLOC_HOST_PTR;
        }
        else if (flags & CL_MEM_COPY_HOST_PTR) {
            ss << "CL_MEM_COPY_HOST_PTR";
            flags &= ~CL_MEM_COPY_HOST_PTR;
        }
        else {
            ss << "0x" << std::hex << (int)flags;
            flags = 0;
        }
        if (flags != 0) {
            ss << '|';
        }
    }

    return ss.str();
}

static std::string
getMapFlagsString(cl_map_flags flags)
{
    if (flags == 0) {
        return "0";
    }

    std::ostringstream ss;
    while (flags) {
        if (flags & CL_MAP_READ) {
            ss << "CL_MAP_READ";
            flags &= ~CL_MAP_READ;
        }
        else if (flags & CL_MAP_WRITE) {
            ss << "CL_MAP_WRITE";
            flags &= ~CL_MAP_WRITE;
        }
        else {
            ss << "0x" << std::hex << (int)flags;
            flags = 0;
        }
        if (flags != 0) {
            ss << '|';
        }
    }

    return ss.str();
}

static std::string
getBufferCreateString(
    cl_buffer_create_type type, const void* info)
{
    std::ostringstream ss;

    if (type == CL_BUFFER_CREATE_TYPE_REGION) {
        const cl_buffer_region* region = (const cl_buffer_region*)info;
        ss << "CL_BUFFER_CREATE_TYPE_REGION,{";
        ss << region->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<const SamplerProperty*>(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<void*>(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;

int32_t CL_CALLBACK
vdiAgent_OnLoad(vdi_agent * agent)
{
    char *clTraceLogEnv;

    int32_t 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(_WIN32)
            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();
}