rocm-systems/projects/clr/opencl/tools/cltrace/cltrace.cpp

//
// 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() > 6000) {
    str = str.substr(0, 6000).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(); }