diff --git a/ext/cl-runtime/cl_runtime.cc b/ext/cl-runtime/cl_runtime.cc new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/cl_runtime.cc @@ -0,0 +1,1753 @@ +/* + * Copyright (c) 2011-2015 Advanced Micro Devices, Inc. + * All rights reserved. + * + * For use for simulation and test purposes only + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Marc Orr + */ + + +#include +#include +#include + +#include +#include + +#include "cl_runtime.hh" +#include "hsa_kernel_info.hh" +#include "misc.hh" +#include "qstruct.hh" + +#define divCeil(a, b) ((a + b - 1) / b) + +volatile uint32_t *dispatcherDoorbell = (uint32_t*)0x10000000; +HsaQueueEntry *hsaTaskPtr = (HsaQueueEntry*)0x10000008; + +// Pointer to the portion of the flat address space reserved for LDS memory +static char *ldsSpaceStart = nullptr; + +// global variables +platform *theOnlyPlatform = nullptr; +std::set memTracker; + +//object tracker +std::map refcontext; +std::map refmem; +std::map refkernel; +std::map refcmdqueue; +std::map refprogram; + +static HsaDriverSizes hsaDriverSizes; +static HsaKernelInfo *hsaKernelInfo; +static const char *hsaStringTable; +static const uint8_t *hsaCode; +static const uint8_t *hsaReadonly; +static uint32_t numCUs = 0; +static uint32_t VecSize = 0; + +cl_uint _cl_device_id::nextID = 0; + +// The current version of the compiler adds six implicit arguments to an +// OpenCL Kernel. This was 3 before, and now it's become 6. CLOC or other +// runtimes may not have them. +static const int DEFAULT_OCL_KERN_ARGS = 6; + +void +clWarn(const char *s) +{ + DPRINT("%s\n", s); +} + +void +clFatal(const char *s) +{ + printf("%s\n", s); + exit(0); +} + +static void +hsaDriverInit() +{ + // skip if already initialized + if (hsaKernelInfo) + return; + + DPRINT("hsaDriverInit()"); + + int fd = open("/dev/hsa", O_RDONLY); + if (fd < 0) { + fprintf(stderr, "Failed to open /dev/hsa\n"); + exit(1); + } + + int status; + + status = ioctl(fd, HSA_GET_SIZES, &hsaDriverSizes); + if (status) { + fprintf(stderr, "HSA_GET_SIZES failed\n"); + exit(1); + } + + DPRINT("hsaDriverInit(): found %d kernels\n", hsaDriverSizes.num_kernels); + + hsaKernelInfo = new HsaKernelInfo[hsaDriverSizes.num_kernels]; + hsaStringTable = new char[hsaDriverSizes.string_table_size]; + + // The simulator fetches a cache block at a time. This behavior may result + // in fetching beyond the code region. If this happens, the simulator + // expects the values fetched to be nullptr. In reality, a more elegant + // solution should be put into place eventually. + uint32_t pad = hsaDriverSizes.code_size % 4096; + pad = (pad == 0) ? 0 : 4096 - pad; + uint32_t padded_code_size = hsaDriverSizes.code_size + pad; + int fp = open("/dev/zero", O_RDONLY); + hsaCode = (uint8_t*)mmap(nullptr, padded_code_size, PROT_EXEC, + MAP_PRIVATE, fp, 0); + + if (hsaDriverSizes.readonly_size > 0) { + pad = hsaDriverSizes.readonly_size % 4096; + pad = (pad == 0) ? 0 : 4096 - pad; + uint32_t padded_readonly_size = hsaDriverSizes.readonly_size + pad; + hsaReadonly = (uint8_t*)mmap(nullptr, padded_readonly_size, + PROT_READ, MAP_PRIVATE, fp, 0); + fprintf(stderr, "hsaReadonly = %llx\n", hsaReadonly); + } else { + hsaReadonly = nullptr; + } + + DPRINT("\t%d %d %d\n\t%p %p %p\n", hsaDriverSizes.num_kernels, + hsaDriverSizes.string_table_size, hsaDriverSizes.code_size, + hsaKernelInfo, hsaStringTable, hsaCode); + + status = ioctl(fd, HSA_GET_KINFO, hsaKernelInfo); + if (status) { + fprintf(stderr, "HSA_GET_KINFO failed\n"); + exit(1); + } + DPRINT("HSA_GET_KINFO\n"); + + status = ioctl(fd, HSA_GET_STRINGS, hsaStringTable); + if (status) { + fprintf(stderr, "HSA_GET_STRINGS failed\n"); + exit(1); + } + DPRINT("HSA_GET_STRINGS\n"); + + status = ioctl(fd, HSA_GET_CODE, hsaCode); + if (status) { + fprintf(stderr, "HSA_GET_CODE failed\n"); + exit(1); + } + DPRINT("HSA_GET_CODE\n"); + + if (hsaDriverSizes.readonly_size > 0) { + status = ioctl(fd, HSA_GET_READONLY_DATA, hsaReadonly); + if (status) { + fprintf(stderr, "HSA_GET_READONLY_DATA failed\n"); + exit(1); + } + DPRINT("HSA_GET_READONLY_DATA\n"); + } else { + hsaReadonly = nullptr; + } + + status = ioctl(fd, HSA_GET_CU_CNT, (cl_uint*)(&numCUs)); + if (status) { + fprintf(stderr, "HSA_GET_CU_CNT failed\n"); + exit(1); + } + + status = ioctl(fd, HSA_GET_VSZ, (cl_uint*)(&VecSize)); + if (status) { + fprintf(stderr, "HSA_GET_VSZ failed\n"); + exit(1); + } +} + +// opencl api implementation + +/* Platform API */ +CL_API_ENTRY cl_int CL_API_CALL +clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platforms, + cl_uint *num_platforms) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetPlatformIDs()\n"); + + if (!theOnlyPlatform) { + theOnlyPlatform = new platform(); + } + + if ((!num_entries && platforms) || + (!num_platforms && !platforms)) { + return CL_INVALID_VALUE; + } else if ((platforms) && (num_entries > 0)) { + platforms[0] = theOnlyPlatform->getID(); + } else if (num_platforms) { + *num_platforms = 1; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetPlatformInfo()\n"); + + if (!platform || platform->ID != theOnlyPlatform->getID()->ID) { + return CL_INVALID_PLATFORM; + } + + if (param_value_size_ret) { + *param_value_size_ret = 0; + } + + char *ret = (char*)param_value; + const char *src; + + switch(param_name) { + case CL_PLATFORM_PROFILE: + src = "FULL_PROFILE"; + if (param_value_size > strlen(src)) { + strcpy(ret, src); + if (param_value_size_ret) { + *param_value_size_ret = sizeof(src); + } + } + break; + case CL_PLATFORM_VERSION: + src = "OpenCL 1.0"; + if (param_value_size > strlen(src)) { + strcpy(ret, src); + if (param_value_size_ret) { + *param_value_size_ret = sizeof(src); + } + } + break; + case CL_PLATFORM_NAME: + src = "ATI Stream"; + if (param_value_size > strlen(src)) { + strcpy(ret, src); + if (param_value_size_ret) { + *param_value_size_ret = sizeof(src); + } + } + break; + case CL_PLATFORM_VENDOR: + src = "Advanced Micro Devices, Inc."; + if (param_value_size > strlen(src)) { + strcpy(ret, src); + if (param_value_size_ret) { + *param_value_size_ret = sizeof(src); + } + } + break; + case CL_PLATFORM_EXTENSIONS: + src = ""; + if (param_value_size > strlen(src)) { + strcpy(ret, src); + if (param_value_size_ret) { + *param_value_size_ret = sizeof(src); + } + } + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_context CL_API_CALL +clCreateContextFromType(const cl_context_properties *properties, + cl_device_type device_type, + void (CL_CALLBACK *pfn_notify)(const char *, + const void *, + size_t, void *), + void *user_data, cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clCreateContextFromType()\n"); + + cl_int ret = CL_SUCCESS; + + if (!properties) { + ret = CL_INVALID_PLATFORM; + } else if (!pfn_notify && user_data) { + ret = CL_INVALID_VALUE; + } else if (pfn_notify) { + clFatal("clCreateContextFromType: pfn_notify not implemented\n"); + } + + int prop_idx = 0; + while (properties[prop_idx]) { + _cl_platform_id *prop; + switch (properties[prop_idx]) { + case CL_CONTEXT_PLATFORM: + prop = (_cl_platform_id*)(properties[prop_idx + 1]); + if (prop->ID != theOnlyPlatform->getID()->ID) { + ret = CL_INVALID_PLATFORM; + } + break; + default: + ret = CL_INVALID_VALUE; + } + prop_idx += 2; + } + + if (ret != CL_SUCCESS) { + if (errcode_ret) { + *errcode_ret = ret; + } + + return nullptr; + } + + _cl_context *context; + ret = theOnlyPlatform->addContext(device_type, &context); + if (errcode_ret) { + *errcode_ret = ret; + } + + if (ret == CL_SUCCESS) { + return context; + } else { + return nullptr; + } +} + +CL_API_ENTRY cl_context CL_API_CALL +clCreateContext(const cl_context_properties *properties, cl_uint num_devices, + const cl_device_id *devices, + void (CL_CALLBACK *pfn_notify)(const char*, const void*, + size_t, void*), + void *user_data, cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + if (!properties) { + _cl_context *context; + theOnlyPlatform->addContext(CL_DEVICE_TYPE_GPU, &context); + + if (errcode_ret) { + *errcode_ret = CL_SUCCESS; + } + + return context; + } + + return clCreateContextFromType(properties, CL_DEVICE_TYPE_GPU, pfn_notify, + user_data,errcode_ret); +} +CL_API_ENTRY cl_int CL_API_CALL +clGetContextInfo(cl_context context, cl_context_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetContextInfo()\n"); + + if (!theOnlyPlatform->isContextValid(context)) { + return CL_INVALID_CONTEXT; + } + + switch (param_name) { + case CL_CONTEXT_REFERENCE_COUNT: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = context->getRefCount(); + } else { + return CL_INVALID_VALUE; + } + } + + break; + case CL_CONTEXT_DEVICES: + if (param_value_size_ret) { + *param_value_size_ret = + sizeof(cl_device_id) * context->getNumDevices(); + } + + if (param_value) { + if (param_value_size >= + sizeof(cl_device_id) * context->getNumDevices()) { + (*((cl_device_id *)(param_value))) = context->devList; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_CONTEXT_PROPERTIES: + clFatal("clGetContextInfo: CL_CONTEXT_PROPERTIES not " + "yet implemented\n"); + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +/* Command Queue APIs */ +CL_API_ENTRY cl_command_queue CL_API_CALL +clCreateCommandQueue(cl_context context, cl_device_id device, + cl_command_queue_properties properties, + cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clCreateCommandQueue()\n"); + + if (!theOnlyPlatform->isContextValid(context)) { + if (errcode_ret) { + *errcode_ret = CL_INVALID_CONTEXT; + } + + return nullptr; + } + + if (device->type != context->getDevType() + && !context->isValidDev(device)) { + if (errcode_ret) { + *errcode_ret = CL_INVALID_DEVICE; + } + + return nullptr; + } + + if (properties & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) { + clWarn("clCreateCommandQueue: CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE " + "not yet implemented\n"); + } + if (properties & CL_QUEUE_PROFILING_ENABLE) { + clWarn("clCreateCommandQueue: CL_QUEUE_PROFILING_ENABLE not yet " + "implemented\n"); + } + if (properties & ~(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE + | CL_QUEUE_PROFILING_ENABLE)) { + if (errcode_ret) { + *errcode_ret = CL_INVALID_QUEUE_PROPERTIES; + } + + return nullptr; + } + + _cl_command_queue *CQ = device->addCQ(); + if (errcode_ret) { + *errcode_ret = CL_SUCCESS; + } + + return CQ; +} + +CL_API_ENTRY cl_mem CL_API_CALL +clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size, + void *host_ptr, cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clCreateBuffer()\n"); + + _cl_mem *buf; + + if (flags & CL_MEM_USE_HOST_PTR) { + buf = (_cl_mem *)host_ptr; + if (errcode_ret) + *errcode_ret = buf ? CL_SUCCESS : + CL_MEM_OBJECT_ALLOCATION_FAILURE; + DPRINT("returning from clCreateBuffer()\n"); + return buf; + } else { + // Ensure the allocated buffer is cache block aligned so that + // coalescing is maximized and bandwidth is reduced. + posix_memalign((void**)&buf, 64, size); + } + if (buf && (flags & CL_MEM_COPY_HOST_PTR)) { + memcpy(buf, host_ptr, size); + } + if (errcode_ret) + *errcode_ret = buf ? CL_SUCCESS : + CL_MEM_OBJECT_ALLOCATION_FAILURE; + memTracker.insert(buf); + DPRINT("returning from clCreateBuffer()\n"); + + return buf; +} + +CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithSource(cl_context context, cl_uint count, + const char **strings, const size_t *lengths, + cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + _cl_program *program; + // addSource sets the program + cl_int err = context->addSource(count, strings, lengths, &program); + // we set the error code if the programmer + // did not pass nullptr for errcode_ret + if (errcode_ret) + *errcode_ret = err; + + return program; +} + +extern CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithBinary(cl_context, cl_uint, const cl_device_id*, + const size_t*, const unsigned char**, + cl_int*, cl_int*) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clCreateProgramWithBinary()\n"); + clWarn("clCreateProgramWithBinary unimplemented\n"); +} + +CL_API_ENTRY cl_int CL_API_CALL +clBuildProgram(cl_program program, cl_uint num_devices, + const cl_device_id *device_list, const char *options, + void (CL_CALLBACK *pfn_notify)(cl_program program, + void *user_data), + void *user_data) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clBuildProgram()\n"); + + clWarn("clBuildProgram unimplemented\n"); + + return CL_SUCCESS; +} + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetProgramInfo(cl_program program, cl_program_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetProgramInfo()\n"); + clWarn("clGetProgramInfo unimplemented\n"); + + switch(param_name) { + case CL_PROGRAM_REFERENCE_COUNT: + clFatal("clGetProgramInfo: CL_PROGRAM_REFERENCE_COUNT not " + "yet implemented\n"); + break; + case CL_PROGRAM_CONTEXT: + clFatal("clGetProgramInfo: CL_PROGRAM_CONTEXT not yet " + "implemented\n"); + break; + case CL_PROGRAM_NUM_DEVICES: + clFatal("clGetProgramInfo: CL_PROGRAM_NUM_DEVICES not yet " + "implemented\n"); + break; + case CL_PROGRAM_DEVICES: + clFatal("clGetProgramInfo: CL_PROGRAM_DEVICES not yet implemented\n"); + break; + case CL_PROGRAM_SOURCE: + clFatal("clGetProgramInfo: CL_PROGRAM_SOURCE not yet implemented\n"); + break; + case CL_PROGRAM_BINARY_SIZES: + clFatal("clGetProgramInfo: CL_PROGRAM_BINARY_SIZES not yet " + "implemented\n"); + break; + case CL_PROGRAM_BINARIES: + clFatal("clGetProgramInfo: CL_PROGRAM_BINARIES not yet " + "implemented\n"); + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clGetProgramBuildInfo(cl_program, cl_device_id, cl_program_build_info, + size_t, void*, size_t*) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetProgramBuildInfo()\n"); + clWarn("clGetProgramBuildInfo unimplemented\n"); +} + +/* Kernel Object APIs */ +CL_API_ENTRY cl_kernel CL_API_CALL +clCreateKernel(cl_program program, const char *kernel_name, + cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clCreateKernel()\n"); + + // init driver in case this is the first call. this call will + // return if the driver is already initialized. + hsaDriverInit(); + + const int MAX_KERNEL_NAME_LENGTH = 256; // totally arbitrary + char long_kernel_name[MAX_KERNEL_NAME_LENGTH]; + snprintf(long_kernel_name, MAX_KERNEL_NAME_LENGTH, + "__OpenCL_%s_kernel", kernel_name); + + DPRINT("clCreateKernel() %s\n", long_kernel_name); + + _cl_kernel *kernel = nullptr; + for (int i = 0; i < hsaDriverSizes.num_kernels; ++i) { + const HsaKernelInfo *kinfo = &hsaKernelInfo[i]; + const char *chk_name = &hsaStringTable[kinfo->name_offs]; + if (!strcmp(long_kernel_name, chk_name)) { + kernel = new _cl_kernel(kernel_name, &hsaCode[kinfo->code_offs], + kinfo->sRegCount, kinfo->dRegCount, + kinfo->cRegCount, kinfo->private_mem_size, + kinfo->spill_mem_size, + kinfo->static_lds_size); + break; + } + } + + if (!kernel) { + fprintf(stderr, "Can't find kernel %s\n", kernel_name); + if (errcode_ret) + *errcode_ret = CL_INVALID_KERNEL_NAME; + + return nullptr; + } + + cl_int tmp = program->addFunction(kernel); + + if (tmp == CL_SUCCESS) { + if (errcode_ret) { + *errcode_ret = tmp; + } + return kernel; + } else { + if (errcode_ret) + *errcode_ret = CL_BUILD_ERROR; + + return nullptr; + } +} + +/* Device APIs */ +CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceIDs(cl_platform_id platform, cl_device_type device_type, + cl_uint num_entries, cl_device_id *devices, + cl_uint *num_devices) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetDeviceIDs()\n"); + + if (!platform || platform->ID != theOnlyPlatform->getID()->ID) { + return CL_INVALID_PLATFORM; + } + + if (device_type & ~(CL_DEVICE_TYPE_ALL | CL_DEVICE_TYPE_CPU | + CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR | + CL_DEVICE_TYPE_DEFAULT) ) { + return CL_INVALID_DEVICE_TYPE; + } + + if ((!num_entries && devices) || (!num_devices && !devices)) { + return CL_INVALID_VALUE; + } + + cl_uint max_dev = 0; + if (num_devices) { + if (device_type & CL_DEVICE_TYPE_ALL) { + *num_devices = theOnlyPlatform->numGPUs() + + theOnlyPlatform->numCPUs(); + } else { + *num_devices = 0; + if (device_type & CL_DEVICE_TYPE_CPU) { + *num_devices += theOnlyPlatform->numGPUs(); + } + if (device_type & CL_DEVICE_TYPE_GPU) { + *num_devices += theOnlyPlatform->numCPUs(); + } + } + max_dev = *num_devices; + } + + cl_uint num_dev_returned = 0; + if (devices) { + num_dev_returned += theOnlyPlatform->getGPUs(devices, num_entries); + num_dev_returned += + theOnlyPlatform->getCPUs(devices, num_entries - num_dev_returned); + } + + if (!(max_dev || num_dev_returned)) { + return CL_DEVICE_NOT_FOUND; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceInfo(cl_device_id device, cl_device_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetDeviceInfo()\n"); + + // init driver in case this is the first call. this call will + // return if the driver is already initialized. + hsaDriverInit(); + + int vector_width = 0; + + if (!theOnlyPlatform->isValidDev(device)) { + return CL_INVALID_DEVICE; + } + + if (param_value_size_ret) { + *param_value_size_ret = 0; + } + + char *strRet = (char*)param_value; + const char *strSrc; + switch (param_name) { + case CL_DEVICE_TYPE: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_device_type); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_device_type)) { + *((cl_device_type*)(param_value)) = CL_DEVICE_TYPE_GPU; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_VENDOR_ID: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = 0; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_MAX_COMPUTE_UNITS: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = numCUs; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = MAX_WI_DIM; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_MAX_WORK_ITEM_SIZES: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(size_t) * 3; + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + size_t *ret = (size_t*)(param_value); + ret[0] = MAX_WI_DIM0; + ret[1] = MAX_WI_DIM1; + ret[2] = MAX_WI_DIM2; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_MAX_WORK_GROUP_SIZE: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(size_t); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((size_t*)(param_value)) = MAX_WG_SIZE; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(char) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(cl_half) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(short) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(int) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(long) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(float) : vector_width; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(double) : vector_width; + DPRINT("vector_width = %d\n", vector_width); + + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = vector_width; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(char) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(cl_half) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(short) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(int) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(long) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(float) : vector_width; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: + vector_width = !vector_width ? + VecSize * sizeof(double) / sizeof(double) : vector_width; + DPRINT("vector_width = %d\n", vector_width); + + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = vector_width; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_MAX_CLOCK_FREQUENCY: + clWarn("clGetDeviceInfo: ignoring request for " + "CL_DEVICE_MAX_CLOCK_FREQUENCY...\n"); + break; + case CL_DEVICE_ADDRESS_BITS: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_uint)) { + *((cl_uint*)(param_value)) = sizeof(void*) * 8; + } else { + return CL_INVALID_VALUE; + } + } + break; + clWarn("clGetDeviceInfo: ignoring request for " + "CL_DEVICE_ADDRESS_BITS...\n"); + break; + case CL_DEVICE_MAX_MEM_ALLOC_SIZE: + clWarn("clGetDeviceInfo: ignoring request for " + "CL_DEVICE_MAX_MEM_ALLOC_SIZE...\n"); + break; + case CL_DEVICE_IMAGE_SUPPORT: + clWarn("clGetDeviceInfo: ignoring request for " + "CL_DEVICE_IMAGE_SUPPORT...\n"); + break; + case CL_DEVICE_MAX_READ_IMAGE_ARGS: + clWarn("clGetDeviceInfo: ignoring request for " + "CL_DEVICE_MAX_READ_IMAGE_ARGS...\n"); + break; + case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: + clWarn("clGetDeviceInfo: CL_DEVICE_MAX_WRITE_IMAGE_ARGS not " + "implemented\n"); + break; + case CL_DEVICE_IMAGE2D_MAX_WIDTH: + clWarn("clGetDeviceInfo: CL_DEVICE_IMAGE2D_MAX_WIDTH not " + "implemented\n"); + break; + case CL_DEVICE_IMAGE2D_MAX_HEIGHT: + clWarn("clGetDeviceInfo: CL_DEVICE_IMAGE2D_MAX_HEIGHT not " + "implemented\n"); + break; + case CL_DEVICE_IMAGE3D_MAX_WIDTH: + clWarn("clGetDeviceInfo: CL_DEVICE_IMAGE3D_MAX_WIDTH not " + "implemented\n"); + break; + case CL_DEVICE_IMAGE3D_MAX_HEIGHT: + clWarn("clGetDeviceInfo: CL_DEVICE_IMAGE3D_MAX_HEIGHT not " + "implemented\n"); + break; + case CL_DEVICE_IMAGE3D_MAX_DEPTH: + clWarn("clGetDeviceInfo: CL_DEVICE_IMAGE3D_MAX_DEPTH not " + "implemented\n"); + break; + case CL_DEVICE_MAX_SAMPLERS: + clWarn("clGetDeviceInfo: CL_DEVICE_MAX_SAMPLERS not implemented\n"); + break; + case CL_DEVICE_MAX_PARAMETER_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_MAX_PARAMETER_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_MEM_BASE_ADDR_ALIGN: + clWarn("clGetDeviceInfo: CL_DEVICE_MEM_BASE_ADDR_ALIGN not " + "implemented\n"); + break; + case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_SINGLE_FP_CONFIG: + clWarn("clGetDeviceInfo: CL_DEVICE_SINGLE_FP_CONFIG not " + "implemented\n"); + break; + case CL_DEVICE_DOUBLE_FP_CONFIG: + clWarn("clGetDeviceInfo: CL_DEVICE_DOUBLE_FP_CONFIG not " + "implemented\n"); + break; + case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: + clWarn("clGetDeviceInfo: CL_DEVICE_GLOBAL_MEM_CACHE_TYPE not " + "implemented\n"); + break; + case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_GLOBAL_MEM_CACHE_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_GLOBAL_MEM_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_GLOBAL_MEM_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: + clWarn("clGetDeviceInfo: CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE not " + "implemented\n"); + break; + case CL_DEVICE_MAX_CONSTANT_ARGS: + clWarn("clGetDeviceInfo: CL_DEVICE_MAX_CONSTANT_ARGS not " + "implemented\n"); + break; + case CL_DEVICE_LOCAL_MEM_TYPE: + clWarn("clGetDeviceInfo: CL_DEVICE_LOCAL_MEM_TYPE not implemented\n"); + break; + case CL_DEVICE_LOCAL_MEM_SIZE: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(unsigned long long); + } + + if (param_value) { + if (param_value_size >= sizeof(unsigned long long)) { + *((unsigned long long*)(param_value)) = MAX_LDS_SIZE; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_ERROR_CORRECTION_SUPPORT: + clWarn("clGetDeviceInfo: CL_DEVICE_ERROR_CORRECTION_SUPPORT not " + "implemented\n"); + break; + case CL_DEVICE_PROFILING_TIMER_RESOLUTION: + clWarn("clGetDeviceInfo: CL_DEVICE_PROFILING_TIMER_RESOLUTION not " + "implemented\n"); + break; + case CL_DEVICE_ENDIAN_LITTLE: + clWarn("clGetDeviceInfo: CL_DEVICE_ENDIAN_LITTLE not implemented\n"); + break; + case CL_DEVICE_HOST_UNIFIED_MEMORY: + clWarn("clGetDeviceInfo: CL_DEVICE_HOST_UNIFIED_MEMORY not " + "implemented\n"); + break; + case CL_DEVICE_AVAILABLE: + clWarn("clGetDeviceInfo: CL_DEVICE_AVAILABLE not implemented\n"); + break; + case CL_DEVICE_COMPILER_AVAILABLE: + clWarn("clGetDeviceInfo: CL_DEVICE_COMPILER_AVAILABLE not " + "implemented\n"); + break; + case CL_DEVICE_EXECUTION_CAPABILITIES: + clWarn("clGetDeviceInfo: CL_DEVICE_EXECUTION_CAPABILITIES not " + "implemented\n"); + break; + case CL_DEVICE_QUEUE_PROPERTIES: + clWarn("clGetDeviceInfo: CL_DEVICE_QUEUE_PROPERTIES not " + "implemented\n"); + break; + case CL_DEVICE_PLATFORM: + clWarn("clGetDeviceInfo: CL_DEVICE_PLATFORM not implemented\n"); + break; + case CL_DEVICE_NAME: + strSrc = "HSAIL-GPU"; + if (param_value_size_ret) { + *param_value_size_ret = strlen(strSrc) + 1; + } + + if (param_value) { + if (param_value_size >= strlen(strSrc) + 1) { + strcpy (strRet, strSrc); + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_DEVICE_VENDOR: + clWarn("clGetDeviceInfo: CL_DEVICE_VENDOR not implemented\n"); + break; + case CL_DRIVER_VERSION: + clWarn("clGetDeviceInfo: CL_DRIVER_VERSION not implemented\n"); + break; + case CL_DEVICE_OPENCL_C_VERSION: + clWarn("clGetDeviceInfo: CL_DEVICE_OPENCL_C_VERSION not " + "implemented\n"); + break; + case CL_DEVICE_PROFILE: + clWarn("clGetDeviceInfo: CL_DEVICE_PROFILE not implemented\n"); + break; + case CL_DEVICE_VERSION: + clWarn("clGetDeviceInfo: CL_DEVICE_VERSION not implemented\n"); + break; + case CL_DEVICE_EXTENSIONS: + strSrc = "cl_khr_byte_addressable_store"; + if (param_value_size_ret) { + *param_value_size_ret = strlen(strSrc) + 1; + } + + if (param_value) { + if (param_value_size >= strlen(strSrc) + 1) { + strcpy (strRet, strSrc); + } else { + return CL_INVALID_VALUE; + } + } + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL +clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size, + const void *arg_value) +CL_API_SUFFIX__VERSION_1_0 +{ + if (!arg_value) { + DPRINT("clSetKernelArg(%p, %d, %d, nullptr)\n", + (void*)kernel, arg_index, (int)arg_size); + } else if (arg_size == 4) { + DPRINT("clSetKernelArg(%p, %d, %d, %#x)\n", + (void*)kernel, arg_index, (int)arg_size, + *(uint32_t*)arg_value); + } else if (arg_size == 8) { + DPRINT("clSetKernelArg(%p, %d, %d, %#llx)\n", + (void*)kernel, arg_index, (int)arg_size, + *(uint64_t*)arg_value); + } else { + DPRINT("clSetKernelArg(%p, %d, %d, %p)\n", + (void*)kernel, arg_index, (int)arg_size, arg_value); + } + + kernel->addArg(arg_index + DEFAULT_OCL_KERN_ARGS, arg_size, arg_value); + + return CL_SUCCESS; +} + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueUnmapMemObject(cl_command_queue, cl_mem, void*, cl_uint, + const cl_event*, cl_event*) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueUnmapMemObject()\n"); + clWarn("clEnqueueUnmapMemObject unimplemented\n"); + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clEnqueueNDRangeKernel(cl_command_queue command_queue, cl_kernel kernel, + cl_uint work_dim, const size_t *global_work_offset, + const size_t *global_work_size, + const size_t *local_work_size, + cl_uint num_events_in_wait_list, + const cl_event *event_wait_list, cl_event *event) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueNDRangeKernel()\n"); + HsaQueueEntry *hsa_task = (HsaQueueEntry*)malloc(sizeof(HsaQueueEntry)); + HostState *host_state = (HostState*)malloc(sizeof(HostState)); + + // the current version of the compiler adds 6 implicit arguments to an + // OpenCL kernel + if (!global_work_offset) { + kernel->addOCLKernelOffsetArgs(0, 0); + kernel->addOCLKernelOffsetArgs(1, 0); + kernel->addOCLKernelOffsetArgs(2, 0); + } else { + kernel->addOCLKernelOffsetArgs(0, &global_work_offset[0]); + kernel->addOCLKernelOffsetArgs(1, &global_work_offset[1]); + kernel->addOCLKernelOffsetArgs(2, &global_work_offset[2]); + } + + kernel->addOCLKernelOffsetArgs(3, 0); + kernel->addOCLKernelOffsetArgs(4, 0); + kernel->addOCLKernelOffsetArgs(5, 0); + + if (event) { + *event = new _cl_event(); + } + + hsa_task->depends = (uint64_t)host_state; + host_state->event = event ? (uint64_t)(*event) : 0; + + if (work_dim < 1 || work_dim > 3) { + return CL_INVALID_WORK_DIMENSION; + } + + for (cl_uint i = 0; i < work_dim; ++i) { + hsa_task->gdSize[i] = global_work_size[i]; + if (local_work_size) { + hsa_task->wgSize[i] = (local_work_size[i] > global_work_size[i]) ? + global_work_size[i] : local_work_size[i]; + } else { + hsa_task->wgSize[i] = global_work_size[i] > 256 ? + 256 : global_work_size[i]; + // only set 1 dimension automatically + for (++i; i < work_dim; ++i) + hsa_task->wgSize[i] = 1; + break; + } + } + for (cl_uint i = work_dim; i < 3; ++i) { + hsa_task->gdSize[i] = 1; + hsa_task->wgSize[i] = 1; + } + + // allocate space for WF context + int numWgTotal = 1; + int wfPerWgTotal = 1; + for (int i = 0; i < 3; ++i) { + numWgTotal *= divCeil(hsa_task->gdSize[i], hsa_task->wgSize[i]); + wfPerWgTotal *= (hsa_task->wgSize[i] + VecSize - 1) / VecSize; + } + int numCtx = numWgTotal * wfPerWgTotal; + + ////////////////////////////////////// + hsa_task->code_ptr = (uint64_t)kernel->code; + DPRINT("launching %s\n", kernel->name); + + // setup arguments + hsa_task->num_args = kernel->maxArgIdx + 1; + int offset = 0; + + for (cl_uint i = 0; i <= kernel->maxArgIdx; i++) { + // copy argument to argument buffer in allocated HSA queue entry + DPRINT("HSA runtime: Offset %d\n", offset); + hsa_task->offsets[i] = offset; + if (kernel->argList[i].contents) { + memcpy(hsa_task->args + offset, kernel->argList[i].contents, + kernel->argList[i].size); + } else { + // argument is __local pointer, i.e., LDS offset + // must use groupMemOffset instead of contents + *(uint64_t*)(hsa_task->args + offset) = + (uint64_t)(kernel->argList[i].groupMemOffset); + } + + offset += kernel->argList[i].size; + + if (i != kernel->maxArgIdx) { + int pad = offset % kernel->argList[i + 1].size; + pad = !pad ? 0 : kernel->argList[i + 1].size - pad; + offset += pad; + } + } + + // Point the dispatcher to counter variable (tracking # of dispatches) + // polled by runtime + hsa_task->numDispLeft = (uint64_t)command_queue->numDispLeft; + + hsa_task->sRegCount = kernel->sRegCount; + hsa_task->dRegCount = kernel->dRegCount; + hsa_task->cRegCount = kernel->cRegCount; + + DPRINT("regs: s %d d %d c %d\n", hsa_task->sRegCount, + hsa_task->dRegCount, hsa_task->cRegCount); + + // Allocate private memory for the kernel, the gdSize already + // accounts for all the blocks + int numWorkItems = hsa_task->gdSize[0] * + hsa_task->gdSize[1] * + hsa_task->gdSize[2]; + numWorkItems = numWorkItems % VecSize ? numWorkItems + VecSize - + (numWorkItems % VecSize) : numWorkItems; + + hsa_task ->privMemPerItem = kernel->privateMemSize; + hsa_task ->spillMemPerItem = kernel->spillMemSize; + + // Total of privMem and spillMem should be calculated with + // Total number of wavefronts must be: + // (Wavefronts * WavefrontSize)* privMemPerItem/spillMemPerItem. + hsa_task->privMemTotal = (kernel->privateMemSize * numWorkItems); + hsa_task->spillMemTotal = (kernel->spillMemSize * numWorkItems); + + // FIXME: There is a mismatch regarding the allcation and use of both + // privateMemory and spliiMemory. On this (HSA_runtime), the total memory + // for each buufer (spill or priv) is calucalted by muptiplying + // total_number of workitems with spill/priv size per workitem. + // On hsail GPU side, the accesses to spill/priv memory assumes + // there is (VSZ * spill/priv per workitem) for each wavefront. + // This becomes a problem when the (total workitems less than number + // of wavefronts * VSZ). The multiplication by 8 below is a hack. + // should be fixed. The multiply with 8 (below) is to make the allocated + // memory for spill buffer large enough. Multipying with 64 would be + // the most conservative approach. + hsa_task->spillMemTotal = hsa_task->spillMemTotal * 8; + + hsa_task->privMemStart = hsa_task->privMemTotal > 0 ? + (uint64_t)malloc(hsa_task->privMemTotal) : 0; + DPRINT("hsa_task->privMemTotal=%d\n", hsa_task->privMemTotal); + DPRINT("hsa_task->privMemStart=%p\n", (void*)hsa_task->privMemStart); + + hsa_task->spillMemStart = hsa_task->spillMemTotal > 0 ? + (uint64_t)malloc(hsa_task->spillMemTotal) : 0; + DPRINT("hsa_task->spillMemTotal=%d\n", hsa_task->spillMemTotal); + DPRINT("hsa_task->spillMemStart=%p\n", (void*)hsa_task->spillMemStart); + + hsa_task->roMemTotal = hsaDriverSizes.readonly_size; + hsa_task->roMemStart = (uint64_t)hsaReadonly; + + // initialize read-only memory + + // LDS storage will be allocated by CU + hsa_task->ldsSize = kernel->groupMemSize; + DPRINT("hsa_task->ldsSize=%d\n", hsa_task->ldsSize); + + // Point the dispatcher to done variables polled by runtime + if (event) { + hsa_task->addrToNotify = (uint64_t)&((*event)->done); + (*event)->hsaTaskPtr = hsa_task; + } else { + hsa_task->addrToNotify = 0; + hsa_task->depends = 0; + } + memcpy(hsaTaskPtr, hsa_task, sizeof(HsaQueueEntry)); + + // notify the dispatch engine that the task params are complete + *dispatcherDoorbell = 0; + + return CL_SUCCESS; +} + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetKernelWorkGroupInfo(cl_kernel kernel, cl_device_id device, + cl_kernel_work_group_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetKernelWorkGroupInfo()\n"); + + switch (param_name) { + case CL_KERNEL_WORK_GROUP_SIZE: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(size_t); + } + + if (param_value) { + if (param_value_size >= sizeof(size_t)) { + *((size_t*)(param_value)) = MAX_WG_SIZE; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_KERNEL_COMPILE_WORK_GROUP_SIZE: + if(param_value_size_ret) { + *param_value_size_ret = sizeof(size_t) * 3; + } + + if (param_value) { + if (param_value_size >= sizeof(size_t) * 3) { + size_t *dest = (size_t*)param_value; + dest[0] = 0; + dest[1] = 0; + dest[2] = 0; + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_KERNEL_LOCAL_MEM_SIZE: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_ulong); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_ulong)) { + *((cl_ulong*)(param_value)) = MAX_LDS_SIZE; + } else { + return CL_INVALID_VALUE; + } + } + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clWaitForEvents(cl_uint num_events, const cl_event *event_list) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clWaitForEvents()\n"); + + for (cl_uint i = 0; i < num_events; ++i) { + while (!event_list[i]->done) { + asm("hlt"); + } + } + return CL_SUCCESS; +} + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetEventInfo(cl_event event, cl_event_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetEventInfo()\n"); + + switch (param_name) { + case CL_EVENT_COMMAND_QUEUE: + clFatal("CL_EVENT_COMMAND_QUEUE: clGetEventInfo not yet " + "implemented\n"); + break; + case CL_EVENT_COMMAND_TYPE: + clFatal("CL_EVENT_COMMAND_TYPE: clGetEventInfo not yet " + "implemented\n"); + break; + case CL_EVENT_COMMAND_EXECUTION_STATUS: + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_int); + } + + if (param_value) { + if (param_value_size >= sizeof(cl_int)) { + if(event->done) { + *((cl_int*)(param_value)) = CL_COMPLETE; + } else { + *((cl_int*)(param_value)) = CL_RUNNING; + } + } else { + return CL_INVALID_VALUE; + } + } + break; + case CL_EVENT_REFERENCE_COUNT: + clFatal("CL_EVENT_REFERENCE_COUNT: clGetEventInfo not yet " + "implemented\n"); + break; + default: + return CL_INVALID_VALUE; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseEvent(cl_event event) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseEvent()\n"); + + if (event->hsaTaskPtr) { + if (event->hsaTaskPtr->privMemStart) { + free((void*)(event->hsaTaskPtr->privMemStart)); + } + if (event->hsaTaskPtr->spillMemStart) { + free((char*)(event->hsaTaskPtr->spillMemStart)); + } + free(event->hsaTaskPtr); + } + delete event; + return CL_SUCCESS; +} + +/* Profiling APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clGetEventProfilingInfo(cl_event event, cl_profiling_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clGetEventProfilingInfo()\n"); + + if (param_value_size_ret) { + *param_value_size_ret = 0; + } + + switch (param_name) { + case CL_PROFILING_COMMAND_START: + assert(param_value_size >= sizeof(uint64_t)); + *((uint64_t*)param_value) = event->start; + if (param_value_size_ret) { + *param_value_size_ret = sizeof(uint64_t); + } + break; + case CL_PROFILING_COMMAND_END: + assert(param_value_size >= sizeof(uint64_t)); + *((uint64_t*)param_value) = event->end; + if (param_value_size_ret) { + *param_value_size_ret = sizeof(uint64_t); + } + break; + default: + return CL_INVALID_VALUE; + } + return CL_SUCCESS; +} + +/* Flush and Finish APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clFlush(cl_command_queue command_queue) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clFlush()\n"); + while (*(command_queue->numDispLeft) > 0); + // asm("hlt") does not work here because there + // is a race if the dispatcher called cpu->wakeup() + // when the CPU is awake and hlt is the next CPU instruction + // to be executed + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clFinish()\n"); + while (*(command_queue->numDispLeft) > 0); + // asm("hlt") does not work here because there + // is a race if the dispatcher called cpu->wakeup() + // when the CPU is awake and hlt is the next CPU instruction + // to be executed + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem buffer, + cl_bool blocking_read, size_t offset, size_t size, + void *ptr, cl_uint num_events_in_wait_list, + const cl_event *event_wait_list, cl_event *event) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueReadBuffer()\n"); + // make sure buffer and ptr are not nullptr pointers + if (!(buffer && ptr)) { + return CL_INVALID_VALUE; + } + + if (event) { + *event = new _cl_event(); + } + + if ((!event_wait_list && num_events_in_wait_list > 0) || + (event_wait_list && !num_events_in_wait_list)) { + return CL_INVALID_EVENT_WAIT_LIST; + } + + clWaitForEvents(num_events_in_wait_list, event_wait_list); + clFinish(command_queue); + if ((void*)buffer != ptr) { + memcpy(ptr, (char*)buffer+offset, size); + } + + if (event) { + (*event)->done = true; + } + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem buffer, + cl_bool blocking_write, size_t offset, size_t size, + const void *ptr, cl_uint num_events_in_wait_list, + const cl_event *event_wait_list, cl_event *event) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueWriteBuffer()\n"); + + if (!(buffer && ptr)) { + return CL_INVALID_VALUE; + } + + if (event) { + *event = new _cl_event(); + } + + if ((!event_wait_list && num_events_in_wait_list > 0) || + (event_wait_list && !num_events_in_wait_list)) { + return CL_INVALID_EVENT_WAIT_LIST; + } + + clWaitForEvents(num_events_in_wait_list, event_wait_list); + if ((void*)buffer != ptr) { + memcpy((char *)buffer+offset, ptr, size); + } + + if (event) { + (*event)->done = true; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyBuffer(cl_command_queue command_queue, cl_mem src_buffer, + cl_mem dst_buffer, size_t src_offset, size_t dst_offset, + size_t size, cl_uint num_events_in_wait_list, + const cl_event *event_wait_list, cl_event *event) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueCopyBuffer()\n"); + + if (!src_buffer) { + return CL_INVALID_VALUE; + } + + if (!dst_buffer) { + return CL_INVALID_VALUE; + } + + if (event) { + *event = new _cl_event(); + } + + if ((!event_wait_list && num_events_in_wait_list > 0) || + (event_wait_list && !num_events_in_wait_list)) { + return CL_INVALID_EVENT_WAIT_LIST; + } + + clWaitForEvents(num_events_in_wait_list, event_wait_list); + + if (((char*)(dst_buffer)+dst_offset) != (char*)(src_buffer)) { + memcpy(((char*)(dst_buffer)+dst_offset), (char*)src_buffer, size); + } + + if (event) { + (*event)->done = true; + } + + return CL_SUCCESS; +} + +CL_API_ENTRY void * CL_API_CALL +clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buffer, + cl_bool blocking_map, cl_map_flags map_flags, + size_t offset, size_t size, + cl_uint num_events_in_wait_list, + const cl_event *event_wait_list, cl_event *event, + cl_int *errcode_ret) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clEnqueueMapBuffer()\n"); + + if (event) { + *event = new _cl_event(); + } + + if ((!event_wait_list && num_events_in_wait_list > 0) || + (event_wait_list && !num_events_in_wait_list)) { + if (errcode_ret) { + *errcode_ret = CL_INVALID_EVENT_WAIT_LIST; + } + + return nullptr; + } + + clWaitForEvents(num_events_in_wait_list, event_wait_list); + + if (event) { + (*event)->done = true; + } + + if (errcode_ret) { + *errcode_ret = CL_SUCCESS; + } + + return (void*)((char*)buffer + offset); +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseKernel()\n"); + cl_int refcnt = refkernel[kernel]; + + if (!refcnt) + delete kernel; + else if (refcnt > 0) + refkernel[kernel]--; + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseProgram()\n"); + cl_int refcnt = refprogram[program]; + + if (!refcnt) + delete program; + else if (refcnt > 0) + refprogram[program]--; + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseMemObject()\n"); + + if (memTracker.count(memobj)) { + free(memobj); + } + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseCommandQueue(cl_command_queue command_queue) +CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseCommandQueue()\n"); + cl_int refcnt = refcmdqueue[command_queue]; + + if (!refcnt) + delete command_queue; + else if (refcnt > 0) + refcmdqueue[command_queue]--; + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 +{ + DPRINT("clReleaseContext()\n"); + cl_int refcnt = refcontext[context]; + + if (!refcnt) + delete context; + else if (refcnt > 0) + refcontext[context]--; + + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 +{ + ++refcontext[context]; + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 +{ + ++refmem[memobj]; + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 +{ + ++refkernel[kernel]; + return CL_SUCCESS; +} + +CL_API_ENTRY cl_int CL_API_CALL +clRetainCommandQueue(cl_command_queue command_queue) +CL_API_SUFFIX__VERSION_1_0 +{ + ++refcmdqueue[command_queue]; + return CL_SUCCESS; + +} + +CL_API_ENTRY cl_int CL_API_CALL +clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 +{ + ++refprogram[program]; + return CL_SUCCESS; + +} diff --git a/ext/cl-runtime/lib.mk b/ext/cl-runtime/lib.mk new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/lib.mk @@ -0,0 +1,57 @@ +# +# Copyright © 1997,2000 Paul D. Smith +# Verbatim copying and distribution is permitted in any medium, provided this +# notice is preserved. +# See http://make.paulandlesley.org/multi-arch.html#advanced +# + +TGTDIR = $(notdir $(CURDIR)) + +ifeq (64, $(findstring 64, $(TGTDIR))) + BITS := 64 +else ifeq (32, $(findstring 32, $(TGTDIR))) + BITS := 32 +else + $(error Target directory name does not indicate BITS) +endif + +ifeq (dbg, $(findstring dbg, $(TGTDIR))) + MODE := dbg +else + MODE := +endif + +VPATH = .. + +HSAIL_GPU = ../../../src/gpu +GEM5_BASE = ../../../src +RUNTIME_SRCS = cl_runtime.cc +HEADERS = cl_runtime.hh \ + $(HSAIL_GPU)/hsa_kernel_info.hh $(HSAIL_GPU)/qstruct.hh +CFLAGS = -D BUILD_CL_RUNTIME + +ifeq ($(MODE), dbg) + CFLAGS += -g -DDEBUG +else + CFLAGS += -O3 +endif + +ifeq ($(BITS), 32) + CFLAGS += -m32 +endif + +CXXFLAGS = $(CFLAGS) -std=c++11 + +CPPFLAGS = -I.. -I$(HSAIL_GPU) -I$(GEM5_BASE) + +all: libOpenCL.a + +RUNTIME_OBJS = $(RUNTIME_SRCS:.cc=.o) + +$(RUNTIME_OBJS): $(HEADERS) + +libOpenCL.a: $(RUNTIME_OBJS) + ar rc libOpenCL.a cl_runtime.o + +clean: + rm -f libOpenCL.a cl_runtime.o hsa_test diff --git a/ext/cl-runtime/cl_event.h b/ext/cl-runtime/cl_event.h new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/cl_event.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011-2015 Advanced Micro Devices, Inc. + * All rights reserved. + * + * For use for simulation and test purposes only + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Marc Orr + */ + +#ifndef CL_EVENT_H_INCLUDED +#define CL_EVENT_H_INCLUDED + +struct HsaQueueEntry; + +class _cl_event { + public: + _cl_event() : done(false), hsaTaskPtr(nullptr), start(0), end(0) { } + + volatile bool done; + HsaQueueEntry *hsaTaskPtr; + uint64_t start; + uint64_t end; +}; + +#endif diff --git a/ext/cl-runtime/cl_runtime.hh b/ext/cl-runtime/cl_runtime.hh new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/cl_runtime.hh @@ -0,0 +1,428 @@ +/* + * Copyright (c) 2011-2015 Advanced Micro Devices, Inc. + * All rights reserved. + * + * For use for simulation and test purposes only + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Marc Orr + */ + +#ifndef __CL_RUNTIME_HH__ +#define __CL_RUNTIME_HH__ + +#ifdef DEBUG +#define DPRINT(format, ...) fprintf(stderr, format, ## __VA_ARGS__) +#else +#define DPRINT(str, ...) +#endif + +#include +#include +#include + +#include "CL/cl_platform.h" +#include "CL/cl.hpp" +#include "cl_event.h" +#include "cl_command_queue.h" + +static const int MAX_WG_SIZE = 1024; + +static const int MAX_WI_DIM = 3; +static const int MAX_WI_DIM0 = 1024; +static const int MAX_WI_DIM1 = 1024; +static const int MAX_WI_DIM2 = 64; + +// Assume a maximum LDS space of 64k +static const int MAX_LDS_SIZE = 64 * 1024; + +// maximum number of kernels per OpenCL binary +static const int MAX_FUNCTIONS_PER_BINARY = 32; +static const int MAX_ARGS_FOR_KERNELS = 40; + +// Used in qstruct.h +typedef uint64_t Addr; + +// general stuff +void clWarn(const char *s); +void clFatal(const char *s); + +// opencl "built-in" types +struct _cl_platform_id { + cl_uint ID; +}; + +class _cl_device_id { + public: + _cl_device_id() { } + + _cl_device_id(cl_device_type _type) : type(_type), ID(nextID++) { } + + ~_cl_device_id() { } + + _cl_command_queue *addCQ() + { + _cl_command_queue *CQ = new _cl_command_queue(); + cqList.push_back(CQ); + return CQ; + } + + cl_uint ID; + cl_device_type type; + + private: + std::vector<_cl_command_queue *> cqList; + static cl_uint nextID; +}; + +struct source_desc +{ + char *str; + size_t len; +}; + +struct argDesc { + size_t size; + void *contents; + int groupMemOffset; +}; + +class _cl_kernel { + public: + _cl_kernel(const char *_name, const void *_code, unsigned sregs, + unsigned dregs, unsigned cregs, unsigned privmem, + unsigned spillmem, unsigned static_lds_size) : + name(_name), code(_code), sRegCount(sregs), dRegCount(dregs), + cRegCount(cregs), privateMemSize(privmem), spillMemSize(spillmem), + groupMemSize(static_lds_size), maxArgIdx(0) + { + memset(&argList, 0, sizeof(argList)); + } + + ~_cl_kernel() + { + for (int i = 0; i < MAX_ARGS_FOR_KERNELS; i++) + if (argList[i].contents) + free(argList[i].contents); + } + + void addArg(cl_uint arg_index, size_t arg_size, const void *arg_value) + { + assert(arg_index < MAX_ARGS_FOR_KERNELS); + + if (arg_value != nullptr) { + argList[arg_index].size = arg_size; + if (argList[arg_index].contents == nullptr) { + argList[arg_index].contents = + (void*)malloc(argList[arg_index].size); + } + memcpy(argList[arg_index].contents, arg_value, arg_size); + } else { + argList[arg_index].size = sizeof(uint64_t); + // assume a null pointer value means it's group memory + // that needs to be dynamically allocated + argList[arg_index].contents = nullptr; + argList[arg_index].groupMemOffset = groupMemSize; + groupMemSize += (arg_size + 7) & ~7; // force 8 byte alignment + } + + if (maxArgIdx < arg_index) { + maxArgIdx = arg_index; + } + } + + void addOCLKernelOffsetArgs(cl_uint arg_index, const void *arg_value) + { + assert(arg_index < MAX_ARGS_FOR_KERNELS); + argList[arg_index].size = sizeof(uint64_t); + argList[arg_index].contents = nullptr; + + if (arg_value) { + if (argList[arg_index].contents == nullptr) { + argList[arg_index].contents = + (void*)malloc(argList[arg_index].size); + } + + memcpy(argList[arg_index].contents, arg_value, + argList[arg_index].size); + } + + if (maxArgIdx < arg_index) { + maxArgIdx = arg_index; + } + } + + const char *name; + const void *code; + + unsigned int privateMemSize; + unsigned int spillMemSize; + unsigned int groupMemSize; + unsigned int sRegCount; // Number of s registers + unsigned int dRegCount; // Number of d registers + unsigned int cRegCount; // Number of c registers + + cl_uint maxArgIdx; + argDesc argList[MAX_ARGS_FOR_KERNELS]; +}; + +class _cl_program { + public: + _cl_program() : numFunctions(0) + { + kernList = + (_cl_kernel**)malloc(sizeof(_cl_kernel*)*MAX_FUNCTIONS_PER_BINARY); + } + + ~_cl_program() + { + /*free(kernList); + for(cl_uint i=0; istr); + free(srcStrings[i]); + } + free(srcStrings);*/ + } + + source_desc **srcStrings; + cl_uint numSrcStrings; + _cl_kernel **kernList; + + cl_int addFunction(_cl_kernel *kernel) + { + if (numFunctions == MAX_FUNCTIONS_PER_BINARY) { + printf("Unable to register function %s (increase " + "MAX_FUNCTIONS_PER_BINARY)\n", kernel->name); + return CL_OUT_OF_HOST_MEMORY; + } + + kernList[numFunctions] = kernel; + numFunctions++; + + return CL_SUCCESS; + } + + private: + cl_uint numFunctions; + char *symbolTable; + int numAllocatedSymbols; +}; + +class _cl_context { + public: + _cl_context(std::vector<_cl_device_id *> &dev_list, + cl_device_type device_type) : deviceType(device_type) + { + refCount = 1; + + // create device list + numDevices = dev_list.size(); + devList = new _cl_device_id[numDevices]; + + //enumerate devices + cl_uint devCount = 0; + for (devCount = 0; devCount < numDevices; devCount++) { + devList[devCount].ID = dev_list[devCount]->ID; + devList[devCount].type = device_type; + } + } + + ~_cl_context() + { + //delete devList; + } + + cl_int addSource(cl_uint count, const char **strings, + const size_t *lengths, _cl_program **program) + { + if (count == 0 || strings == nullptr || *strings == nullptr) { + _cl_program *_program = new _cl_program(); + *program = _program; + return CL_SUCCESS; + } + + _cl_program *_program = new _cl_program(); + _program->srcStrings = (source_desc**)malloc(sizeof(source_desc*)); + _program->numSrcStrings = count; + + for (cl_uint i; i < count; i++) { + if (strings[i] == nullptr) { + return CL_INVALID_VALUE; + } + + source_desc *cur_src = (source_desc *)malloc(sizeof(source_desc)); + + if (lengths == nullptr || lengths[i] == 0) { + size_t bytes = strlen(strings[i]) + 1; + cur_src->str = (char*)malloc(bytes); + cur_src->len = 0; + strcpy(cur_src->str, strings[i]); + cur_src->str[strlen(strings[i])] = '\0'; + } else { + cur_src->str = (char *)malloc(lengths[i]+1); + cur_src->len = lengths[i]; + memcpy(cur_src->str, strings[i], lengths[i]); + cur_src->str[lengths[i]] = '\0'; + } + + sourceList.push_back(cur_src); + _program->srcStrings[i] = cur_src; + } + + *program = _program; + + return CL_SUCCESS; + } + + bool isValidDev(_cl_device_id *dev) + { + uint64_t dev_u64 = (uint64_t)dev; + uint64_t devList_u64 = (uint64_t)devList; + + if (dev_u64 >= devList_u64 && dev_u64 <= devList_u64 + numDevices + && (dev_u64 - devList_u64) % sizeof(_cl_device_id) == 0 ) { + return true; + } + + return false; + } + + cl_uint getRefCount() { return refCount; } + cl_uint getNumDevices() { return numDevices; } + cl_device_type getDevType() { return deviceType; } + + _cl_device_id *devList; + + private: + cl_uint refCount; + cl_uint numDevices; + cl_device_type deviceType; + + std::vector sourceList; +}; + +class platform { + public: + platform() + { + clID.ID = 0; + gpuDevList.push_back(new _cl_device_id(CL_DEVICE_TYPE_GPU)); + } + + _cl_platform_id *getID() { return &clID; } + + cl_int addContext(cl_device_type device_type, _cl_context **context) + { + std::vector<_cl_device_id *> emptyGpuDevList; + std::vector<_cl_device_id *> emptyCpuDevList; + + if (device_type == CL_DEVICE_TYPE_GPU) { + *context = new _cl_context(gpuDevList, device_type); + } else if (device_type == CL_DEVICE_TYPE_CPU) { + *context = new _cl_context(cpuDevList, device_type); + } else { + return CL_INVALID_DEVICE_TYPE; + } + + if ((*context)->getNumDevices() < 1) { + delete *context; + *context = nullptr; + + return CL_DEVICE_NOT_AVAILABLE; + } + + contextList.push_back(*context); + return CL_SUCCESS; + } + + bool isContextValid(_cl_context *context) + { + auto it = find (contextList.begin(), contextList.end(), context); + + if (it == contextList.end()) { + return false; + } + + return true; + } + + bool isValidDev(_cl_device_id *dev) + { + for (cl_uint i = 0; i < gpuDevList.size(); ++i) { + if (dev->ID == gpuDevList[i]->ID) { + return true; + } + } + + for (cl_uint i = 0; i < cpuDevList.size(); ++i) { + if (dev->ID == cpuDevList[i]->ID) { + return true; + } + } + return false; + } + + cl_uint numGPUs() { return gpuDevList.size(); } + cl_uint numCPUs() { return cpuDevList.size(); } + + cl_uint getGPUs(_cl_device_id **dev_list, cl_uint num_dev) + { + cl_uint num_ret = 0; + + for(num_ret = 0; num_ret < gpuDevList.size(); num_ret++) { + if(num_ret+1 > num_dev) { + break; + } + dev_list[num_ret] = gpuDevList[num_ret]; + } + + return num_ret; + } + + cl_uint getCPUs(_cl_device_id **dev_list, cl_uint num_dev) + { + cl_uint num_ret = 0; + + for(; num_ret num_dev) { + break; + } + dev_list[num_ret] = cpuDevList[num_ret]; + } + + return num_ret; + } + + private: + std::vector<_cl_context *> contextList; + std::vector<_cl_device_id *> gpuDevList; + std::vector<_cl_device_id *> cpuDevList; + _cl_platform_id clID; +}; + +#endif // __CL_RUNTIME_HH__ diff --git a/ext/cl-runtime/CL/cl_ext.h b/ext/cl-runtime/CL/cl_ext.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl_ext.h @@ -0,0 +1,310 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/* $Revision: 14835 $ on $Date: 2011-05-26 11:32:00 -0700 (Thu, 26 May 2011) $ */ + +/* cl_ext.h contains OpenCL extensions which don't have external */ +/* (OpenGL, D3D) dependencies. */ + +#ifndef __CL_EXT_H +#define __CL_EXT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __APPLE__ + #include + #include +#else + #include +#endif + +/* cl_khr_fp64 extension - no extension #define since it has no functions */ +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 + +/* cl_khr_fp16 extension - no extension #define since it has no functions */ +#define CL_DEVICE_HALF_FP_CONFIG 0x1033 + +/* Memory object destruction + * + * Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR + * + * Registers a user callback function that will be called when the memory object is deleted and its resources + * freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback + * stack associated with memobj. The registered user callback functions are called in the reverse order in + * which they were registered. The user callback functions are called and then the memory object is deleted + * and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be + * notified when the memory referenced by host_ptr, specified when the memory object is created and used as + * the storage bits for the memory object, can be reused or freed. + * + * The application may not call CL api's with the cl_mem object passed to the pfn_notify. + * + * Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) + * before using. + */ +#define cl_APPLE_SetMemObjectDestructor 1 +cl_int CL_API_ENTRY clSetMemObjectDestructorAPPLE( cl_mem /* memobj */, + void (* /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), + void * /*user_data */ ) CL_EXT_SUFFIX__VERSION_1_0; + + +/* Context Logging Functions + * + * The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext(). + * Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) + * before using. + * + * clLogMessagesToSystemLog fowards on all log messages to the Apple System Logger + */ +#define cl_APPLE_ContextLoggingFunctions 1 +extern void CL_API_ENTRY clLogMessagesToSystemLogAPPLE( const char * /* errstr */, + const void * /* private_info */, + size_t /* cb */, + void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0; + +/* clLogMessagesToStdout sends all log messages to the file descriptor stdout */ +extern void CL_API_ENTRY clLogMessagesToStdoutAPPLE( const char * /* errstr */, + const void * /* private_info */, + size_t /* cb */, + void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0; + +/* clLogMessagesToStderr sends all log messages to the file descriptor stderr */ +extern void CL_API_ENTRY clLogMessagesToStderrAPPLE( const char * /* errstr */, + const void * /* private_info */, + size_t /* cb */, + void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0; + + +/************************ +* cl_khr_icd extension * +************************/ +#define cl_khr_icd 1 + +/* cl_platform_info */ +#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 + +/* Additional Error Codes */ +#define CL_PLATFORM_NOT_FOUND_KHR -1001 + +extern CL_API_ENTRY cl_int CL_API_CALL +clIcdGetPlatformIDsKHR(cl_uint /* num_entries */, + cl_platform_id * /* platforms */, + cl_uint * /* num_platforms */); + +typedef CL_API_ENTRY cl_int (CL_API_CALL *clIcdGetPlatformIDsKHR_fn)( + cl_uint /* num_entries */, + cl_platform_id * /* platforms */, + cl_uint * /* num_platforms */); + + +/****************************************** +* cl_nv_device_attribute_query extension * +******************************************/ +/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */ +#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 +#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 +#define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002 +#define CL_DEVICE_WARP_SIZE_NV 0x4003 +#define CL_DEVICE_GPU_OVERLAP_NV 0x4004 +#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005 +#define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006 + +/********************************* +* cl_amd_device_memory_flags * +*********************************/ +#define cl_amd_device_memory_flags 1 + +#define CL_MEM_USE_PERSISTENT_MEM_AMD (1 << 6) // Alloc from GPU's CPU visible heap + +/* cl_device_info */ +#define CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT 0x4032 + +/********************************* +* cl_amd_device_attribute_query * +*********************************/ +#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036 +#define CL_DEVICE_TOPOLOGY_AMD 0x4037 +#define CL_DEVICE_BOARD_NAME_AMD 0x4038 +#define CL_DEVICE_GLOBAL_FREE_MEMORY_AMD 0x4039 + +typedef union +{ + struct { cl_uint type; cl_uint data[5]; } raw; + struct { cl_uint type; cl_char unused[17]; cl_char bus; cl_char device; cl_char function; } pcie; +} cl_device_topology_amd; + +#define CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD 1 + +// +/*************************** +* cl_amd_command_intercept * +***************************/ +#define CL_CONTEXT_COMMAND_INTERCEPT_CALLBACK_AMD 0x403D +#define CL_QUEUE_COMMAND_INTERCEPT_ENABLE_AMD (1ull << 63) + +typedef cl_int (CL_CALLBACK * intercept_callback_fn)(cl_event, cl_int *); +// + +/************************** +* cl_amd_offline_devices * +**************************/ +#define CL_CONTEXT_OFFLINE_DEVICES_AMD 0x403F + +// + + +#ifdef CL_VERSION_1_1 + /*********************************** + * cl_ext_device_fission extension * + ***********************************/ + #define cl_ext_device_fission 1 + + extern CL_API_ENTRY cl_int CL_API_CALL + clReleaseDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int + (CL_API_CALL *clReleaseDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL + clRetainDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int + (CL_API_CALL *clRetainDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + typedef cl_ulong cl_device_partition_property_ext; + extern CL_API_ENTRY cl_int CL_API_CALL + clCreateSubDevicesEXT( cl_device_id /*in_device*/, + const cl_device_partition_property_ext * /* properties */, + cl_uint /*num_entries*/, + cl_device_id * /*out_devices*/, + cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int + ( CL_API_CALL * clCreateSubDevicesEXT_fn)( cl_device_id /*in_device*/, + const cl_device_partition_property_ext * /* properties */, + cl_uint /*num_entries*/, + cl_device_id * /*out_devices*/, + cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + /* cl_device_partition_property_ext */ + #define CL_DEVICE_PARTITION_EQUALLY_EXT 0x4050 + #define CL_DEVICE_PARTITION_BY_COUNTS_EXT 0x4051 + #define CL_DEVICE_PARTITION_BY_NAMES_EXT 0x4052 + #define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT 0x4053 + + /* clDeviceGetInfo selectors */ + #define CL_DEVICE_PARENT_DEVICE_EXT 0x4054 + #define CL_DEVICE_PARTITION_TYPES_EXT 0x4055 + #define CL_DEVICE_AFFINITY_DOMAINS_EXT 0x4056 + #define CL_DEVICE_REFERENCE_COUNT_EXT 0x4057 + #define CL_DEVICE_PARTITION_STYLE_EXT 0x4058 + + /* error codes */ + #define CL_DEVICE_PARTITION_FAILED_EXT -1057 + #define CL_INVALID_PARTITION_COUNT_EXT -1058 + #define CL_INVALID_PARTITION_NAME_EXT -1059 + + /* CL_AFFINITY_DOMAINs */ + #define CL_AFFINITY_DOMAIN_L1_CACHE_EXT 0x1 + #define CL_AFFINITY_DOMAIN_L2_CACHE_EXT 0x2 + #define CL_AFFINITY_DOMAIN_L3_CACHE_EXT 0x3 + #define CL_AFFINITY_DOMAIN_L4_CACHE_EXT 0x4 + #define CL_AFFINITY_DOMAIN_NUMA_EXT 0x10 + #define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT 0x100 + + /* cl_device_partition_property_ext list terminators */ + #define CL_PROPERTIES_LIST_END_EXT ((cl_device_partition_property_ext) 0) + #define CL_PARTITION_BY_COUNTS_LIST_END_EXT ((cl_device_partition_property_ext) 0) + #define CL_PARTITION_BY_NAMES_LIST_END_EXT ((cl_device_partition_property_ext) 0 - 1) + + /* cl_ext_atomic_counters_32 and cl_ext_atomic_counters_64 extensions + * no extension #define since they have no functions + */ + #define CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT 0x4032 + + /*********************************** + * cl_ext_migrate_memobject extension definitions + ***********************************/ + #define cl_ext_migrate_memobject 1 + + typedef cl_bitfield cl_mem_migration_flags_ext; + + #define CL_MIGRATE_MEM_OBJECT_HOST_EXT 0x1 + + #define CL_COMMAND_MIGRATE_MEM_OBJECT_EXT 0x4040 + + extern CL_API_ENTRY cl_int CL_API_CALL + clEnqueueMigrateMemObjectEXT( cl_command_queue /* command_queue */, + cl_uint /* num_mem_objects */, + const cl_mem * /* mem_objects */, + cl_mem_migration_flags_ext /* flags */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int + (CL_API_CALL *clEnqueueMigrateMemObjectEXT_fn)( cl_command_queue /* command_queue */, + cl_uint /* num_mem_objects */, + const cl_mem * /* mem_objects */, + cl_mem_migration_flags_ext /* flags */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_1; + +// + /************************* + * cl_amd_object_metadata * + **************************/ + #define cl_amd_object_metadata 1 + + typedef size_t cl_key_amd; + + #define CL_INVALID_OBJECT_AMD 0x403A + #define CL_INVALID_KEY_AMD 0x403B + #define CL_PLATFORM_MAX_KEYS_AMD 0x403C + + typedef CL_API_ENTRY cl_key_amd (CL_API_CALL * clCreateKeyAMD_fn)( + cl_platform_id /* platform */, + void (CL_CALLBACK * /* destructor */)( void* /* old_value */), + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int (CL_API_CALL * clObjectGetValueForKeyAMD_fn)( + void * /* object */, + cl_key_amd /* key */, + void ** /* ret_val */) CL_API_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int (CL_API_CALL * clObjectSetValueForKeyAMD_fn)( + void * /* object */, + cl_key_amd /* key */, + void * /* value */) CL_API_SUFFIX__VERSION_1_1; +// + +#endif /* CL_VERSION_1_1 */ + +#ifdef __cplusplus +} +#endif + + +#endif /* __CL_EXT_H */ diff --git a/ext/cl-runtime/CL/cl_gl.h b/ext/cl-runtime/CL/cl_gl.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl_gl.h @@ -0,0 +1,163 @@ +/********************************************************************************** + * Copyright (c) 2011 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +#ifndef __OPENCL_CL_GL_H +#define __OPENCL_CL_GL_H + +#ifdef __APPLE__ +#include +#else +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef cl_uint cl_gl_object_type; +typedef cl_uint cl_gl_texture_info; +typedef cl_uint cl_gl_platform_info; +typedef struct __GLsync *cl_GLsync; + +/* cl_gl_object_type = 0x2000 - 0x200F enum values are currently taken */ +#define CL_GL_OBJECT_BUFFER 0x2000 +#define CL_GL_OBJECT_TEXTURE2D 0x2001 +#define CL_GL_OBJECT_TEXTURE3D 0x2002 +#define CL_GL_OBJECT_RENDERBUFFER 0x2003 +#define CL_GL_OBJECT_TEXTURE2D_ARRAY 0x200E +#define CL_GL_OBJECT_TEXTURE1D 0x200F +#define CL_GL_OBJECT_TEXTURE1D_ARRAY 0x2010 +#define CL_GL_OBJECT_TEXTURE_BUFFER 0x2011 + +/* cl_gl_texture_info */ +#define CL_GL_TEXTURE_TARGET 0x2004 +#define CL_GL_MIPMAP_LEVEL 0x2005 + + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromGLBuffer(cl_context /* context */, + cl_mem_flags /* flags */, + cl_GLuint /* bufobj */, + int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromGLTexture(cl_context /* context */, + cl_mem_flags /* flags */, + cl_GLenum /* target */, + cl_GLint /* miplevel */, + cl_GLuint /* texture */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromGLRenderbuffer(cl_context /* context */, + cl_mem_flags /* flags */, + cl_GLuint /* renderbuffer */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetGLObjectInfo(cl_mem /* memobj */, + cl_gl_object_type * /* gl_object_type */, + cl_GLuint * /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetGLTextureInfo(cl_mem /* memobj */, + cl_gl_texture_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireGLObjects(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 */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReleaseGLObjects(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 */) CL_API_SUFFIX__VERSION_1_0; + + +#ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS +//#warning CL_USE_DEPRECATED_OPENCL_1_1_APIS is defined. These APIs are unsupported and untested in OpenCL 1.2! + extern CL_API_ENTRY cl_mem CL_API_CALL + clCreateFromGLTexture2D(cl_context /* context */, + cl_mem_flags /* flags */, + cl_GLenum /* target */, + cl_GLint /* miplevel */, + cl_GLuint /* texture */, + cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_mem CL_API_CALL + clCreateFromGLTexture3D(cl_context /* context */, + cl_mem_flags /* flags */, + cl_GLenum /* target */, + cl_GLint /* miplevel */, + cl_GLuint /* texture */, + cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_2_APIS */ + +/* cl_khr_gl_sharing extension */ + +#define cl_khr_gl_sharing 1 + +typedef cl_uint cl_gl_context_info; + +/* Additional Error Codes */ +#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000 + +/* cl_gl_context_info */ +#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006 +#define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007 + +/* Additional cl_context_properties */ +#define CL_GL_CONTEXT_KHR 0x2008 +#define CL_EGL_DISPLAY_KHR 0x2009 +#define CL_GLX_DISPLAY_KHR 0x200A +#define CL_WGL_HDC_KHR 0x200B +#define CL_CGL_SHAREGROUP_KHR 0x200C + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetGLContextInfoKHR(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 */) CL_API_SUFFIX__VERSION_1_0; + +typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)( + 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); + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_GL_H */ diff --git a/ext/cl-runtime/CL/cl_gl_ext.h b/ext/cl-runtime/CL/cl_gl_ext.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl_gl_ext.h @@ -0,0 +1,69 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 14826 $ on $Date: 2011-05-26 07:40:43 -0700 (Thu, 26 May 2011) $ */ + +/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have */ +/* OpenGL dependencies. */ + +#ifndef __OPENCL_CL_GL_EXT_H +#define __OPENCL_CL_GL_EXT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __APPLE__ + #include +#else + #include +#endif + +/* + * For each extension, follow this template + * cl_VEN_extname extension */ +/* #define cl_VEN_extname 1 + * ... define new types, if any + * ... define new tokens, if any + * ... define new APIs, if any + * + * If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header + * This allows us to avoid having to decide whether to include GL headers or GLES here. + */ + +/* + * cl_khr_gl_event extension + * See section 9.9 in the OpenCL 1.1 spec for more information + */ +#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D + +extern CL_API_ENTRY cl_event CL_API_CALL +clCreateEventFromGLsyncKHR(cl_context /* context */, + cl_GLsync /* cl_GLsync */, + cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1; + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_GL_EXT_H */ diff --git a/ext/cl-runtime/CL/cl_platform.h b/ext/cl-runtime/CL/cl_platform.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl_platform.h @@ -0,0 +1,1116 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 14829 $ on $Date: 2011-05-26 08:22:50 -0700 (Thu, 26 May 2011) $ */ + +#ifndef __CL_PLATFORM_H +#define __CL_PLATFORM_H + +#ifdef __APPLE__ + /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ + #include +#endif + +#if !defined(_WIN32) || !defined(_MSC_VER) +# include +#endif /* !_WIN32 */ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) || defined(__CYGWIN__) + #define CL_API_ENTRY + #define CL_API_CALL __stdcall + #define CL_CALLBACK __stdcall +#else + #define CL_API_ENTRY + #define CL_API_CALL + #define CL_CALLBACK +#endif + +#ifdef __APPLE__ + #define CL_EXTENSION_WEAK_LINK __attribute__((weak_import)) + #define CL_API_SUFFIX__VERSION_1_0 AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER + #define CL_EXT_SUFFIX__VERSION_1_0 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER + #define CL_API_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK + #define CL_EXT_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK + #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER +#else + #define CL_EXTENSION_WEAK_LINK + #define CL_API_SUFFIX__VERSION_1_0 + #define CL_EXT_SUFFIX__VERSION_1_0 + #define CL_API_SUFFIX__VERSION_1_1 + #define CL_EXT_SUFFIX__VERSION_1_1 + #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED + #define CL_API_SUFFIX__VERSION_1_2 + #define CL_EXT_SUFFIX__VERSION_1_2 + #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED +#endif + +#if (defined (_WIN32) && defined(_MSC_VER)) + +/* scalar types */ +typedef signed __int8 cl_char; +typedef unsigned __int8 cl_uchar; +typedef signed __int16 cl_short; +typedef unsigned __int16 cl_ushort; +typedef signed __int32 cl_int; +typedef unsigned __int32 cl_uint; +typedef signed __int64 cl_long; +typedef unsigned __int64 cl_ulong; +typedef unsigned __int16 cl_half; +#else /* !_WIN32 */ +typedef int8_t cl_char; +typedef uint8_t cl_uchar; +typedef int16_t cl_short; +typedef uint16_t cl_ushort; +typedef int32_t cl_int; +typedef uint32_t cl_uint; +typedef int64_t cl_long; +typedef uint64_t cl_ulong; +typedef uint16_t cl_half; +#endif /* !_WIN32 */ +typedef float cl_float; +typedef double cl_double; + +#define CL_CHAR_BIT 8 +#define CL_SCHAR_MAX 127 +#define CL_SCHAR_MIN (-127-1) +#define CL_CHAR_MAX CL_SCHAR_MAX +#define CL_CHAR_MIN CL_SCHAR_MIN +#define CL_UCHAR_MAX 255 +#define CL_SHRT_MAX 32767 +#define CL_SHRT_MIN (-32767-1) +#define CL_USHRT_MAX 65535 +#define CL_INT_MAX 2147483647 +#define CL_INT_MIN (-2147483647-1) +#define CL_UINT_MAX 0xffffffffU +#define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) +#define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) +#define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) + +#define CL_FLT_DIG 6 +#define CL_FLT_MANT_DIG 24 +#define CL_FLT_MAX_10_EXP +38 +#define CL_FLT_MAX_EXP +128 +#define CL_FLT_MIN_10_EXP -37 +#define CL_FLT_MIN_EXP -125 +#define CL_FLT_RADIX 2 +#define CL_FLT_MAX FLT_MAX +#define CL_FLT_MIN FLT_MIN +#define CL_FLT_EPSILON FLT_EPSILON + +#define CL_DBL_DIG 15 +#define CL_DBL_MANT_DIG 53 +#define CL_DBL_MAX_10_EXP +308 +#define CL_DBL_MAX_EXP +1024 +#define CL_DBL_MIN_10_EXP -307 +#define CL_DBL_MIN_EXP -1021 +#define CL_DBL_RADIX 2 +#define CL_DBL_MAX DBL_MAX +#define CL_DBL_MIN DBL_MIN +#define CL_DBL_EPSILON DBL_EPSILON + +#define CL_M_E 2.718281828459045090796 +#define CL_M_LOG2E 1.442695040888963387005 +#define CL_M_LOG10E 0.434294481903251816668 +#define CL_M_LN2 0.693147180559945286227 +#define CL_M_LN10 2.302585092994045901094 +#define CL_M_PI 3.141592653589793115998 +#define CL_M_PI_2 1.570796326794896557999 +#define CL_M_PI_4 0.785398163397448278999 +#define CL_M_1_PI 0.318309886183790691216 +#define CL_M_2_PI 0.636619772367581382433 +#define CL_M_2_SQRTPI 1.128379167095512558561 +#define CL_M_SQRT2 1.414213562373095145475 +#define CL_M_SQRT1_2 0.707106781186547572737 + +#define CL_M_E_F 2.71828174591064f +#define CL_M_LOG2E_F 1.44269502162933f +#define CL_M_LOG10E_F 0.43429449200630f +#define CL_M_LN2_F 0.69314718246460f +#define CL_M_LN10_F 2.30258512496948f +#define CL_M_PI_F 3.14159274101257f +#define CL_M_PI_2_F 1.57079637050629f +#define CL_M_PI_4_F 0.78539818525314f +#define CL_M_1_PI_F 0.31830987334251f +#define CL_M_2_PI_F 0.63661974668503f +#define CL_M_2_SQRTPI_F 1.12837922573090f +#define CL_M_SQRT2_F 1.41421353816986f +#define CL_M_SQRT1_2_F 0.70710676908493f + +#define CL_NAN (CL_INFINITY - CL_INFINITY) +#define CL_HUGE_VALF ((cl_float) 1e50) +#define CL_HUGE_VAL ((cl_double) 1e500) +#define CL_MAXFLOAT CL_FLT_MAX +#define CL_INFINITY CL_HUGE_VALF + +#include + +/* Mirror types to GL types. Mirror types allow us to avoid deciding which headers to load based on whether we are using GL or GLES here. */ +typedef unsigned int cl_GLuint; +typedef int cl_GLint; +typedef unsigned int cl_GLenum; + +/* + * Vector types + * + * Note: OpenCL requires that all types be naturally aligned. + * This means that vector types must be naturally aligned. + * For example, a vector of four floats must be aligned to + * a 16 byte boundary (calculated as 4 * the natural 4-byte + * alignment of the float). The alignment qualifiers here + * will only function properly if your compiler supports them + * and if you don't actively work to defeat them. For example, + * in order for a cl_float4 to be 16 byte aligned in a struct, + * the start of the struct must itself be 16-byte aligned. + * + * Maintaining proper alignment is the user's responsibility. + */ + +/* Define basic vector types */ +#if defined( __VEC__ ) + #include /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */ + typedef vector unsigned char __cl_uchar16; + typedef vector signed char __cl_char16; + typedef vector unsigned short __cl_ushort8; + typedef vector signed short __cl_short8; + typedef vector unsigned int __cl_uint4; + typedef vector signed int __cl_int4; + typedef vector float __cl_float4; + #define __CL_UCHAR16__ 1 + #define __CL_CHAR16__ 1 + #define __CL_USHORT8__ 1 + #define __CL_SHORT8__ 1 + #define __CL_UINT4__ 1 + #define __CL_INT4__ 1 + #define __CL_FLOAT4__ 1 +#endif + +#if defined( __SSE__ ) + #if defined( __MINGW64__ ) + #include + #else + #include + #endif + #if defined( __GNUC__ ) && !defined( __ICC ) + typedef float __cl_float4 __attribute__((vector_size(16))); + #else + typedef __m128 __cl_float4; + #endif + #define __CL_FLOAT4__ 1 +#endif + +#if defined( __SSE2__ ) + #if defined( __MINGW64__ ) + #include + #else + #include + #endif + #if defined( __GNUC__ ) && !defined( __ICC ) + typedef cl_uchar __cl_uchar16 __attribute__((vector_size(16))); + typedef cl_char __cl_char16 __attribute__((vector_size(16))); + typedef cl_ushort __cl_ushort8 __attribute__((vector_size(16))); + typedef cl_short __cl_short8 __attribute__((vector_size(16))); + typedef cl_uint __cl_uint4 __attribute__((vector_size(16))); + typedef cl_int __cl_int4 __attribute__((vector_size(16))); + typedef cl_ulong __cl_ulong2 __attribute__((vector_size(16))); + typedef cl_long __cl_long2 __attribute__((vector_size(16))); + typedef cl_double __cl_double2 __attribute__((vector_size(16))); + #else + typedef __m128i __cl_uchar16; + typedef __m128i __cl_char16; + typedef __m128i __cl_ushort8; + typedef __m128i __cl_short8; + typedef __m128i __cl_uint4; + typedef __m128i __cl_int4; + typedef __m128i __cl_ulong2; + typedef __m128i __cl_long2; + typedef __m128d __cl_double2; + #endif + #define __CL_UCHAR16__ 1 + #define __CL_CHAR16__ 1 + #define __CL_USHORT8__ 1 + #define __CL_SHORT8__ 1 + #define __CL_INT4__ 1 + #define __CL_UINT4__ 1 + #define __CL_ULONG2__ 1 + #define __CL_LONG2__ 1 + #define __CL_DOUBLE2__ 1 +#endif + +#if defined( __MMX__ ) + #include + #if defined( __GNUC__ ) && !defined( __ICC ) + typedef cl_uchar __cl_uchar8 __attribute__((vector_size(8))); + typedef cl_char __cl_char8 __attribute__((vector_size(8))); + typedef cl_ushort __cl_ushort4 __attribute__((vector_size(8))); + typedef cl_short __cl_short4 __attribute__((vector_size(8))); + typedef cl_uint __cl_uint2 __attribute__((vector_size(8))); + typedef cl_int __cl_int2 __attribute__((vector_size(8))); + typedef cl_ulong __cl_ulong1 __attribute__((vector_size(8))); + typedef cl_long __cl_long1 __attribute__((vector_size(8))); + typedef cl_float __cl_float2 __attribute__((vector_size(8))); + #else + typedef __m64 __cl_uchar8; + typedef __m64 __cl_char8; + typedef __m64 __cl_ushort4; + typedef __m64 __cl_short4; + typedef __m64 __cl_uint2; + typedef __m64 __cl_int2; + typedef __m64 __cl_ulong1; + typedef __m64 __cl_long1; + typedef __m64 __cl_float2; + #endif + #define __CL_UCHAR8__ 1 + #define __CL_CHAR8__ 1 + #define __CL_USHORT4__ 1 + #define __CL_SHORT4__ 1 + #define __CL_INT2__ 1 + #define __CL_UINT2__ 1 + #define __CL_ULONG1__ 1 + #define __CL_LONG1__ 1 + #define __CL_FLOAT2__ 1 +#endif + +#if defined( __AVX__ ) + #if defined( __MINGW64__ ) + #include + #else + #include + #endif + #if defined( __GNUC__ ) && !defined( __ICC ) + typedef cl_float __cl_float8 __attribute__((vector_size(32))); + typedef cl_double __cl_double4 __attribute__((vector_size(32))); + #else + typedef __m256 __cl_float8; + typedef __m256d __cl_double4; + #endif + #define __CL_FLOAT8__ 1 + #define __CL_DOUBLE4__ 1 +#endif + +/* Define alignment keys */ +#if (defined( __GNUC__ ) || defined( __IBMC__ )) + #define CL_ALIGNED(_x) __attribute__ ((aligned(_x))) +#elif defined( _WIN32) && (_MSC_VER) + /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ + /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ + /* #include */ + /* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ + #define CL_ALIGNED(_x) +#else + #warning Need to implement some method to align data here + #define CL_ALIGNED(_x) +#endif + +/* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + /* .xyzw and .s0123...{f|F} are supported */ + #define CL_HAS_NAMED_VECTOR_FIELDS 1 + /* .hi and .lo are supported */ + #define CL_HAS_HI_LO_VECTOR_FIELDS 1 +#endif + +/* Define cl_vector types */ + +/* ---- cl_charn ---- */ +typedef union +{ + cl_char CL_ALIGNED(2) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y; }; + __extension__ struct{ cl_char s0, s1; }; + __extension__ struct{ cl_char lo, hi; }; +#endif +#if defined( __CL_CHAR2__) + __cl_char2 v2; +#endif +}cl_char2; + +typedef union +{ + cl_char CL_ALIGNED(4) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w; }; + __extension__ struct{ cl_char s0, s1, s2, s3; }; + __extension__ struct{ cl_char2 lo, hi; }; +#endif +#if defined( __CL_CHAR2__) + __cl_char2 v2[2]; +#endif +#if defined( __CL_CHAR4__) + __cl_char4 v4; +#endif +}cl_char4; + +/* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ +typedef cl_char4 cl_char3; + +typedef union +{ + cl_char CL_ALIGNED(8) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w; }; + __extension__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_char4 lo, hi; }; +#endif +#if defined( __CL_CHAR2__) + __cl_char2 v2[4]; +#endif +#if defined( __CL_CHAR4__) + __cl_char4 v4[2]; +#endif +#if defined( __CL_CHAR8__ ) + __cl_char8 v8; +#endif +}cl_char8; + +typedef union +{ + cl_char CL_ALIGNED(16) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_char8 lo, hi; }; +#endif +#if defined( __CL_CHAR2__) + __cl_char2 v2[8]; +#endif +#if defined( __CL_CHAR4__) + __cl_char4 v4[4]; +#endif +#if defined( __CL_CHAR8__ ) + __cl_char8 v8[2]; +#endif +#if defined( __CL_CHAR16__ ) + __cl_char16 v16; +#endif +}cl_char16; + + +/* ---- cl_ucharn ---- */ +typedef union +{ + cl_uchar CL_ALIGNED(2) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y; }; + __extension__ struct{ cl_uchar s0, s1; }; + __extension__ struct{ cl_uchar lo, hi; }; +#endif +#if defined( __cl_uchar2__) + __cl_uchar2 v2; +#endif +}cl_uchar2; + +typedef union +{ + cl_uchar CL_ALIGNED(4) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3; }; + __extension__ struct{ cl_uchar2 lo, hi; }; +#endif +#if defined( __CL_UCHAR2__) + __cl_uchar2 v2[2]; +#endif +#if defined( __CL_UCHAR4__) + __cl_uchar4 v4; +#endif +}cl_uchar4; + +/* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ +typedef cl_uchar4 cl_uchar3; + +typedef union +{ + cl_uchar CL_ALIGNED(8) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_uchar4 lo, hi; }; +#endif +#if defined( __CL_UCHAR2__) + __cl_uchar2 v2[4]; +#endif +#if defined( __CL_UCHAR4__) + __cl_uchar4 v4[2]; +#endif +#if defined( __CL_UCHAR8__ ) + __cl_uchar8 v8; +#endif +}cl_uchar8; + +typedef union +{ + cl_uchar CL_ALIGNED(16) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_uchar8 lo, hi; }; +#endif +#if defined( __CL_UCHAR2__) + __cl_uchar2 v2[8]; +#endif +#if defined( __CL_UCHAR4__) + __cl_uchar4 v4[4]; +#endif +#if defined( __CL_UCHAR8__ ) + __cl_uchar8 v8[2]; +#endif +#if defined( __CL_UCHAR16__ ) + __cl_uchar16 v16; +#endif +}cl_uchar16; + + +/* ---- cl_shortn ---- */ +typedef union +{ + cl_short CL_ALIGNED(4) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y; }; + __extension__ struct{ cl_short s0, s1; }; + __extension__ struct{ cl_short lo, hi; }; +#endif +#if defined( __CL_SHORT2__) + __cl_short2 v2; +#endif +}cl_short2; + +typedef union +{ + cl_short CL_ALIGNED(8) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w; }; + __extension__ struct{ cl_short s0, s1, s2, s3; }; + __extension__ struct{ cl_short2 lo, hi; }; +#endif +#if defined( __CL_SHORT2__) + __cl_short2 v2[2]; +#endif +#if defined( __CL_SHORT4__) + __cl_short4 v4; +#endif +}cl_short4; + +/* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ +typedef cl_short4 cl_short3; + +typedef union +{ + cl_short CL_ALIGNED(16) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w; }; + __extension__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_short4 lo, hi; }; +#endif +#if defined( __CL_SHORT2__) + __cl_short2 v2[4]; +#endif +#if defined( __CL_SHORT4__) + __cl_short4 v4[2]; +#endif +#if defined( __CL_SHORT8__ ) + __cl_short8 v8; +#endif +}cl_short8; + +typedef union +{ + cl_short CL_ALIGNED(32) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_short8 lo, hi; }; +#endif +#if defined( __CL_SHORT2__) + __cl_short2 v2[8]; +#endif +#if defined( __CL_SHORT4__) + __cl_short4 v4[4]; +#endif +#if defined( __CL_SHORT8__ ) + __cl_short8 v8[2]; +#endif +#if defined( __CL_SHORT16__ ) + __cl_short16 v16; +#endif +}cl_short16; + + +/* ---- cl_ushortn ---- */ +typedef union +{ + cl_ushort CL_ALIGNED(4) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y; }; + __extension__ struct{ cl_ushort s0, s1; }; + __extension__ struct{ cl_ushort lo, hi; }; +#endif +#if defined( __CL_USHORT2__) + __cl_ushort2 v2; +#endif +}cl_ushort2; + +typedef union +{ + cl_ushort CL_ALIGNED(8) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3; }; + __extension__ struct{ cl_ushort2 lo, hi; }; +#endif +#if defined( __CL_USHORT2__) + __cl_ushort2 v2[2]; +#endif +#if defined( __CL_USHORT4__) + __cl_ushort4 v4; +#endif +}cl_ushort4; + +/* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ +typedef cl_ushort4 cl_ushort3; + +typedef union +{ + cl_ushort CL_ALIGNED(16) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_ushort4 lo, hi; }; +#endif +#if defined( __CL_USHORT2__) + __cl_ushort2 v2[4]; +#endif +#if defined( __CL_USHORT4__) + __cl_ushort4 v4[2]; +#endif +#if defined( __CL_USHORT8__ ) + __cl_ushort8 v8; +#endif +}cl_ushort8; + +typedef union +{ + cl_ushort CL_ALIGNED(32) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_ushort8 lo, hi; }; +#endif +#if defined( __CL_USHORT2__) + __cl_ushort2 v2[8]; +#endif +#if defined( __CL_USHORT4__) + __cl_ushort4 v4[4]; +#endif +#if defined( __CL_USHORT8__ ) + __cl_ushort8 v8[2]; +#endif +#if defined( __CL_USHORT16__ ) + __cl_ushort16 v16; +#endif +}cl_ushort16; + +/* ---- cl_intn ---- */ +typedef union +{ + cl_int CL_ALIGNED(8) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y; }; + __extension__ struct{ cl_int s0, s1; }; + __extension__ struct{ cl_int lo, hi; }; +#endif +#if defined( __CL_INT2__) + __cl_int2 v2; +#endif +}cl_int2; + +typedef union +{ + cl_int CL_ALIGNED(16) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w; }; + __extension__ struct{ cl_int s0, s1, s2, s3; }; + __extension__ struct{ cl_int2 lo, hi; }; +#endif +#if defined( __CL_INT2__) + __cl_int2 v2[2]; +#endif +#if defined( __CL_INT4__) + __cl_int4 v4; +#endif +}cl_int4; + +/* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ +typedef cl_int4 cl_int3; + +typedef union +{ + cl_int CL_ALIGNED(32) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w; }; + __extension__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_int4 lo, hi; }; +#endif +#if defined( __CL_INT2__) + __cl_int2 v2[4]; +#endif +#if defined( __CL_INT4__) + __cl_int4 v4[2]; +#endif +#if defined( __CL_INT8__ ) + __cl_int8 v8; +#endif +}cl_int8; + +typedef union +{ + cl_int CL_ALIGNED(64) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_int8 lo, hi; }; +#endif +#if defined( __CL_INT2__) + __cl_int2 v2[8]; +#endif +#if defined( __CL_INT4__) + __cl_int4 v4[4]; +#endif +#if defined( __CL_INT8__ ) + __cl_int8 v8[2]; +#endif +#if defined( __CL_INT16__ ) + __cl_int16 v16; +#endif +}cl_int16; + + +/* ---- cl_uintn ---- */ +typedef union +{ + cl_uint CL_ALIGNED(8) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y; }; + __extension__ struct{ cl_uint s0, s1; }; + __extension__ struct{ cl_uint lo, hi; }; +#endif +#if defined( __CL_UINT2__) + __cl_uint2 v2; +#endif +}cl_uint2; + +typedef union +{ + cl_uint CL_ALIGNED(16) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w; }; + __extension__ struct{ cl_uint s0, s1, s2, s3; }; + __extension__ struct{ cl_uint2 lo, hi; }; +#endif +#if defined( __CL_UINT2__) + __cl_uint2 v2[2]; +#endif +#if defined( __CL_UINT4__) + __cl_uint4 v4; +#endif +}cl_uint4; + +/* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ +typedef cl_uint4 cl_uint3; + +typedef union +{ + cl_uint CL_ALIGNED(32) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w; }; + __extension__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_uint4 lo, hi; }; +#endif +#if defined( __CL_UINT2__) + __cl_uint2 v2[4]; +#endif +#if defined( __CL_UINT4__) + __cl_uint4 v4[2]; +#endif +#if defined( __CL_UINT8__ ) + __cl_uint8 v8; +#endif +}cl_uint8; + +typedef union +{ + cl_uint CL_ALIGNED(64) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_uint8 lo, hi; }; +#endif +#if defined( __CL_UINT2__) + __cl_uint2 v2[8]; +#endif +#if defined( __CL_UINT4__) + __cl_uint4 v4[4]; +#endif +#if defined( __CL_UINT8__ ) + __cl_uint8 v8[2]; +#endif +#if defined( __CL_UINT16__ ) + __cl_uint16 v16; +#endif +}cl_uint16; + +/* ---- cl_longn ---- */ +typedef union +{ + cl_long CL_ALIGNED(16) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y; }; + __extension__ struct{ cl_long s0, s1; }; + __extension__ struct{ cl_long lo, hi; }; +#endif +#if defined( __CL_LONG2__) + __cl_long2 v2; +#endif +}cl_long2; + +typedef union +{ + cl_long CL_ALIGNED(32) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w; }; + __extension__ struct{ cl_long s0, s1, s2, s3; }; + __extension__ struct{ cl_long2 lo, hi; }; +#endif +#if defined( __CL_LONG2__) + __cl_long2 v2[2]; +#endif +#if defined( __CL_LONG4__) + __cl_long4 v4; +#endif +}cl_long4; + +/* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ +typedef cl_long4 cl_long3; + +typedef union +{ + cl_long CL_ALIGNED(64) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w; }; + __extension__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_long4 lo, hi; }; +#endif +#if defined( __CL_LONG2__) + __cl_long2 v2[4]; +#endif +#if defined( __CL_LONG4__) + __cl_long4 v4[2]; +#endif +#if defined( __CL_LONG8__ ) + __cl_long8 v8; +#endif +}cl_long8; + +typedef union +{ + cl_long CL_ALIGNED(128) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_long8 lo, hi; }; +#endif +#if defined( __CL_LONG2__) + __cl_long2 v2[8]; +#endif +#if defined( __CL_LONG4__) + __cl_long4 v4[4]; +#endif +#if defined( __CL_LONG8__ ) + __cl_long8 v8[2]; +#endif +#if defined( __CL_LONG16__ ) + __cl_long16 v16; +#endif +}cl_long16; + + +/* ---- cl_ulongn ---- */ +typedef union +{ + cl_ulong CL_ALIGNED(16) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y; }; + __extension__ struct{ cl_ulong s0, s1; }; + __extension__ struct{ cl_ulong lo, hi; }; +#endif +#if defined( __CL_ULONG2__) + __cl_ulong2 v2; +#endif +}cl_ulong2; + +typedef union +{ + cl_ulong CL_ALIGNED(32) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3; }; + __extension__ struct{ cl_ulong2 lo, hi; }; +#endif +#if defined( __CL_ULONG2__) + __cl_ulong2 v2[2]; +#endif +#if defined( __CL_ULONG4__) + __cl_ulong4 v4; +#endif +}cl_ulong4; + +/* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ +typedef cl_ulong4 cl_ulong3; + +typedef union +{ + cl_ulong CL_ALIGNED(64) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_ulong4 lo, hi; }; +#endif +#if defined( __CL_ULONG2__) + __cl_ulong2 v2[4]; +#endif +#if defined( __CL_ULONG4__) + __cl_ulong4 v4[2]; +#endif +#if defined( __CL_ULONG8__ ) + __cl_ulong8 v8; +#endif +}cl_ulong8; + +typedef union +{ + cl_ulong CL_ALIGNED(128) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_ulong8 lo, hi; }; +#endif +#if defined( __CL_ULONG2__) + __cl_ulong2 v2[8]; +#endif +#if defined( __CL_ULONG4__) + __cl_ulong4 v4[4]; +#endif +#if defined( __CL_ULONG8__ ) + __cl_ulong8 v8[2]; +#endif +#if defined( __CL_ULONG16__ ) + __cl_ulong16 v16; +#endif +}cl_ulong16; + + +/* --- cl_floatn ---- */ + +typedef union +{ + cl_float CL_ALIGNED(8) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y; }; + __extension__ struct{ cl_float s0, s1; }; + __extension__ struct{ cl_float lo, hi; }; +#endif +#if defined( __CL_FLOAT2__) + __cl_float2 v2; +#endif +}cl_float2; + +typedef union +{ + cl_float CL_ALIGNED(16) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w; }; + __extension__ struct{ cl_float s0, s1, s2, s3; }; + __extension__ struct{ cl_float2 lo, hi; }; +#endif +#if defined( __CL_FLOAT2__) + __cl_float2 v2[2]; +#endif +#if defined( __CL_FLOAT4__) + __cl_float4 v4; +#endif +}cl_float4; + +/* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ +typedef cl_float4 cl_float3; + +typedef union +{ + cl_float CL_ALIGNED(32) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w; }; + __extension__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_float4 lo, hi; }; +#endif +#if defined( __CL_FLOAT2__) + __cl_float2 v2[4]; +#endif +#if defined( __CL_FLOAT4__) + __cl_float4 v4[2]; +#endif +#if defined( __CL_FLOAT8__ ) + __cl_float8 v8; +#endif +}cl_float8; + +typedef union +{ + cl_float CL_ALIGNED(64) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_float8 lo, hi; }; +#endif +#if defined( __CL_FLOAT2__) + __cl_float2 v2[8]; +#endif +#if defined( __CL_FLOAT4__) + __cl_float4 v4[4]; +#endif +#if defined( __CL_FLOAT8__ ) + __cl_float8 v8[2]; +#endif +#if defined( __CL_FLOAT16__ ) + __cl_float16 v16; +#endif +}cl_float16; + +/* --- cl_doublen ---- */ + +typedef union +{ + cl_double CL_ALIGNED(16) s[2]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y; }; + __extension__ struct{ cl_double s0, s1; }; + __extension__ struct{ cl_double lo, hi; }; +#endif +#if defined( __CL_DOUBLE2__) + __cl_double2 v2; +#endif +}cl_double2; + +typedef union +{ + cl_double CL_ALIGNED(32) s[4]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w; }; + __extension__ struct{ cl_double s0, s1, s2, s3; }; + __extension__ struct{ cl_double2 lo, hi; }; +#endif +#if defined( __CL_DOUBLE2__) + __cl_double2 v2[2]; +#endif +#if defined( __CL_DOUBLE4__) + __cl_double4 v4; +#endif +}cl_double4; + +/* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ +typedef cl_double4 cl_double3; + +typedef union +{ + cl_double CL_ALIGNED(64) s[8]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w; }; + __extension__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ struct{ cl_double4 lo, hi; }; +#endif +#if defined( __CL_DOUBLE2__) + __cl_double2 v2[4]; +#endif +#if defined( __CL_DOUBLE4__) + __cl_double4 v4[2]; +#endif +#if defined( __CL_DOUBLE8__ ) + __cl_double8 v8; +#endif +}cl_double8; + +typedef union +{ + cl_double CL_ALIGNED(128) s[16]; +#if (defined( __GNUC__) || defined( __IBMC__ )) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ struct{ cl_double8 lo, hi; }; +#endif +#if defined( __CL_DOUBLE2__) + __cl_double2 v2[8]; +#endif +#if defined( __CL_DOUBLE4__) + __cl_double4 v4[4]; +#endif +#if defined( __CL_DOUBLE8__ ) + __cl_double8 v8[2]; +#endif +#if defined( __CL_DOUBLE16__ ) + __cl_double16 v16; +#endif +}cl_double16; + +/* Macro to facilitate debugging + * Usage: + * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. + * The first line ends with: CL_PROGRAM_STRING_BEGIN \" + * Each line thereafter of OpenCL C source must end with: \n\ + * The last line ends in "; + * + * Example: + * + * const char *my_program = CL_PROGRAM_STRING_BEGIN "\ + * kernel void foo( int a, float * b ) \n\ + * { \n\ + * // my comment \n\ + * *b[ get_global_id(0)] = a; \n\ + * } \n\ + * "; + * + * This should correctly set up the line, (column) and file information for your source + * string so you can do source level debugging. + */ +#define __CL_STRINGIFY( _x ) # _x +#define _CL_STRINGIFY( _x ) __CL_STRINGIFY( _x ) +#define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" + +#ifdef __cplusplus +} +#endif + +#endif /* __CL_PLATFORM_H */ diff --git a/ext/cl-runtime/CL/opencl.h b/ext/cl-runtime/CL/opencl.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/opencl.h @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */ + +#ifndef __OPENCL_H +#define __OPENCL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __APPLE__ + +#include +#include +#include +#include + +#else + +#include +#include +#include +#include + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_H */ + diff --git a/ext/cl-runtime/Makefile b/ext/cl-runtime/Makefile new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/Makefile @@ -0,0 +1,31 @@ +# +# Copyright © 1997,2000 Paul D. Smith +# Verbatim copying and distribution is permitted in any medium, provided this +# notice is preserved. +# See http://make.paulandlesley.org/multi-arch.html#advanced +# + +TGTDIRS = 64b 32b dbg64b dbg32b + +all: $(TGTDIRS) + +NEWGOALS = $(filter-out $(TGTDIRS), $(MAKECMDGOALS)) + +.SUFFIXES: + +MAKETARGET = $(MAKE) --no-print-directory -C $@ -f ../lib.mk $(NEWGOALS) + +.PHONY: $(TGTDIRS) +$(TGTDIRS): + +@echo "Building in $@" + +@[ -d $@ ] || mkdir -p $@ + +@$(MAKETARGET) + +Makefile : ; +%.mk :: ; + +% :: $(TGTDIRS) ; + +.PHONY: clean +clean: + rm -rf $(TGTDIRS) diff --git a/ext/cl-runtime/SConscript b/ext/cl-runtime/SConscript new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/SConscript @@ -0,0 +1,39 @@ +# -*- mode:python -*- + +# +# Copyright (c) 2015 Advanced Micro Devices, Inc. +# All rights reserved. +# +# For use for simulation and test purposes only +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Author: Marc Orr + +Import('main') + +main.Prepend(CPPPATH=Dir('.')) diff --git a/ext/cl-runtime/cl_command_queue.h b/ext/cl-runtime/cl_command_queue.h new file mode 100644 --- /dev/null +++ b/ext/cl-runtime/cl_command_queue.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2011-2015 Advanced Micro Devices, Inc. + * All rights reserved. + * + * For use for simulation and test purposes only + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Marc Orr + */ + +#ifndef __CL_COMMAND_QUEUE_HH__ +#define __CL_COMMAND_QUEUE_HH__ + +#include +#include + +class _cl_command_queue { + public: + _cl_command_queue() + { + numDispLeft = (volatile uint32_t*)calloc(1, sizeof(uint32_t)); + *numDispLeft = 0; + } + + cl_uint ID; + volatile uint32_t *numDispLeft; +}; + +#endif // __CL_COMMAND_QUEUE_HH__ # Node ID b2b56ddfcd3900ee56b12a2f90d37d96dfee024c # Parent bb9212a4b8d11fc866310b357ec366e9b2b14503 diff --git a/SConstruct b/SConstruct --- a/SConstruct +++ b/SConstruct @@ -1208,6 +1208,10 @@ main.SConscript('ext/nomali/SConscript', variant_dir = joinpath(build_root, 'nomali')) +# make cl-runtime headers available to gpu code. +main.SConscript('ext/cl-runtime/SConscript', + variant_dir = joinpath(build_root, 'cl-runtime')) + ################################################### # # This function is used to set up a directory with switching headers diff --git a/ext/cl-runtime/CL/cl.h b/ext/cl-runtime/CL/cl.h new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl.h @@ -0,0 +1,1239 @@ +/******************************************************************************* + * Copyright (c) 2011 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +#ifndef __OPENCL_CL_H +#define __OPENCL_CL_H + +#ifdef __APPLE__ +#include +#else +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************/ + +typedef struct _cl_platform_id * cl_platform_id; +typedef struct _cl_device_id * cl_device_id; +typedef struct _cl_context * cl_context; +typedef struct _cl_command_queue * cl_command_queue; +typedef struct _cl_mem * cl_mem; +typedef struct _cl_program * cl_program; +typedef struct _cl_kernel * cl_kernel; +typedef struct _cl_event * cl_event; +typedef struct _cl_sampler * cl_sampler; + +typedef cl_uint cl_bool; /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ +typedef cl_ulong cl_bitfield; +typedef cl_bitfield cl_device_type; +typedef cl_uint cl_platform_info; +typedef cl_uint cl_device_info; +typedef cl_bitfield cl_device_fp_config; +typedef cl_uint cl_device_mem_cache_type; +typedef cl_uint cl_device_local_mem_type; +typedef cl_bitfield cl_device_exec_capabilities; +typedef cl_bitfield cl_command_queue_properties; +typedef intptr_t cl_device_partition_property; +typedef cl_bitfield cl_device_affinity_domain; + +typedef intptr_t cl_context_properties; +typedef cl_uint cl_context_info; +typedef cl_uint cl_command_queue_info; +typedef cl_uint cl_channel_order; +typedef cl_uint cl_channel_type; +typedef cl_bitfield cl_mem_flags; +typedef cl_uint cl_mem_object_type; +typedef cl_uint cl_mem_info; +typedef cl_bitfield cl_mem_migration_flags; +typedef cl_uint cl_image_info; +typedef cl_uint cl_buffer_create_type; +typedef cl_uint cl_addressing_mode; +typedef cl_uint cl_filter_mode; +typedef cl_uint cl_sampler_info; +typedef cl_bitfield cl_map_flags; +typedef cl_uint cl_program_info; +typedef cl_uint cl_program_build_info; +typedef cl_uint cl_program_binary_type; +typedef cl_int cl_build_status; +typedef cl_uint cl_kernel_info; +typedef cl_uint cl_kernel_arg_info; +typedef cl_uint cl_kernel_arg_address_qualifier; +typedef cl_uint cl_kernel_arg_access_qualifier; +typedef cl_bitfield cl_kernel_arg_type_qualifier; +typedef cl_uint cl_kernel_work_group_info; +typedef cl_uint cl_event_info; +typedef cl_uint cl_command_type; +typedef cl_uint cl_profiling_info; + + +typedef struct _cl_image_format { + cl_channel_order image_channel_order; + cl_channel_type image_channel_data_type; +} cl_image_format; + +typedef struct _cl_image_desc { + cl_mem_object_type image_type; + size_t image_width; + size_t image_height; + size_t image_depth; + size_t image_array_size; + size_t image_row_pitch; + size_t image_slice_pitch; + cl_uint num_mip_levels; + cl_uint num_samples; + cl_mem buffer; +} cl_image_desc; + +typedef struct _cl_buffer_region { + size_t origin; + size_t size; +} cl_buffer_region; + + +/******************************************************************************/ + +/* Error Codes */ +#define CL_SUCCESS 0 +#define CL_DEVICE_NOT_FOUND -1 +#define CL_DEVICE_NOT_AVAILABLE -2 +#define CL_COMPILER_NOT_AVAILABLE -3 +#define CL_MEM_OBJECT_ALLOCATION_FAILURE -4 +#define CL_OUT_OF_RESOURCES -5 +#define CL_OUT_OF_HOST_MEMORY -6 +#define CL_PROFILING_INFO_NOT_AVAILABLE -7 +#define CL_MEM_COPY_OVERLAP -8 +#define CL_IMAGE_FORMAT_MISMATCH -9 +#define CL_IMAGE_FORMAT_NOT_SUPPORTED -10 +#define CL_BUILD_PROGRAM_FAILURE -11 +#define CL_MAP_FAILURE -12 +#define CL_MISALIGNED_SUB_BUFFER_OFFSET -13 +#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14 +#define CL_COMPILE_PROGRAM_FAILURE -15 +#define CL_LINKER_NOT_AVAILABLE -16 +#define CL_LINK_PROGRAM_FAILURE -17 +#define CL_DEVICE_PARTITION_FAILED -18 +#define CL_KERNEL_ARG_INFO_NOT_AVAILABLE -19 + +#define CL_INVALID_VALUE -30 +#define CL_INVALID_DEVICE_TYPE -31 +#define CL_INVALID_PLATFORM -32 +#define CL_INVALID_DEVICE -33 +#define CL_INVALID_CONTEXT -34 +#define CL_INVALID_QUEUE_PROPERTIES -35 +#define CL_INVALID_COMMAND_QUEUE -36 +#define CL_INVALID_HOST_PTR -37 +#define CL_INVALID_MEM_OBJECT -38 +#define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39 +#define CL_INVALID_IMAGE_SIZE -40 +#define CL_INVALID_SAMPLER -41 +#define CL_INVALID_BINARY -42 +#define CL_INVALID_BUILD_OPTIONS -43 +#define CL_INVALID_PROGRAM -44 +#define CL_INVALID_PROGRAM_EXECUTABLE -45 +#define CL_INVALID_KERNEL_NAME -46 +#define CL_INVALID_KERNEL_DEFINITION -47 +#define CL_INVALID_KERNEL -48 +#define CL_INVALID_ARG_INDEX -49 +#define CL_INVALID_ARG_VALUE -50 +#define CL_INVALID_ARG_SIZE -51 +#define CL_INVALID_KERNEL_ARGS -52 +#define CL_INVALID_WORK_DIMENSION -53 +#define CL_INVALID_WORK_GROUP_SIZE -54 +#define CL_INVALID_WORK_ITEM_SIZE -55 +#define CL_INVALID_GLOBAL_OFFSET -56 +#define CL_INVALID_EVENT_WAIT_LIST -57 +#define CL_INVALID_EVENT -58 +#define CL_INVALID_OPERATION -59 +#define CL_INVALID_GL_OBJECT -60 +#define CL_INVALID_BUFFER_SIZE -61 +#define CL_INVALID_MIP_LEVEL -62 +#define CL_INVALID_GLOBAL_WORK_SIZE -63 +#define CL_INVALID_PROPERTY -64 +#define CL_INVALID_IMAGE_DESCRIPTOR -65 +#define CL_INVALID_COMPILER_OPTIONS -66 +#define CL_INVALID_LINKER_OPTIONS -67 +#define CL_INVALID_DEVICE_PARTITION_COUNT -68 + +/* OpenCL Version */ +#define CL_VERSION_1_0 1 +#define CL_VERSION_1_1 1 +#define CL_VERSION_1_2 1 + +/* cl_bool */ +#define CL_FALSE 0 +#define CL_TRUE 1 +#define CL_BLOCKING CL_TRUE +#define CL_NON_BLOCKING CL_FALSE + +/* cl_platform_info */ +#define CL_PLATFORM_PROFILE 0x0900 +#define CL_PLATFORM_VERSION 0x0901 +#define CL_PLATFORM_NAME 0x0902 +#define CL_PLATFORM_VENDOR 0x0903 +#define CL_PLATFORM_EXTENSIONS 0x0904 + +/* cl_device_type - bitfield */ +#define CL_DEVICE_TYPE_DEFAULT (1 << 0) +#define CL_DEVICE_TYPE_CPU (1 << 1) +#define CL_DEVICE_TYPE_GPU (1 << 2) +#define CL_DEVICE_TYPE_ACCELERATOR (1 << 3) +#define CL_DEVICE_TYPE_CUSTOM (1 << 4) +#define CL_DEVICE_TYPE_ALL 0xFFFFFFFF + +/* cl_device_info */ +#define CL_DEVICE_TYPE 0x1000 +#define CL_DEVICE_VENDOR_ID 0x1001 +#define CL_DEVICE_MAX_COMPUTE_UNITS 0x1002 +#define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS 0x1003 +#define CL_DEVICE_MAX_WORK_GROUP_SIZE 0x1004 +#define CL_DEVICE_MAX_WORK_ITEM_SIZES 0x1005 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B +#define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C +#define CL_DEVICE_ADDRESS_BITS 0x100D +#define CL_DEVICE_MAX_READ_IMAGE_ARGS 0x100E +#define CL_DEVICE_MAX_WRITE_IMAGE_ARGS 0x100F +#define CL_DEVICE_MAX_MEM_ALLOC_SIZE 0x1010 +#define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011 +#define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012 +#define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013 +#define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014 +#define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015 +#define CL_DEVICE_IMAGE_SUPPORT 0x1016 +#define CL_DEVICE_MAX_PARAMETER_SIZE 0x1017 +#define CL_DEVICE_MAX_SAMPLERS 0x1018 +#define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019 +#define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A +#define CL_DEVICE_SINGLE_FP_CONFIG 0x101B +#define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C +#define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 0x101D +#define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E +#define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F +#define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE 0x1020 +#define CL_DEVICE_MAX_CONSTANT_ARGS 0x1021 +#define CL_DEVICE_LOCAL_MEM_TYPE 0x1022 +#define CL_DEVICE_LOCAL_MEM_SIZE 0x1023 +#define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024 +#define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025 +#define CL_DEVICE_ENDIAN_LITTLE 0x1026 +#define CL_DEVICE_AVAILABLE 0x1027 +#define CL_DEVICE_COMPILER_AVAILABLE 0x1028 +#define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029 +#define CL_DEVICE_QUEUE_PROPERTIES 0x102A +#define CL_DEVICE_NAME 0x102B +#define CL_DEVICE_VENDOR 0x102C +#define CL_DRIVER_VERSION 0x102D +#define CL_DEVICE_PROFILE 0x102E +#define CL_DEVICE_VERSION 0x102F +#define CL_DEVICE_EXTENSIONS 0x1030 +#define CL_DEVICE_PLATFORM 0x1031 +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 +/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */ +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034 +#define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 0x1036 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 0x1037 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 0x1038 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 0x1039 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT 0x103A +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE 0x103B +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF 0x103C +#define CL_DEVICE_OPENCL_C_VERSION 0x103D +#define CL_DEVICE_LINKER_AVAILABLE 0x103E +#define CL_DEVICE_BUILT_IN_KERNELS 0x103F +#define CL_DEVICE_IMAGE_MAX_BUFFER_SIZE 0x1040 +#define CL_DEVICE_IMAGE_MAX_ARRAY_SIZE 0x1041 +#define CL_DEVICE_PARENT_DEVICE 0x1042 +#define CL_DEVICE_PARTITION_MAX_SUB_DEVICES 0x1043 +#define CL_DEVICE_PARTITION_PROPERTIES 0x1044 +#define CL_DEVICE_PARTITION_AFFINITY_DOMAIN 0x1045 +#define CL_DEVICE_PARTITION_TYPE 0x1046 +#define CL_DEVICE_REFERENCE_COUNT 0x1047 +#define CL_DEVICE_PREFERRED_INTEROP_USER_SYNC 0x1048 +#define CL_DEVICE_PRINTF_BUFFER_SIZE 0x1049 + +/* cl_device_fp_config - bitfield */ +#define CL_FP_DENORM (1 << 0) +#define CL_FP_INF_NAN (1 << 1) +#define CL_FP_ROUND_TO_NEAREST (1 << 2) +#define CL_FP_ROUND_TO_ZERO (1 << 3) +#define CL_FP_ROUND_TO_INF (1 << 4) +#define CL_FP_FMA (1 << 5) +#define CL_FP_SOFT_FLOAT (1 << 6) +#define CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT (1 << 7) + +/* cl_device_mem_cache_type */ +#define CL_NONE 0x0 +#define CL_READ_ONLY_CACHE 0x1 +#define CL_READ_WRITE_CACHE 0x2 + +/* cl_device_local_mem_type */ +#define CL_LOCAL 0x1 +#define CL_GLOBAL 0x2 + +/* cl_device_exec_capabilities - bitfield */ +#define CL_EXEC_KERNEL (1 << 0) +#define CL_EXEC_NATIVE_KERNEL (1 << 1) + +/* cl_command_queue_properties - bitfield */ +#define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE (1 << 0) +#define CL_QUEUE_PROFILING_ENABLE (1 << 1) + +/* cl_context_info */ +#define CL_CONTEXT_REFERENCE_COUNT 0x1080 +#define CL_CONTEXT_DEVICES 0x1081 +#define CL_CONTEXT_PROPERTIES 0x1082 +#define CL_CONTEXT_NUM_DEVICES 0x1083 + +/* cl_context_properties */ +#define CL_CONTEXT_PLATFORM 0x1084 +#define CL_CONTEXT_INTEROP_USER_SYNC 0x1085 + +/* cl_device_partition_property */ +#define CL_DEVICE_PARTITION_EQUALLY 0x1086 +#define CL_DEVICE_PARTITION_BY_COUNTS 0x1087 +#define CL_DEVICE_PARTITION_BY_COUNTS_LIST_END 0x0 +#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN 0x1088 + +/* cl_device_affinity_domain */ +#define CL_DEVICE_AFFINITY_DOMAIN_NUMA (1 << 0) +#define CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE (1 << 1) +#define CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE (1 << 2) +#define CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE (1 << 3) +#define CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE (1 << 4) +#define CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE (1 << 5) + +/* cl_command_queue_info */ +#define CL_QUEUE_CONTEXT 0x1090 +#define CL_QUEUE_DEVICE 0x1091 +#define CL_QUEUE_REFERENCE_COUNT 0x1092 +#define CL_QUEUE_PROPERTIES 0x1093 + +/* cl_mem_flags - bitfield */ +#define CL_MEM_READ_WRITE (1 << 0) +#define CL_MEM_WRITE_ONLY (1 << 1) +#define CL_MEM_READ_ONLY (1 << 2) +#define CL_MEM_USE_HOST_PTR (1 << 3) +#define CL_MEM_ALLOC_HOST_PTR (1 << 4) +#define CL_MEM_COPY_HOST_PTR (1 << 5) +// reserved (1 << 6) +#define CL_MEM_HOST_WRITE_ONLY (1 << 7) +#define CL_MEM_HOST_READ_ONLY (1 << 8) +#define CL_MEM_HOST_NO_ACCESS (1 << 9) + +/* cl_mem_migration_flags - bitfield */ +#define CL_MIGRATE_MEM_OBJECT_HOST (1 << 0) +#define CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED (1 << 1) + +/* cl_channel_order */ +#define CL_R 0x10B0 +#define CL_A 0x10B1 +#define CL_RG 0x10B2 +#define CL_RA 0x10B3 +#define CL_RGB 0x10B4 +#define CL_RGBA 0x10B5 +#define CL_BGRA 0x10B6 +#define CL_ARGB 0x10B7 +#define CL_INTENSITY 0x10B8 +#define CL_LUMINANCE 0x10B9 +#define CL_Rx 0x10BA +#define CL_RGx 0x10BB +#define CL_RGBx 0x10BC + +/* cl_channel_type */ +#define CL_SNORM_INT8 0x10D0 +#define CL_SNORM_INT16 0x10D1 +#define CL_UNORM_INT8 0x10D2 +#define CL_UNORM_INT16 0x10D3 +#define CL_UNORM_SHORT_565 0x10D4 +#define CL_UNORM_SHORT_555 0x10D5 +#define CL_UNORM_INT_101010 0x10D6 +#define CL_SIGNED_INT8 0x10D7 +#define CL_SIGNED_INT16 0x10D8 +#define CL_SIGNED_INT32 0x10D9 +#define CL_UNSIGNED_INT8 0x10DA +#define CL_UNSIGNED_INT16 0x10DB +#define CL_UNSIGNED_INT32 0x10DC +#define CL_HALF_FLOAT 0x10DD +#define CL_FLOAT 0x10DE + +/* cl_mem_object_type */ +#define CL_MEM_OBJECT_BUFFER 0x10F0 +#define CL_MEM_OBJECT_IMAGE2D 0x10F1 +#define CL_MEM_OBJECT_IMAGE3D 0x10F2 +#define CL_MEM_OBJECT_IMAGE2D_ARRAY 0x10F3 +#define CL_MEM_OBJECT_IMAGE1D 0x10F4 +#define CL_MEM_OBJECT_IMAGE1D_ARRAY 0x10F5 +#define CL_MEM_OBJECT_IMAGE1D_BUFFER 0x10F6 + +/* cl_mem_info */ +#define CL_MEM_TYPE 0x1100 +#define CL_MEM_FLAGS 0x1101 +#define CL_MEM_SIZE 0x1102 +#define CL_MEM_HOST_PTR 0x1103 +#define CL_MEM_MAP_COUNT 0x1104 +#define CL_MEM_REFERENCE_COUNT 0x1105 +#define CL_MEM_CONTEXT 0x1106 +#define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107 +#define CL_MEM_OFFSET 0x1108 + +/* cl_image_info */ +#define CL_IMAGE_FORMAT 0x1110 +#define CL_IMAGE_ELEMENT_SIZE 0x1111 +#define CL_IMAGE_ROW_PITCH 0x1112 +#define CL_IMAGE_SLICE_PITCH 0x1113 +#define CL_IMAGE_WIDTH 0x1114 +#define CL_IMAGE_HEIGHT 0x1115 +#define CL_IMAGE_DEPTH 0x1116 +#define CL_IMAGE_ARRAY_SIZE 0x1117 +#define CL_IMAGE_BUFFER 0x1118 +#define CL_IMAGE_NUM_MIP_LEVELS 0x1119 +#define CL_IMAGE_NUM_SAMPLES 0x111A + +/* cl_addressing_mode */ +#define CL_ADDRESS_NONE 0x1130 +#define CL_ADDRESS_CLAMP_TO_EDGE 0x1131 +#define CL_ADDRESS_CLAMP 0x1132 +#define CL_ADDRESS_REPEAT 0x1133 +#define CL_ADDRESS_MIRRORED_REPEAT 0x1134 + +/* cl_filter_mode */ +#define CL_FILTER_NEAREST 0x1140 +#define CL_FILTER_LINEAR 0x1141 + +/* cl_sampler_info */ +#define CL_SAMPLER_REFERENCE_COUNT 0x1150 +#define CL_SAMPLER_CONTEXT 0x1151 +#define CL_SAMPLER_NORMALIZED_COORDS 0x1152 +#define CL_SAMPLER_ADDRESSING_MODE 0x1153 +#define CL_SAMPLER_FILTER_MODE 0x1154 + +/* cl_map_flags - bitfield */ +#define CL_MAP_READ (1 << 0) +#define CL_MAP_WRITE (1 << 1) +#define CL_MAP_WRITE_INVALIDATE_REGION (1 << 2) + +/* cl_program_info */ +#define CL_PROGRAM_REFERENCE_COUNT 0x1160 +#define CL_PROGRAM_CONTEXT 0x1161 +#define CL_PROGRAM_NUM_DEVICES 0x1162 +#define CL_PROGRAM_DEVICES 0x1163 +#define CL_PROGRAM_SOURCE 0x1164 +#define CL_PROGRAM_BINARY_SIZES 0x1165 +#define CL_PROGRAM_BINARIES 0x1166 +#define CL_PROGRAM_NUM_KERNELS 0x1167 +#define CL_PROGRAM_KERNEL_NAMES 0x1168 + +/* cl_program_build_info */ +#define CL_PROGRAM_BUILD_STATUS 0x1181 +#define CL_PROGRAM_BUILD_OPTIONS 0x1182 +#define CL_PROGRAM_BUILD_LOG 0x1183 +#define CL_PROGRAM_BINARY_TYPE 0x1184 + +/* cl_program_binary_type */ +#define CL_PROGRAM_BINARY_TYPE_NONE 0x0 +#define CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT 0x1 +#define CL_PROGRAM_BINARY_TYPE_LIBRARY 0x2 +#define CL_PROGRAM_BINARY_TYPE_EXECUTABLE 0x4 + +/* cl_build_status */ +#define CL_BUILD_SUCCESS 0 +#define CL_BUILD_NONE -1 +#define CL_BUILD_ERROR -2 +#define CL_BUILD_IN_PROGRESS -3 + +/* cl_kernel_info */ +#define CL_KERNEL_FUNCTION_NAME 0x1190 +#define CL_KERNEL_NUM_ARGS 0x1191 +#define CL_KERNEL_REFERENCE_COUNT 0x1192 +#define CL_KERNEL_CONTEXT 0x1193 +#define CL_KERNEL_PROGRAM 0x1194 +#define CL_KERNEL_ATTRIBUTES 0x1195 + +/* cl_kernel_arg_info */ +#define CL_KERNEL_ARG_ADDRESS_QUALIFIER 0x1196 +#define CL_KERNEL_ARG_ACCESS_QUALIFIER 0x1197 +#define CL_KERNEL_ARG_TYPE_NAME 0x1198 +#define CL_KERNEL_ARG_TYPE_QUALIFIER 0x1199 +#define CL_KERNEL_ARG_NAME 0x119A + +/* cl_kernel_arg_address_qualifier */ +#define CL_KERNEL_ARG_ADDRESS_GLOBAL 0x119B +#define CL_KERNEL_ARG_ADDRESS_LOCAL 0x119C +#define CL_KERNEL_ARG_ADDRESS_CONSTANT 0x119D +#define CL_KERNEL_ARG_ADDRESS_PRIVATE 0x119E + +/* cl_kernel_arg_access_qualifier */ +#define CL_KERNEL_ARG_ACCESS_READ_ONLY 0x11A0 +#define CL_KERNEL_ARG_ACCESS_WRITE_ONLY 0x11A1 +#define CL_KERNEL_ARG_ACCESS_READ_WRITE 0x11A2 +#define CL_KERNEL_ARG_ACCESS_NONE 0x11A3 + +/* cl_kernel_arg_type_qualifer */ +#define CL_KERNEL_ARG_TYPE_NONE 0 +#define CL_KERNEL_ARG_TYPE_CONST (1 << 0) +#define CL_KERNEL_ARG_TYPE_RESTRICT (1 << 1) +#define CL_KERNEL_ARG_TYPE_VOLATILE (1 << 2) + +/* cl_kernel_work_group_info */ +#define CL_KERNEL_WORK_GROUP_SIZE 0x11B0 +#define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1 +#define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2 +#define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3 +#define CL_KERNEL_PRIVATE_MEM_SIZE 0x11B4 +#define CL_KERNEL_GLOBAL_WORK_SIZE 0x11B5 + +/* cl_event_info */ +#define CL_EVENT_COMMAND_QUEUE 0x11D0 +#define CL_EVENT_COMMAND_TYPE 0x11D1 +#define CL_EVENT_REFERENCE_COUNT 0x11D2 +#define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3 +#define CL_EVENT_CONTEXT 0x11D4 + +/* cl_command_type */ +#define CL_COMMAND_NDRANGE_KERNEL 0x11F0 +#define CL_COMMAND_TASK 0x11F1 +#define CL_COMMAND_NATIVE_KERNEL 0x11F2 +#define CL_COMMAND_READ_BUFFER 0x11F3 +#define CL_COMMAND_WRITE_BUFFER 0x11F4 +#define CL_COMMAND_COPY_BUFFER 0x11F5 +#define CL_COMMAND_READ_IMAGE 0x11F6 +#define CL_COMMAND_WRITE_IMAGE 0x11F7 +#define CL_COMMAND_COPY_IMAGE 0x11F8 +#define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9 +#define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA +#define CL_COMMAND_MAP_BUFFER 0x11FB +#define CL_COMMAND_MAP_IMAGE 0x11FC +#define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD +#define CL_COMMAND_MARKER 0x11FE +#define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF +#define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200 +#define CL_COMMAND_READ_BUFFER_RECT 0x1201 +#define CL_COMMAND_WRITE_BUFFER_RECT 0x1202 +#define CL_COMMAND_COPY_BUFFER_RECT 0x1203 +#define CL_COMMAND_USER 0x1204 +#define CL_COMMAND_BARRIER 0x1205 +#define CL_COMMAND_MIGRATE_MEM_OBJECTS 0x1206 +#define CL_COMMAND_FILL_BUFFER 0x1207 +#define CL_COMMAND_FILL_IMAGE 0x1208 + +/* command execution status */ +#define CL_COMPLETE 0x0 +#define CL_RUNNING 0x1 +#define CL_SUBMITTED 0x2 +#define CL_QUEUED 0x3 + +/* cl_buffer_create_type */ +#define CL_BUFFER_CREATE_TYPE_REGION 0x1220 + +/* cl_profiling_info */ +#define CL_PROFILING_COMMAND_QUEUED 0x1280 +#define CL_PROFILING_COMMAND_SUBMIT 0x1281 +#define CL_PROFILING_COMMAND_START 0x1282 +#define CL_PROFILING_COMMAND_END 0x1283 + +/********************************************************************************************************/ + +/* Platform API */ +extern CL_API_ENTRY cl_int CL_API_CALL +clGetPlatformIDs(cl_uint /* num_entries */, + cl_platform_id * /* platforms */, + cl_uint * /* num_platforms */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetPlatformInfo(cl_platform_id /* platform */, + cl_platform_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Device APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceIDs(cl_platform_id /* platform */, + cl_device_type /* device_type */, + cl_uint /* num_entries */, + cl_device_id * /* devices */, + cl_uint * /* num_devices */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceInfo(cl_device_id /* device */, + cl_device_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clCreateSubDevices(cl_device_id /* in_device */, + const cl_device_partition_property * /* properties */, + cl_uint /* num_devices */, + cl_device_id * /* out_devices */, + cl_uint * /* num_devices_ret */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; + +/* Context APIs */ +extern CL_API_ENTRY cl_context CL_API_CALL +clCreateContext(const cl_context_properties * /* properties */, + cl_uint /* num_devices */, + const cl_device_id * /* devices */, + void (CL_CALLBACK * /* pfn_notify */)(const char *, const void *, size_t, void *), + void * /* user_data */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_context CL_API_CALL +clCreateContextFromType(const cl_context_properties * /* properties */, + cl_device_type /* device_type */, + void (CL_CALLBACK * /* pfn_notify*/ )(const char *, const void *, size_t, void *), + void * /* user_data */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetContextInfo(cl_context /* context */, + cl_context_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Command Queue APIs */ +extern CL_API_ENTRY cl_command_queue CL_API_CALL +clCreateCommandQueue(cl_context /* context */, + cl_device_id /* device */, + cl_command_queue_properties /* properties */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetCommandQueueInfo(cl_command_queue /* command_queue */, + cl_command_queue_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Memory Object APIs */ +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateBuffer(cl_context /* context */, + cl_mem_flags /* flags */, + size_t /* size */, + void * /* host_ptr */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateSubBuffer(cl_mem /* buffer */, + cl_mem_flags /* flags */, + cl_buffer_create_type /* buffer_create_type */, + const void * /* buffer_create_info */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateImage(cl_context /* context */, + cl_mem_flags /* flags */, + const cl_image_format * /* image_format */, + const cl_image_desc * /* image_desc */, + void * /* host_ptr */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedImageFormats(cl_context /* context */, + cl_mem_flags /* flags */, + cl_mem_object_type /* image_type */, + cl_uint /* num_entries */, + cl_image_format * /* image_formats */, + cl_uint * /* num_image_formats */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetMemObjectInfo(cl_mem /* memobj */, + cl_mem_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetImageInfo(cl_mem /* image */, + cl_image_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetMemObjectDestructorCallback( cl_mem /* memobj */, + void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), + void * /*user_data */ ) CL_API_SUFFIX__VERSION_1_1; + +/* Sampler APIs */ +extern CL_API_ENTRY cl_sampler CL_API_CALL +clCreateSampler(cl_context /* context */, + cl_bool /* normalized_coords */, + cl_addressing_mode /* addressing_mode */, + cl_filter_mode /* filter_mode */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSamplerInfo(cl_sampler /* sampler */, + cl_sampler_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Program Object APIs */ +extern CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithSource(cl_context /* context */, + cl_uint /* count */, + const char ** /* strings */, + const size_t * /* lengths */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithBinary(cl_context /* context */, + cl_uint /* num_devices */, + const cl_device_id * /* device_list */, + const size_t * /* lengths */, + const unsigned char ** /* binaries */, + cl_int * /* binary_status */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithBuiltInKernels(cl_context /* context */, + cl_uint /* num_devices */, + const cl_device_id * /* device_list */, + const char * /* kernel_names */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clBuildProgram(cl_program /* program */, + cl_uint /* num_devices */, + const cl_device_id * /* device_list */, + const char * /* options */, + void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */), + void * /* user_data */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clCompileProgram(cl_program /* program */, + cl_uint /* num_devices */, + const cl_device_id * /* device_list */, + const char * /* options */, + cl_uint /* num_input_headers */, + const cl_program * /* input_headers */, + const char ** /* header_include_names */, + void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */), + void * /* user_data */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_program CL_API_CALL +clLinkProgram(cl_context /* context */, + cl_uint /* num_devices */, + const cl_device_id * /* device_list */, + const char * /* options */, + cl_uint /* num_input_programs */, + const cl_program * /* input_programs */, + void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */), + void * /* user_data */, + cl_int * /* errcode_ret */ ) CL_API_SUFFIX__VERSION_1_2; + + +extern CL_API_ENTRY cl_int CL_API_CALL +clUnloadPlatformCompiler(cl_platform_id /* platform */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetProgramInfo(cl_program /* program */, + cl_program_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetProgramBuildInfo(cl_program /* program */, + cl_device_id /* device */, + cl_program_build_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Kernel Object APIs */ +extern CL_API_ENTRY cl_kernel CL_API_CALL +clCreateKernel(cl_program /* program */, + const char * /* kernel_name */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clCreateKernelsInProgram(cl_program /* program */, + cl_uint /* num_kernels */, + cl_kernel * /* kernels */, + cl_uint * /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetKernelArg(cl_kernel /* kernel */, + cl_uint /* arg_index */, + size_t /* arg_size */, + const void * /* arg_value */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetKernelInfo(cl_kernel /* kernel */, + cl_kernel_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetKernelArgInfo(cl_kernel /* kernel */, + cl_uint /* arg_indx */, + cl_kernel_arg_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetKernelWorkGroupInfo(cl_kernel /* kernel */, + cl_device_id /* device */, + cl_kernel_work_group_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Event Object APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clWaitForEvents(cl_uint /* num_events */, + const cl_event * /* event_list */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetEventInfo(cl_event /* event */, + cl_event_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_event CL_API_CALL +clCreateUserEvent(cl_context /* context */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetUserEventStatus(cl_event /* event */, + cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetEventCallback( cl_event /* event */, + cl_int /* command_exec_callback_type */, + void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *), + void * /* user_data */) CL_API_SUFFIX__VERSION_1_1; + +/* Profiling APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clGetEventProfilingInfo(cl_event /* event */, + cl_profiling_info /* param_name */, + size_t /* param_value_size */, + void * /* param_value */, + size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + +/* Flush and Finish APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clFlush(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clFinish(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + +/* Enqueued Commands APIs */ +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReadBuffer(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + cl_bool /* blocking_read */, + size_t /* offset */, + size_t /* size */, + void * /* ptr */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReadBufferRect(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + cl_bool /* blocking_read */, + const size_t * /* buffer_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 */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWriteBuffer(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + cl_bool /* blocking_write */, + size_t /* offset */, + size_t /* size */, + const void * /* ptr */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWriteBufferRect(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + cl_bool /* blocking_write */, + const size_t * /* buffer_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 */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueFillBuffer(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + const void * /* pattern */, + size_t /* pattern_size */, + size_t /* offset */, + size_t /* size */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyBuffer(cl_command_queue /* command_queue */, + cl_mem /* src_buffer */, + cl_mem /* dst_buffer */, + size_t /* src_offset */, + size_t /* dst_offset */, + size_t /* size */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyBufferRect(cl_command_queue /* command_queue */, + cl_mem /* src_buffer */, + cl_mem /* dst_buffer */, + const size_t * /* src_origin */, + const size_t * /* dst_origin */, + const size_t * /* region */, + size_t /* src_row_pitch */, + size_t /* src_slice_pitch */, + size_t /* dst_row_pitch */, + size_t /* dst_slice_pitch */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReadImage(cl_command_queue /* command_queue */, + cl_mem /* image */, + cl_bool /* blocking_read */, + const size_t * /* origin[3] */, + const size_t * /* region[3] */, + size_t /* row_pitch */, + size_t /* slice_pitch */, + void * /* ptr */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWriteImage(cl_command_queue /* command_queue */, + cl_mem /* image */, + cl_bool /* blocking_write */, + const size_t * /* origin[3] */, + const size_t * /* region[3] */, + size_t /* input_row_pitch */, + size_t /* input_slice_pitch */, + const void * /* ptr */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueFillImage(cl_command_queue /* command_queue */, + cl_mem /* image */, + const void * /* fill_color */, + const size_t * /* origin[3] */, + const size_t * /* region[3] */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyImage(cl_command_queue /* command_queue */, + cl_mem /* src_image */, + cl_mem /* dst_image */, + const size_t * /* src_origin[3] */, + const size_t * /* dst_origin[3] */, + const size_t * /* region[3] */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */, + cl_mem /* src_image */, + cl_mem /* dst_buffer */, + const size_t * /* src_origin[3] */, + const size_t * /* region[3] */, + size_t /* dst_offset */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */, + cl_mem /* src_buffer */, + cl_mem /* dst_image */, + size_t /* src_offset */, + const size_t * /* dst_origin[3] */, + const size_t * /* region[3] */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY void * CL_API_CALL +clEnqueueMapBuffer(cl_command_queue /* command_queue */, + cl_mem /* buffer */, + cl_bool /* blocking_map */, + cl_map_flags /* map_flags */, + size_t /* offset */, + size_t /* size */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY void * CL_API_CALL +clEnqueueMapImage(cl_command_queue /* command_queue */, + cl_mem /* image */, + cl_bool /* blocking_map */, + cl_map_flags /* map_flags */, + const size_t * /* origin[3] */, + const size_t * /* region[3] */, + size_t * /* image_row_pitch */, + size_t * /* image_slice_pitch */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueUnmapMemObject(cl_command_queue /* command_queue */, + cl_mem /* memobj */, + void * /* mapped_ptr */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMigrateMemObjects(cl_command_queue /* command_queue */, + cl_uint /* num_mem_objects */, + const cl_mem * /* mem_objects */, + cl_mem_migration_flags /* flags */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueNDRangeKernel(cl_command_queue /* command_queue */, + cl_kernel /* kernel */, + cl_uint /* work_dim */, + const size_t * /* global_work_offset */, + const size_t * /* global_work_size */, + const size_t * /* local_work_size */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueTask(cl_command_queue /* command_queue */, + cl_kernel /* kernel */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueNativeKernel(cl_command_queue /* command_queue */, + void (CL_CALLBACK * /*user_func*/)(void *), + void * /* args */, + size_t /* cb_args */, + cl_uint /* num_mem_objects */, + const cl_mem * /* mem_list */, + const void ** /* args_mem_loc */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMarkerWithWaitList(cl_command_queue /* command_queue */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueBarrierWithWaitList(cl_command_queue /* command_queue */, + cl_uint /* num_events_in_wait_list */, + const cl_event * /* event_wait_list */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetPrintfCallback(cl_context /* context */, + void (CL_CALLBACK * /* pfn_notify */)(cl_context /* program */, + cl_uint /*printf_data_len */, + char * /* printf_data_ptr */, + void * /* user_data */), + void * /* user_data */) CL_API_SUFFIX__VERSION_1_2; + + + +/* Extension function access + * + * Returns the extension function address for the given function name, + * or NULL if a valid function can not be found. The client must + * check to make sure the address is not NULL, before using or + * calling the returned function address. + */ +extern CL_API_ENTRY void * CL_API_CALL +clGetExtensionFunctionAddressForPlatform(cl_platform_id /* platform */, + const char * /* func_name */) CL_API_SUFFIX__VERSION_1_2; + + +#ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS +//#warning CL_USE_DEPRECATED_OPENCL_1_0_APIS is defined. These APIs are unsupported and untested in OpenCL 1.1! + /* + * WARNING: + * This API introduces mutable state into the OpenCL implementation. It has been REMOVED + * to better facilitate thread safety. The 1.0 API is not thread safe. It is not tested by the + * OpenCL 1.1 conformance test, and consequently may not work or may not work dependably. + * It is likely to be non-performant. Use of this API is not advised. Use at your own risk. + * + * Software developers previously relying on this API are instructed to set the command queue + * properties when creating the queue, instead. + */ + extern CL_API_ENTRY cl_int CL_API_CALL + clSetCommandQueueProperty(cl_command_queue /* command_queue */, + cl_command_queue_properties /* properties */, + cl_bool /* enable */, + cl_command_queue_properties * /* old_properties */) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */ + + +#ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS + extern CL_API_ENTRY cl_mem CL_API_CALL + clCreateImage2D(cl_context /* context */, + cl_mem_flags /* flags */, + const cl_image_format * /* image_format */, + size_t /* image_width */, + size_t /* image_height */, + size_t /* image_row_pitch */, + void * /* host_ptr */, + cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_mem CL_API_CALL + clCreateImage3D(cl_context /* context */, + cl_mem_flags /* flags */, + const cl_image_format * /* image_format */, + size_t /* image_width */, + size_t /* image_height */, + size_t /* image_depth */, + size_t /* image_row_pitch */, + size_t /* image_slice_pitch */, + void * /* host_ptr */, + cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL + clEnqueueMarker(cl_command_queue /* command_queue */, + cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL + clEnqueueWaitForEvents(cl_command_queue /* command_queue */, + cl_uint /* num_events */, + const cl_event * /* event_list */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL + clEnqueueBarrier(cl_command_queue /* command_queue */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL + clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY void * CL_API_CALL + clGetExtensionFunctionAddress(const char * /* func_name */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_2_APIS */ + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_H */ + diff --git a/ext/cl-runtime/CL/cl.hpp b/ext/cl-runtime/CL/cl.hpp new file mode 100755 --- /dev/null +++ b/ext/cl-runtime/CL/cl.hpp @@ -0,0 +1,75013 @@ +/******************************************************************************* + * Copyright (c) 2008-2011 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/*! \file + * + * \brief C++ bindings for OpenCL 1.0 (rev 48) and OpenCL 1.1 (rev 33) + * \author Benedict R. Gaster and Laurent Morichetti + * + * Additions and fixes from Brian Cole, March 3rd 2010. + * + * \version 1.1 + * \date June 2010 + * + * Optional extension support + * + * cl + * cl_ext_device_fission + * #define USE_CL_DEVICE_FISSION + */ + +/*! \mainpage + * \section intro Introduction + * For many large applications C++ is the language of choice and so it seems + * reasonable to define C++ bindings for OpenCL. + * + * + * The interface is contained with a single C++ header file \em cl.hpp and all + * definitions are contained within the namespace \em cl. There is no additional + * requirement to include \em cl.h and to use either the C++ or original C + * bindings it is enough to simply include \em cl.hpp. + * + * The bindings themselves are lightweight and correspond closely to the + * underlying C API. Using the C++ bindings introduces no additional execution + * overhead. + * + * For detail documentation on the bindings see: + * + * The OpenCL C++ Wrapper API 1.1 (revision 04) + * http://www.khronos.org/registry/cl/specs/opencl-cplusplus-1.1.pdf + * + * \section example Example + * + * The following example shows a general use case for the C++ + * bindings, including support for the optional exception feature and + * also the supplied vector and string classes, see following sections for + * decriptions of these features. + * + * \code + * #define __CL_ENABLE_EXCEPTIONS + * + * #if defined(__APPLE__) || defined(__MACOSX) + * #include + * #else + * #include + * #endif + * #include + * #include + * #include + * + * const char * helloStr = "__kernel void " + * "hello(void) " + * "{ " + * " " + * "} "; + * + * int + * main(void) + * { + * cl_int err = CL_SUCCESS; + * try { + * + * std::vector platforms; + * cl::Platform::get(&platforms); + * if (platforms.size() == 0) { + * std::cout << "Platform size 0\n"; + * return -1; + * } + * + * cl_context_properties properties[] = + * { CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(), 0}; + * cl::Context context(CL_DEVICE_TYPE_CPU, properties); + * + * std::vector devices = context.getInfo(); + * + * cl::Program::Sources source(1, + * std::make_pair(helloStr,strlen(helloStr))); + * cl::Program program_ = cl::Program(context, source); + * program_.build(devices); + * + * cl::Kernel kernel(program_, "hello", &err); + * + * cl::Event event; + * cl::CommandQueue queue(context, devices[0], 0, &err); + * queue.enqueueNDRangeKernel( + * kernel, + * cl::NullRange, + * cl::NDRange(4,4), + * cl::NullRange, + * NULL, + * &event); + * + * event.wait(); + * } + * catch (cl::Error err) { + * std::cerr + * << "ERROR: " + * << err.what() + * << "(" + * << err.err() + * << ")" + * << std::endl; + * } + * + * return EXIT_SUCCESS; + * } + * + * \endcode + * + */ +#ifndef CL_HPP_ +#define CL_HPP_ + +#define CL_USE_DEPRECATED_OPENCL_1_1_APIS + +#ifdef _WIN32 +#include +#include +#pragma push_macro("max") +#undef max +#if defined(USE_DX_INTEROP) +#include +#endif +#endif // _WIN32 + +// +#if defined(USE_CL_DEVICE_FISSION) +#include +#endif + +#if defined(__APPLE__) || defined(__MACOSX) +#include +#include +#include +#else +#include +#include +#endif // !__APPLE__ + +#if !defined(CL_CALLBACK) +#define CL_CALLBACK +#endif //CL_CALLBACK + +#include +#include + +#if !defined(__NO_STD_VECTOR) +#include +#endif + +#if !defined(__NO_STD_STRING) +#include +#endif + +#if defined(linux) || defined(__APPLE__) || defined(__MACOSX) +# include +#endif // linux + +#include + +#if defined(_WIN32) +#include +#else +#include +#endif + +/*! \namespace cl + * + * \brief The OpenCL C++ bindings are defined within this namespace. + * + */ +namespace cl { + +#define __INIT_CL_EXT_FCN_PTR(name) \ + if(!pfn_##name) { \ + pfn_##name = (PFN_##name) \ + clGetExtensionFunctionAddress(#name); \ + if(!pfn_##name) { \ + } \ + } + +class Program; +class Device; +class Context; +class CommandQueue; +class Memory; + +#if defined(__CL_ENABLE_EXCEPTIONS) +#include +/*! \class Error + * \brief Exception class + */ +class Error : public std::exception +{ +private: + cl_int err_; + const char * errStr_; +public: + /*! Create a new CL error exception for a given error code + * and corresponding message. + */ + Error(cl_int err, const char * errStr = NULL) : err_(err), errStr_(errStr) + {} + + ~Error() throw() {} + + /*! \brief Get error string associated with exception + * + * \return A memory pointer to the error message string. + */ + virtual const char * what() const throw () + { + if (errStr_ == NULL) { + return "empty"; + } + else { + return errStr_; + } + } + + /*! \brief Get error code associated with exception + * + * \return The error code. + */ + cl_int err(void) const { return err_; } +}; + +#define __ERR_STR(x) #x +#else +#define __ERR_STR(x) NULL +#endif // __CL_ENABLE_EXCEPTIONS + +//! \cond DOXYGEN_DETAIL +#if !defined(__CL_USER_OVERRIDE_ERROR_STRINGS) +#define __GET_DEVICE_INFO_ERR __ERR_STR(clGetDeviceInfo) +#define __GET_PLATFORM_INFO_ERR __ERR_STR(clGetPlatformInfo) +#define __GET_DEVICE_IDS_ERR __ERR_STR(clGetDeviceIDs) +#define __GET_PLATFORM_IDS_ERR __ERR_STR(clGetPlatformIDs) +#define __GET_CONTEXT_INFO_ERR __ERR_STR(clGetContextInfo) +#define __GET_EVENT_INFO_ERR __ERR_STR(clGetEventInfo) +#define __GET_EVENT_PROFILE_INFO_ERR __ERR_STR(clGetEventProfileInfo) +#define __GET_MEM_OBJECT_INFO_ERR __ERR_STR(clGetMemObjectInfo) +#define __GET_IMAGE_INFO_ERR __ERR_STR(clGetImageInfo) +#define __GET_SAMPLER_INFO_ERR __ERR_STR(clGetSamplerInfo) +#define __GET_KERNEL_INFO_ERR __ERR_STR(clGetKernelInfo) +#define __GET_KERNEL_WORK_GROUP_INFO_ERR __ERR_STR(clGetKernelWorkGroupInfo) +#define __GET_PROGRAM_INFO_ERR __ERR_STR(clGetProgramInfo) +#define __GET_PROGRAM_BUILD_INFO_ERR __ERR_STR(clGetProgramBuildInfo) +#define __GET_COMMAND_QUEUE_INFO_ERR __ERR_STR(clGetCommandQueueInfo) + +#define __CREATE_CONTEXT_ERR __ERR_STR(clCreateContext) +#define __CREATE_CONTEXT_FROM_TYPE_ERR __ERR_STR(clCreateContextFromType) +#define __GET_SUPPORTED_IMAGE_FORMATS_ERR __ERR_STR(clGetSupportedImageFormats) + +#define __CREATE_BUFFER_ERR __ERR_STR(clCreateBuffer) +#define __CREATE_SUBBUFFER_ERR __ERR_STR(clCreateSubBuffer) +#define __CREATE_GL_BUFFER_ERR __ERR_STR(clCreateFromGLBuffer) +#define __CREATE_GL_RENDER_BUFFER_ERR __ERR_STR(clCreateFromGLBuffer) +#define __CREATE_GL_TEXTURE_2D_ERR __ERR_STR(clCreateFromGLTexture2D) +#define __CREATE_GL_TEXTURE_3D_ERR __ERR_STR(clCreateFromGLTexture3D) +#define __GET_GL_OBJECT_INFO_ERR __ERR_STR(clGetGLObjectInfo) +#define __CREATE_IMAGE2D_ERR __ERR_STR(clCreateImage2D) +#define __CREATE_IMAGE3D_ERR __ERR_STR(clCreateImage3D) +#define __CREATE_SAMPLER_ERR __ERR_STR(clCreateSampler) +#define __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR __ERR_STR(clSetMemObjectDestructorCallback) + +#define __CREATE_USER_EVENT_ERR __ERR_STR(clCreateUserEvent) +#define __SET_USER_EVENT_STATUS_ERR __ERR_STR(clSetUserEventStatus) +#define __SET_EVENT_CALLBACK_ERR __ERR_STR(clSetEventCallback) +#define __WAIT_FOR_EVENTS_ERR __ERR_STR(clWaitForEvents) + +#define __CREATE_KERNEL_ERR __ERR_STR(clCreateKernel) +#define __SET_KERNEL_ARGS_ERR __ERR_STR(clSetKernelArg) +#define __CREATE_PROGRAM_WITH_SOURCE_ERR __ERR_STR(clCreateProgramWithSource) +#define __CREATE_PROGRAM_WITH_BINARY_ERR __ERR_STR(clCreateProgramWithBinary) +#define __BUILD_PROGRAM_ERR __ERR_STR(clBuildProgram) +#define __CREATE_KERNELS_IN_PROGRAM_ERR __ERR_STR(clCreateKernelsInProgram) + +#define __CREATE_COMMAND_QUEUE_ERR __ERR_STR(clCreateCommandQueue) +#define __SET_COMMAND_QUEUE_PROPERTY_ERR __ERR_STR(clSetCommandQueueProperty) +#define __ENQUEUE_READ_BUFFER_ERR __ERR_STR(clEnqueueReadBuffer) +#define __ENQUEUE_READ_BUFFER_RECT_ERR __ERR_STR(clEnqueueReadBufferRect) +#define __ENQUEUE_WRITE_BUFFER_ERR __ERR_STR(clEnqueueWriteBuffer) +#define __ENQUEUE_WRITE_BUFFER_RECT_ERR __ERR_STR(clEnqueueWriteBufferRect) +#define __ENQEUE_COPY_BUFFER_ERR __ERR_STR(clEnqueueCopyBuffer) +#define __ENQEUE_COPY_BUFFER_RECT_ERR __ERR_STR(clEnqueueCopyBufferRect) +#define __ENQUEUE_READ_IMAGE_ERR __ERR_STR(clEnqueueReadImage) +#define __ENQUEUE_WRITE_IMAGE_ERR __ERR_STR(clEnqueueWriteImage) +#define __ENQUEUE_COPY_IMAGE_ERR __ERR_STR(clEnqueueCopyImage) +#define __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR __ERR_STR(clEnqueueCopyImageToBuffer) +#define __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR __ERR_STR(clEnqueueCopyBufferToImage) +#define __ENQUEUE_MAP_BUFFER_ERR __ERR_STR(clEnqueueMapBuffer) +#define __ENQUEUE_MAP_IMAGE_ERR __ERR_STR(clEnqueueMapImage) +#define __ENQUEUE_UNMAP_MEM_OBJECT_ERR __ERR_STR(clEnqueueUnMapMemObject) +#define __ENQUEUE_NDRANGE_KERNEL_ERR __ERR_STR(clEnqueueNDRangeKernel) +#define __ENQUEUE_TASK_ERR __ERR_STR(clEnqueueTask) +#define __ENQUEUE_NATIVE_KERNEL __ERR_STR(clEnqueueNativeKernel) +#define __ENQUEUE_MARKER_ERR __ERR_STR(clEnqueueMarker) +#define __ENQUEUE_WAIT_FOR_EVENTS_ERR __ERR_STR(clEnqueueWaitForEvents) +#define __ENQUEUE_BARRIER_ERR __ERR_STR(clEnqueueBarrier) + +#define __ENQUEUE_ACQUIRE_GL_ERR __ERR_STR(clEnqueueAcquireGLObjects) +#define __ENQUEUE_RELEASE_GL_ERR __ERR_STR(clEnqueueReleaseGLObjects) + +#define __UNLOAD_COMPILER_ERR __ERR_STR(clUnloadCompiler) + +#define __FLUSH_ERR __ERR_STR(clFlush) +#define __FINISH_ERR __ERR_STR(clFinish) + +#define __CREATE_SUB_DEVICES __ERR_STR(clCreateSubDevicesEXT) +#endif // __CL_USER_OVERRIDE_ERROR_STRINGS +//! \endcond + +/*! \class string + * \brief Simple string class, that provides a limited subset of std::string + * functionality but avoids many of the issues that come with that class. + */ +class string +{ +private: + ::size_t size_; + char * str_; +public: + string(void) : size_(0), str_(NULL) + { + } + + string(char * str, ::size_t size) : + size_(size), + str_(NULL) + { + str_ = new char[size_+1]; + if (str_ != NULL) { + memcpy(str_, str, size_ * sizeof(char)); + str_[size_] = '\0'; + } + else { + size_ = 0; + } + } + + string(char * str) : + str_(NULL) + { + size_= ::strlen(str); + str_ = new char[size_ + 1]; + if (str_ != NULL) { + memcpy(str_, str, (size_ + 1) * sizeof(char)); + } + else { + size_ = 0; + } + } + + string& operator=(const string& rhs) + { + if (this == &rhs) { + return *this; + } + + if (rhs.size_ == 0 || rhs.str_ == NULL) { + size_ = 0; + str_ = NULL; + } + else { + size_ = rhs.size_; + str_ = new char[size_ + 1]; + if (str_ != NULL) { + memcpy(str_, rhs.str_, (size_ + 1) * sizeof(char)); + } + else { + size_ = 0; + } + } + + return *this; + } + + string(const string& rhs) + { + *this = rhs; + } + + ~string() + { + if (str_ != NULL) { + delete[] str_; + } + } + + ::size_t size(void) const { return size_; } + ::size_t length(void) const { return size(); } + + const char * c_str(void) const { return (str_) ? str_ : "";} +}; + +#if !defined(__USE_DEV_STRING) && !defined(__NO_STD_STRING) +#include +typedef std::string STRING_CLASS; +#elif !defined(__USE_DEV_STRING) +typedef cl::string STRING_CLASS; +#endif + +#if !defined(__USE_DEV_VECTOR) && !defined(__NO_STD_VECTOR) +#include +#define VECTOR_CLASS std::vector +#elif !defined(__USE_DEV_VECTOR) +#define VECTOR_CLASS cl::vector +#endif + +#if !defined(__MAX_DEFAULT_VECTOR_SIZE) +#define __MAX_DEFAULT_VECTOR_SIZE 10 +#endif + +/*! \class vector + * \brief Fixed sized vector implementation that mirroring + * std::vector functionality. + */ +template +class vector +{ +private: + T data_[N]; + unsigned int size_; + bool empty_; +public: + vector() : + size_(static_cast(-1)), + empty_(true) + {} + + ~vector() {} + + unsigned int size(void) const + { + return size_ + 1; + } + + void clear() + { + size_ = -1; + empty_ = true; + } + + void push_back (const T& x) + { + if (size() < N) { + size_++; + data_[size_] = x; + empty_ = false; + } + } + + void pop_back(void) + { + if (!empty_) { + data_[size_].~T(); + size_--; + if (size_ == -1) { + empty_ = true; + } + } + } + + vector(const vector& vec) : + size_(vec.size_), + empty_(vec.empty_) + { + if (!empty_) { + memcpy(&data_[0], &vec.data_[0], size() * sizeof(T)); + } + } + + vector(unsigned int size, const T& val = T()) : + size_(-1), + empty_(true) + { + for (unsigned int i = 0; i < size; i++) { + push_back(val); + } + } + + vector& operator=(const vector& rhs) + { + if (this == &rhs) { + return *this; + } + + size_ = rhs.size_; + empty_ = rhs.empty_; + + if (!empty_) { + memcpy(&data_[0], &rhs.data_[0], size() * sizeof(T)); + } + + return *this; + } + + bool operator==(vector &vec) + { + if (empty_ && vec.empty_) { + return true; + } + + if (size() != vec.size()) { + return false; + } + + return memcmp(&data_[0], &vec.data_[0], size() * sizeof(T)) == 0 ? true : false; + } + + operator T* () { return data_; } + operator const T* () const { return data_; } + + bool empty (void) const + { + return empty_; + } + + unsigned int max_size (void) const + { + return N; + } + + unsigned int capacity () const + { + return sizeof(T) * N; + } + + T& operator[](int index) + { + return data_[index]; + } + + T operator[](int index) const + { + return data_[index]; + } + + template + void assign(I start, I end) + { + clear(); + while(start < end) { + push_back(*start); + start++; + } + } + + /*! \class iterator + * \brief Iterator class for vectors + */ + class iterator + { + private: + vector vec_; + int index_; + bool initialized_; + public: + iterator(void) : + index_(-1), + initialized_(false) + { + index_ = -1; + initialized_ = false; + } + + ~iterator(void) {} + + static iterator begin(vector &vec) + { + iterator i; + + if (!vec.empty()) { + i.index_ = 0; + } + + i.vec_ = vec; + i.initialized_ = true; + return i; + } + + static iterator end(vector &vec) + { + iterator i; + + if (!vec.empty()) { + i.index_ = vec.size(); + } + i.vec_ = vec; + i.initialized_ = true; + return i; + } + + bool operator==(iterator i) + { + return ((vec_ == i.vec_) && + (index_ == i.index_) && + (initialized_ == i.initialized_)); + } + + bool operator!=(iterator i) + { + return (!(*this==i)); + } + + void operator++() + { + index_++; + } + + void operator++(int x) + { + index_ += x; + } + + void operator--() + { + index_--; + } + + void operator--(int x) + { + index_ -= x; + } + + T operator *() + { + return vec_[index_]; + } + }; + + iterator begin(void) + { + return iterator::begin(*this); + } + + iterator end(void) + { + return iterator::end(*this); + } + + T& front(void) + { + return data_[0]; + } + + T& back(void) + { + return data_[size_]; + } + + const T& front(void) const + { + return data_[0]; + } + + const T& back(void) const + { + return data_[size_]; + } +}; + +namespace detail { +#define __DEFAULT_NOT_INITIALIZED 1 +#define __DEFAULT_BEING_INITIALIZED 2 +#define __DEFAULT_INITIALIZED 4 + + /* + * Compare and exchange primitives are needed for handling of defaults + */ + inline int compare_exchange(volatile int * dest, int exchange, int comparand) + { +#ifdef _WIN32 + return (int)(InterlockedCompareExchange( + (volatile long*)dest, + (long)exchange, + (long)comparand)); +#elif defined(__APPLE__) || defined(__MACOSX) + return OSAtomicOr32Orig((uint32_t)exchange, (volatile uint32_t*)dest); +#else // !_WIN32 || defined(__APPLE__) || defined(__MACOSX) + return (__sync_val_compare_and_swap( + dest, + comparand, + exchange)); +#endif // !_WIN32 + } +}; // namespace detail + + +/*! + * \brief size_t class used to interface between C++ and + * OpenCL C calls that require arrays of size_t values, who's + * size is known statically. + */ +template +struct size_t : public cl::vector< ::size_t, N> { }; + +namespace detail { + +// GetInfo help struct +template +struct GetInfoHelper +{ + static cl_int + get(Functor f, cl_uint name, T* param) + { + return f(name, sizeof(T), param, NULL); + } +}; + +// Specialized GetInfoHelper for VECTOR_CLASS params +template +struct GetInfoHelper > +{ + static cl_int get(Func f, cl_uint name, VECTOR_CLASS* param) + { + ::size_t required; + cl_int err = f(name, 0, NULL, &required); + if (err != CL_SUCCESS) { + return err; + } + + T* value = (T*) alloca(required); + err = f(name, required, value, NULL); + if (err != CL_SUCCESS) { + return err; + } + + param->assign(&value[0], &value[required/sizeof(T)]); + return CL_SUCCESS; + } +}; + +// Specialized for getInfo +template +struct GetInfoHelper > +{ + static cl_int + get(Func f, cl_uint name, VECTOR_CLASS* param) + { + ::size_t nDevices; + ::size_t * binary_sizes; + char ** values; + + cl_int err = f(CL_PROGRAM_NUM_DEVICES, sizeof(nDevices), &nDevices, NULL); + if (err != CL_SUCCESS) { + return err; + } + + binary_sizes = (::size_t*)alloca(sizeof(::size_t)*nDevices); + err = f(CL_PROGRAM_BINARY_SIZES, sizeof(::size_t)*nDevices, binary_sizes, NULL); + if (err != CL_SUCCESS) { + return err; + } + + values = (char **) alloca(sizeof(char*)*nDevices); + for(cl_uint i = 0; i < nDevices; i++ ) + { + if( binary_sizes[i] != 0 ) + { + values[i]= (char *)alloca( sizeof(char)*binary_sizes[i]); + } + else + { + values[i] = NULL; + } + } + err = f(name, sizeof(char *)*nDevices, values, NULL); + if (err != CL_SUCCESS) { + return err; + } + + param->assign(values,values+nDevices); + return CL_SUCCESS; + } +}; + +// Specialized GetInfoHelper for STRING_CLASS params +template +struct GetInfoHelper +{ + static cl_int get(Func f, cl_uint name, STRING_CLASS* param) + { + ::size_t required; + cl_int err = f(name, 0, NULL, &required); + if (err != CL_SUCCESS) { + return err; + } + + char* value = (char*) alloca(required); + err = f(name, required, value, NULL); + if (err != CL_SUCCESS) { + return err; + } + + *param = value; + return CL_SUCCESS; + } +}; + +// Specialized GetInfoHelper for cl::size_t params +template +struct GetInfoHelper > +{ + static cl_int get(Func f, cl_uint name, size_t* param) + { + ::size_t required; + cl_int err = f(name, 0, NULL, &required); + if (err != CL_SUCCESS) { + return err; + } + + ::size_t* value = (::size_t*) alloca(required); + err = f(name, required, value, NULL); + if (err != CL_SUCCESS) { + return err; + } + + param->assign(&value[0], &value[required/sizeof(::size_t)]); + return CL_SUCCESS; + } +}; + +#define __GET_INFO_HELPER_WITH_RETAIN(CPP_TYPE) \ +namespace detail { \ +template \ +struct GetInfoHelper \ +{ \ + static cl_int get(Func f, cl_uint name, CPP_TYPE* param) \ + { \ + cl_uint err = f(name, sizeof(CPP_TYPE), param, NULL); \ + if (err != CL_SUCCESS) { \ + return err; \ + } \ + \ + return ReferenceHandler::retain((*param)()); \ + } \ +}; \ +} + + +#define __PARAM_NAME_INFO_1_0(F) \ + F(cl_platform_info, CL_PLATFORM_PROFILE, STRING_CLASS) \ + F(cl_platform_info, CL_PLATFORM_VERSION, STRING_CLASS) \ + F(cl_platform_info, CL_PLATFORM_NAME, STRING_CLASS) \ + F(cl_platform_info, CL_PLATFORM_VENDOR, STRING_CLASS) \ + F(cl_platform_info, CL_PLATFORM_EXTENSIONS, STRING_CLASS) \ + \ + F(cl_device_info, CL_DEVICE_TYPE, cl_device_type) \ + F(cl_device_info, CL_DEVICE_VENDOR_ID, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_WORK_GROUP_SIZE, ::size_t) \ + F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_SIZES, VECTOR_CLASS< ::size_t>) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, cl_uint) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, cl_uint) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint) \ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint) \ + F(cl_device_info, CL_DEVICE_ADDRESS_BITS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_READ_IMAGE_ARGS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong) \ + F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_WIDTH, ::size_t) \ + F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_HEIGHT, ::size_t) \ + F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_WIDTH, ::size_t) \ + F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_HEIGHT, ::size_t) \ + F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_DEPTH, ::size_t) \ + F(cl_device_info, CL_DEVICE_IMAGE_SUPPORT, cl_bool) \ + F(cl_device_info, CL_DEVICE_MAX_PARAMETER_SIZE, ::size_t) \ + F(cl_device_info, CL_DEVICE_MAX_SAMPLERS, cl_uint) \ + F(cl_device_info, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint) \ + F(cl_device_info, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, cl_uint) \ + F(cl_device_info, CL_DEVICE_SINGLE_FP_CONFIG, cl_device_fp_config) \ + F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, cl_device_mem_cache_type) \ + F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint)\ + F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong) \ + F(cl_device_info, CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong) \ + F(cl_device_info, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong) \ + F(cl_device_info, CL_DEVICE_MAX_CONSTANT_ARGS, cl_uint) \ + F(cl_device_info, CL_DEVICE_LOCAL_MEM_TYPE, cl_device_local_mem_type) \ + F(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong) \ + F(cl_device_info, CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_bool) \ + F(cl_device_info, CL_DEVICE_PROFILING_TIMER_RESOLUTION, ::size_t) \ + F(cl_device_info, CL_DEVICE_ENDIAN_LITTLE, cl_bool) \ + F(cl_device_info, CL_DEVICE_AVAILABLE, cl_bool) \ + F(cl_device_info, CL_DEVICE_COMPILER_AVAILABLE, cl_bool) \ + F(cl_device_info, CL_DEVICE_EXECUTION_CAPABILITIES, cl_device_exec_capabilities) \ + F(cl_device_info, CL_DEVICE_QUEUE_PROPERTIES, cl_command_queue_properties) \ + F(cl_device_info, CL_DEVICE_PLATFORM, cl_platform_id) \ + F(cl_device_info, CL_DEVICE_NAME, STRING_CLASS) \ + F(cl_device_info, CL_DEVICE_VENDOR, STRING_CLASS) \ + F(cl_device_info, CL_DRIVER_VERSION, STRING_CLASS) \ + F(cl_device_info, CL_DEVICE_PROFILE, STRING_CLASS) \ + F(cl_device_info, CL_DEVICE_VERSION, STRING_CLASS) \ + F(cl_device_info, CL_DEVICE_EXTENSIONS, STRING_CLASS) \ + \ + F(cl_context_info, CL_CONTEXT_REFERENCE_COUNT, cl_uint) \ + F(cl_context_info, CL_CONTEXT_DEVICES, VECTOR_CLASS) \ + F(cl_context_info, CL_CONTEXT_PROPERTIES, VECTOR_CLASS) \ + \ + F(cl_event_info, CL_EVENT_COMMAND_QUEUE, cl::CommandQueue) \ + F(cl_event_info, CL_EVENT_COMMAND_TYPE, cl_command_type) \ + F(cl_event_info, CL_EVENT_REFERENCE_COUNT, cl_uint) \ + F(cl_event_info, CL_EVENT_COMMAND_EXECUTION_STATUS, cl_uint) \ + \ + F(cl_profiling_info, CL_PROFILING_COMMAND_QUEUED, cl_ulong) \ + F(cl_profiling_info, CL_PROFILING_COMMAND_SUBMIT, cl_ulong) \ + F(cl_profiling_info, CL_PROFILING_COMMAND_START, cl_ulong) \ + F(cl_profiling_info, CL_PROFILING_COMMAND_END, cl_ulong) \ + \ + F(cl_mem_info, CL_MEM_TYPE, cl_mem_object_type) \ + F(cl_mem_info, CL_MEM_FLAGS, cl_mem_flags) \ + F(cl_mem_info, CL_MEM_SIZE, ::size_t) \ + F(cl_mem_info, CL_MEM_HOST_PTR, void*) \ + F(cl_mem_info, CL_MEM_MAP_COUNT, cl_uint) \ + F(cl_mem_info, CL_MEM_REFERENCE_COUNT, cl_uint) \ + F(cl_mem_info, CL_MEM_CONTEXT, cl::Context) \ + \ + F(cl_image_info, CL_IMAGE_FORMAT, cl_image_format) \ + F(cl_image_info, CL_IMAGE_ELEMENT_SIZE, ::size_t) \ + F(cl_image_info, CL_IMAGE_ROW_PITCH, ::size_t) \ + F(cl_image_info, CL_IMAGE_SLICE_PITCH, ::size_t) \ + F(cl_image_info, CL_IMAGE_WIDTH, ::size_t) \ + F(cl_image_info, CL_IMAGE_HEIGHT, ::size_t) \ + F(cl_image_info, CL_IMAGE_DEPTH, ::size_t) \ + \ + F(cl_sampler_info, CL_SAMPLER_REFERENCE_COUNT, cl_uint) \ + F(cl_sampler_info, CL_SAMPLER_CONTEXT, cl::Context) \ + F(cl_sampler_info, CL_SAMPLER_NORMALIZED_COORDS, cl_addressing_mode) \ + F(cl_sampler_info, CL_SAMPLER_ADDRESSING_MODE, cl_filter_mode) \ + F(cl_sampler_info, CL_SAMPLER_FILTER_MODE, cl_bool) \ + \ + F(cl_program_info, CL_PROGRAM_REFERENCE_COUNT, cl_uint) \ + F(cl_program_info, CL_PROGRAM_CONTEXT, cl::Context) \ + F(cl_program_info, CL_PROGRAM_NUM_DEVICES, cl_uint) \ + F(cl_program_info, CL_PROGRAM_DEVICES, VECTOR_CLASS) \ + F(cl_program_info, CL_PROGRAM_SOURCE, STRING_CLASS) \ + F(cl_program_info, CL_PROGRAM_BINARY_SIZES, VECTOR_CLASS< ::size_t>) \ + F(cl_program_info, CL_PROGRAM_BINARIES, VECTOR_CLASS) \ + \ + F(cl_program_build_info, CL_PROGRAM_BUILD_STATUS, cl_build_status) \ + F(cl_program_build_info, CL_PROGRAM_BUILD_OPTIONS, STRING_CLASS) \ + F(cl_program_build_info, CL_PROGRAM_BUILD_LOG, STRING_CLASS) \ + \ + F(cl_kernel_info, CL_KERNEL_FUNCTION_NAME, STRING_CLASS) \ + F(cl_kernel_info, CL_KERNEL_NUM_ARGS, cl_uint) \ + F(cl_kernel_info, CL_KERNEL_REFERENCE_COUNT, cl_uint) \ + F(cl_kernel_info, CL_KERNEL_CONTEXT, cl::Context) \ + F(cl_kernel_info, CL_KERNEL_PROGRAM, cl::Program) \ + \ + F(cl_kernel_work_group_info, CL_KERNEL_WORK_GROUP_SIZE, ::size_t) \ + F(cl_kernel_work_group_info, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, cl::size_t<3>) \ + F(cl_kernel_work_group_info, CL_KERNEL_LOCAL_MEM_SIZE, cl_ulong) \ + \ + F(cl_command_queue_info, CL_QUEUE_CONTEXT, cl::Context) \ + F(cl_command_queue_info, CL_QUEUE_DEVICE, cl::Device) \ + F(cl_command_queue_info, CL_QUEUE_REFERENCE_COUNT, cl_uint) \ + F(cl_command_queue_info, CL_QUEUE_PROPERTIES, cl_command_queue_properties) + +#if defined(CL_VERSION_1_1) +#define __PARAM_NAME_INFO_1_1(F) \ + F(cl_context_info, CL_CONTEXT_NUM_DEVICES, cl_uint)\ + F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint) \ + F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, cl_uint) \ + F(cl_device_info, CL_DEVICE_DOUBLE_FP_CONFIG, cl_device_fp_config) \ + F(cl_device_info, CL_DEVICE_HALF_FP_CONFIG, cl_device_fp_config) \ + F(cl_device_info, CL_DEVICE_HOST_UNIFIED_MEMORY, cl_bool) \ + F(cl_device_info, CL_DEVICE_OPENCL_C_VERSION, STRING_CLASS) \ + \ + F(cl_mem_info, CL_MEM_ASSOCIATED_MEMOBJECT, cl::Memory) \ + F(cl_mem_info, CL_MEM_OFFSET, ::size_t) \ + \ + F(cl_kernel_work_group_info, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, ::size_t) \ + F(cl_kernel_work_group_info, CL_KERNEL_PRIVATE_MEM_SIZE, cl_ulong) \ + \ + F(cl_event_info, CL_EVENT_CONTEXT, cl::Context) +#endif // CL_VERSION_1_1 + +#if defined(USE_CL_DEVICE_FISSION) +#define __PARAM_NAME_DEVICE_FISSION(F) \ + F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl_device_id) \ + F(cl_device_info, CL_DEVICE_PARTITION_TYPES_EXT, VECTOR_CLASS) \ + F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, VECTOR_CLASS) \ + F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT , cl_uint) \ + F(cl_device_info, CL_DEVICE_PARTITION_STYLE_EXT, VECTOR_CLASS) +#endif // USE_CL_DEVICE_FISSION + +template +struct param_traits {}; + +#define __CL_DECLARE_PARAM_TRAITS(token, param_name, T) \ +struct token; \ +template<> \ +struct param_traits \ +{ \ + enum { value = param_name }; \ + typedef T param_type; \ +}; + +__PARAM_NAME_INFO_1_0(__CL_DECLARE_PARAM_TRAITS) +#if defined(CL_VERSION_1_1) +__PARAM_NAME_INFO_1_1(__CL_DECLARE_PARAM_TRAITS) +#endif // CL_VERSION_1_1 + +#if defined(USE_CL_DEVICE_FISSION) +__PARAM_NAME_DEVICE_FISSION(__CL_DECLARE_PARAM_TRAITS); +#endif // USE_CL_DEVICE_FISSION + +#ifdef CL_PLATFORM_ICD_SUFFIX_KHR +__CL_DECLARE_PARAM_TRAITS(cl_platform_info, CL_PLATFORM_ICD_SUFFIX_KHR, STRING_CLASS) +#endif + +#ifdef CL_DEVICE_PROFILING_TIMER_OFFSET_AMD +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_PROFILING_TIMER_OFFSET_AMD, cl_ulong) +#endif + +#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, cl_uint) +#endif +#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, cl_uint) +#endif +#ifdef CL_DEVICE_REGISTERS_PER_BLOCK_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_REGISTERS_PER_BLOCK_NV, cl_uint) +#endif +#ifdef CL_DEVICE_WARP_SIZE_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_WARP_SIZE_NV, cl_uint) +#endif +#ifdef CL_DEVICE_GPU_OVERLAP_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GPU_OVERLAP_NV, cl_bool) +#endif +#ifdef CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, cl_bool) +#endif +#ifdef CL_DEVICE_INTEGRATED_MEMORY_NV +__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_INTEGRATED_MEMORY_NV, cl_bool) +#endif + +// Convenience functions + +template +inline cl_int +getInfo(Func f, cl_uint name, T* param) +{ + return GetInfoHelper::get(f, name, param); +} + +template +struct GetInfoFunctor0 +{ + Func f_; const Arg0& arg0_; + cl_int operator ()( + cl_uint param, ::size_t size, void* value, ::size_t* size_ret) + { return f_(arg0_, param, size, value, size_ret); } +}; + +template +struct GetInfoFunctor1 +{ + Func f_; const Arg0& arg0_; const Arg1& arg1_; + cl_int operator ()( + cl_uint param, ::size_t size, void* value, ::size_t* size_ret) + { return f_(arg0_, arg1_, param, size, value, size_ret); } +}; + +template +inline cl_int +getInfo(Func f, const Arg0& arg0, cl_uint name, T* param) +{ + GetInfoFunctor0 f0 = { f, arg0 }; + return GetInfoHelper, T> + ::get(f0, name, param); +} + +template +inline cl_int +getInfo(Func f, const Arg0& arg0, const Arg1& arg1, cl_uint name, T* param) +{ + GetInfoFunctor1 f0 = { f, arg0, arg1 }; + return GetInfoHelper, T> + ::get(f0, name, param); +} + +template +struct ReferenceHandler +{ }; + +template <> +struct ReferenceHandler +{ + // cl_device_id does not have retain(). + static cl_int retain(cl_device_id) + { return CL_INVALID_DEVICE; } + // cl_device_id does not have release(). + static cl_int release(cl_device_id) + { return CL_INVALID_DEVICE; } +}; + +template <> +struct ReferenceHandler +{ + // cl_platform_id does not have retain(). + static cl_int retain(cl_platform_id) + { return CL_INVALID_PLATFORM; } + // cl_platform_id does not have release(). + static cl_int release(cl_platform_id) + { return CL_INVALID_PLATFORM; } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_context context) + { return ::clRetainContext(context); } + static cl_int release(cl_context context) + { return ::clReleaseContext(context); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_command_queue queue) + { return ::clRetainCommandQueue(queue); } + static cl_int release(cl_command_queue queue) + { return ::clReleaseCommandQueue(queue); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_mem memory) + { return ::clRetainMemObject(memory); } + static cl_int release(cl_mem memory) + { return ::clReleaseMemObject(memory); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_sampler sampler) + { return ::clRetainSampler(sampler); } + static cl_int release(cl_sampler sampler) + { return ::clReleaseSampler(sampler); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_program program) + { return ::clRetainProgram(program); } + static cl_int release(cl_program program) + { return ::clReleaseProgram(program); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_kernel kernel) + { return ::clRetainKernel(kernel); } + static cl_int release(cl_kernel kernel) + { return ::clReleaseKernel(kernel); } +}; + +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_event event) + { return ::clRetainEvent(event); } + static cl_int release(cl_event event) + { return ::clReleaseEvent(event); } +}; + +template +class Wrapper +{ +public: + typedef T cl_type; + +protected: + cl_type object_; + +public: + Wrapper() : object_(NULL) { } + + Wrapper(const cl_type &obj) : object_(obj) { } + + ~Wrapper() + { + if (object_ != NULL) { release(); } + } + + Wrapper(const Wrapper& rhs) + { + object_ = rhs.object_; + if (object_ != NULL) { retain(); } + } + + Wrapper& operator = (const Wrapper& rhs) + { + if (object_ != NULL) { release(); } + object_ = rhs.object_; + if (object_ != NULL) { retain(); } + return *this; + } + + Wrapper& operator = (const cl_type &rhs) + { + if (object_ != NULL) { release(); } + object_ = rhs; + return *this; + } + + cl_type operator ()() const { return object_; } + + cl_type& operator ()() { return object_; } + +protected: + + cl_int retain() const + { + return ReferenceHandler::retain(object_); + } + + cl_int release() const + { + return ReferenceHandler::release(object_); + } +}; + +#if defined(__CL_ENABLE_EXCEPTIONS) +static inline cl_int errHandler ( + cl_int err, + const char * errStr = NULL) throw(Error) +{ + if (err != CL_SUCCESS) { + throw Error(err, errStr); + } + return err; +} +#else +static inline cl_int errHandler (cl_int err, const char * errStr = NULL) +{ + return err; +} +#endif // __CL_ENABLE_EXCEPTIONS + +} // namespace detail +//! \endcond + +/*! \stuct ImageFormat + * \brief ImageFormat interface fro cl_image_format. + */ +struct ImageFormat : public cl_image_format +{ + ImageFormat(){} + + ImageFormat(cl_channel_order order, cl_channel_type type) + { + image_channel_order = order; + image_channel_data_type = type; + } + + ImageFormat& operator = (const ImageFormat& rhs) + { + if (this != &rhs) { + this->image_channel_data_type = rhs.image_channel_data_type; + this->image_channel_order = rhs.image_channel_order; + } + return *this; + } +}; + +/*! \class Device + * \brief Device interface for cl_device_id. + */ +class Device : public detail::Wrapper +{ +public: + Device() : detail::Wrapper() { } + + Device(const Device& device) : detail::Wrapper(device) { } + + Device(const cl_device_id &device) : detail::Wrapper(device) { } + + static Device getDefault(cl_int * err = NULL); + + Device& operator = (const Device& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Device& operator = (const cl_device_id& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_device_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetDeviceInfo, object_, name, param), + __GET_DEVICE_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_device_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + +#if defined(USE_CL_DEVICE_FISSION) + cl_int createSubDevices( + const cl_device_partition_property_ext * properties, + VECTOR_CLASS* devices) + { + typedef CL_API_ENTRY cl_int + ( CL_API_CALL * PFN_clCreateSubDevicesEXT)( + cl_device_id /*in_device*/, + const cl_device_partition_property_ext * /* properties */, + cl_uint /*num_entries*/, + cl_device_id * /*out_devices*/, + cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1; + + static PFN_clCreateSubDevicesEXT pfn_clCreateSubDevicesEXT = NULL; + __INIT_CL_EXT_FCN_PTR(clCreateSubDevicesEXT); + + cl_uint n = 0; + cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, NULL, &n); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __CREATE_SUB_DEVICES); + } + + cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id)); + err = pfn_clCreateSubDevicesEXT(object_, properties, n, ids, NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __CREATE_SUB_DEVICES); + } + + devices->assign(&ids[0], &ids[n]); + return CL_SUCCESS; + } +#endif +}; + +/*! \class Platform + * \brief Platform interface. + */ +class Platform : public detail::Wrapper +{ +public: + static const Platform null(); + + Platform() : detail::Wrapper() { } + + Platform(const Platform& platform) : detail::Wrapper(platform) { } + + Platform(const cl_platform_id &platform) : detail::Wrapper(platform) { } + + Platform& operator = (const Platform& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Platform& operator = (const cl_platform_id& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + cl_int getInfo(cl_platform_info name, STRING_CLASS* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetPlatformInfo, object_, name, param), + __GET_PLATFORM_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_platform_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + cl_int getDevices( + cl_device_type type, + VECTOR_CLASS* devices) const + { + cl_uint n = 0; + cl_int err = ::clGetDeviceIDs(object_, type, 0, NULL, &n); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_DEVICE_IDS_ERR); + } + + cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id)); + err = ::clGetDeviceIDs(object_, type, n, ids, NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_DEVICE_IDS_ERR); + } + + devices->assign(&ids[0], &ids[n]); + return CL_SUCCESS; + } + +#if defined(USE_DX_INTEROP) + /*! \brief Get the list of available D3D10 devices. + * + * \param d3d_device_source. + * + * \param d3d_object. + * + * \param d3d_device_set. + * + * \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device + * values returned in devices can be used to identify a specific OpenCL + * device. If \a devices argument is NULL, this argument is ignored. + * + * \return One of the following values: + * - CL_SUCCESS if the function is executed successfully. + * + * The application can query specific capabilities of the OpenCL device(s) + * returned by cl::getDevices. This can be used by the application to + * determine which device(s) to use. + * + * \note In the case that exceptions are enabled and a return value + * other than CL_SUCCESS is generated, then cl::Error exception is + * generated. + */ + cl_int getDevices( + cl_d3d10_device_source_khr d3d_device_source, + void * d3d_object, + cl_d3d10_device_set_khr d3d_device_set, + VECTOR_CLASS* devices) const + { + typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clGetDeviceIDsFromD3D10KHR)( + cl_platform_id platform, + cl_d3d10_device_source_khr d3d_device_source, + void * d3d_object, + cl_d3d10_device_set_khr d3d_device_set, + cl_uint num_entries, + cl_device_id * devices, + cl_uint* num_devices); + + static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = NULL; + __INIT_CL_EXT_FCN_PTR(clGetDeviceIDsFromD3D10KHR); + + cl_uint n = 0; + cl_int err = pfn_clGetDeviceIDsFromD3D10KHR( + object_, + d3d_device_source, + d3d_object, + d3d_device_set, + 0, + NULL, + &n); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_DEVICE_IDS_ERR); + } + + cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id)); + err = pfn_clGetDeviceIDsFromD3D10KHR( + object_, + d3d_device_source, + d3d_object, + d3d_device_set, + n, + ids, + NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_DEVICE_IDS_ERR); + } + + devices->assign(&ids[0], &ids[n]); + return CL_SUCCESS; + } +#endif + + static cl_int get( + VECTOR_CLASS* platforms) + { + cl_uint n = 0; + cl_int err = ::clGetPlatformIDs(0, NULL, &n); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + } + + cl_platform_id* ids = (cl_platform_id*) alloca( + n * sizeof(cl_platform_id)); + err = ::clGetPlatformIDs(n, ids, NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + } + + platforms->assign(&ids[0], &ids[n]); + return CL_SUCCESS; + } + + static cl_int get( + Platform * platform) + { + cl_uint n = 0; + cl_int err = ::clGetPlatformIDs(0, NULL, &n); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + } + + cl_platform_id* ids = (cl_platform_id*) alloca( + n * sizeof(cl_platform_id)); + err = ::clGetPlatformIDs(n, ids, NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + } + + *platform = ids[0]; + return CL_SUCCESS; + } + + static Platform get( + cl_int * errResult = NULL) + { + Platform platform; + cl_uint n = 0; + cl_int err = ::clGetPlatformIDs(0, NULL, &n); + if (err != CL_SUCCESS) { + detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + if (errResult != NULL) { + *errResult = err; + } + } + + cl_platform_id* ids = (cl_platform_id*) alloca( + n * sizeof(cl_platform_id)); + err = ::clGetPlatformIDs(n, ids, NULL); + + if (err != CL_SUCCESS) { + detail::errHandler(err, __GET_PLATFORM_IDS_ERR); + } + + if (errResult != NULL) { + *errResult = err; + } + + return ids[0]; + } +}; + +static inline cl_int +UnloadCompiler() +{ + return ::clUnloadCompiler(); +} + +class Context : public detail::Wrapper +{ +private: + static volatile int default_initialized_; + static Context default_; + static volatile cl_int default_error_; +public: + Context( + const VECTOR_CLASS& devices, + cl_context_properties* properties = NULL, + void (CL_CALLBACK * notifyFptr)( + const char *, + const void *, + ::size_t, + void *) = NULL, + void* data = NULL, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateContext( + properties, (cl_uint) devices.size(), + (cl_device_id*) &devices.front(), + notifyFptr, data, &error); + + detail::errHandler(error, __CREATE_CONTEXT_ERR); + if (err != NULL) { + *err = error; + } + } + + Context( + cl_device_type type, + cl_context_properties* properties = NULL, + void (CL_CALLBACK * notifyFptr)( + const char *, + const void *, + ::size_t, + void *) = NULL, + void* data = NULL, + cl_int* err = NULL) + { + cl_int error; + +#if !defined(__APPLE__) || !defined(__MACOS) + cl_context_properties prop[4] = {CL_CONTEXT_PLATFORM, 0, 0, 0 }; + if (properties == NULL) { + prop[1] = (cl_context_properties)Platform::get(&error)(); + if (error != CL_SUCCESS) { + detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR); + if (err != NULL) { + *err = error; + return; + } + } + + properties = &prop[0]; + } +#endif + object_ = ::clCreateContextFromType( + properties, type, notifyFptr, data, &error); + + detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR); + if (err != NULL) { + *err = error; + } + } + + static Context getDefault(cl_int * err = NULL) + { + int state = detail::compare_exchange( + &default_initialized_, + __DEFAULT_BEING_INITIALIZED, __DEFAULT_NOT_INITIALIZED); + + if (state & __DEFAULT_INITIALIZED) { + if (err != NULL) { + *err = default_error_; + } + return default_; + } + + if (state & __DEFAULT_BEING_INITIALIZED) { + // Assume writes will propagate eventually... + while(default_initialized_ != __DEFAULT_INITIALIZED) { + ; + } + + if (err != NULL) { + *err = default_error_; + } + return default_; + } + + cl_int error; + default_ = Context( + CL_DEVICE_TYPE_DEFAULT, + NULL, + NULL, + NULL, + &error); + + default_error_ = error; + // Assume writes will propagate eventually... + default_initialized_ = __DEFAULT_INITIALIZED; + if (err != NULL) { + *err = default_error_; + } + return default_; + + } + + Context() : detail::Wrapper() { } + + Context(const Context& context) : detail::Wrapper(context) { } + + Context(const cl_context& context) : detail::Wrapper(context) { } + + Context& operator = (const Context& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Context& operator = (const cl_context& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_context_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetContextInfo, object_, name, param), + __GET_CONTEXT_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_context_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + cl_int getSupportedImageFormats( + cl_mem_flags flags, + cl_mem_object_type type, + VECTOR_CLASS* formats) const + { + cl_uint numEntries; + cl_int err = ::clGetSupportedImageFormats( + object_, + flags, + type, + 0, + NULL, + &numEntries); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR); + } + + ImageFormat* value = (ImageFormat*) + alloca(numEntries * sizeof(ImageFormat)); + err = ::clGetSupportedImageFormats( + object_, + flags, + type, + numEntries, + (cl_image_format*) value, + NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR); + } + + formats->assign(&value[0], &value[numEntries]); + return CL_SUCCESS; + } +}; + +inline Device Device::getDefault(cl_int * err) +{ + cl_int error; + Device device; + + Context context = Context::getDefault(&error); + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + + if (error != CL_SUCCESS) { + if (err != NULL) { + *err = error; + } + } + else { + device = context.getInfo()[0]; + if (err != NULL) { + *err = CL_SUCCESS; + } + } + + return device; +} + +#ifdef _WIN32 +__declspec(selectany) volatile int Context::default_initialized_ = __DEFAULT_NOT_INITIALIZED; +__declspec(selectany) Context Context::default_; +__declspec(selectany) volatile cl_int Context::default_error_ = CL_SUCCESS; +#else +__attribute__((weak)) volatile int Context::default_initialized_ = __DEFAULT_NOT_INITIALIZED; +__attribute__((weak)) Context Context::default_; +__attribute__((weak)) volatile cl_int Context::default_error_ = CL_SUCCESS; +#endif + +__GET_INFO_HELPER_WITH_RETAIN(cl::Context) + +/*! \class Event + * \brief Event interface for cl_event. + */ +class Event : public detail::Wrapper +{ +public: + Event() : detail::Wrapper() { } + + Event(const Event& event) : detail::Wrapper(event) { } + + Event(const cl_event& event) : detail::Wrapper(event) { } + + Event& operator = (const Event& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Event& operator = (const cl_event& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_event_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetEventInfo, object_, name, param), + __GET_EVENT_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_event_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + template + cl_int getProfilingInfo(cl_profiling_info name, T* param) const + { + return detail::errHandler(detail::getInfo( + &::clGetEventProfilingInfo, object_, name, param), + __GET_EVENT_PROFILE_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getProfilingInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_profiling_info, name>::param_type param; + cl_int result = getProfilingInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + cl_int wait() const + { + return detail::errHandler( + ::clWaitForEvents(1, &object_), + __WAIT_FOR_EVENTS_ERR); + } + +#if defined(CL_VERSION_1_1) + cl_int setCallback( + cl_int type, + void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *), + void * user_data = NULL) + { + return detail::errHandler( + ::clSetEventCallback( + object_, + type, + pfn_notify, + user_data), + __SET_EVENT_CALLBACK_ERR); + } +#endif + + static cl_int + waitForEvents(const VECTOR_CLASS& events) + { + return detail::errHandler( + ::clWaitForEvents( + (cl_uint) events.size(), (cl_event*)&events.front()), + __WAIT_FOR_EVENTS_ERR); + } +}; + +__GET_INFO_HELPER_WITH_RETAIN(cl::Event) + +#if defined(CL_VERSION_1_1) +/*! \class UserEvent + * \brief User event interface for cl_event. + */ +class UserEvent : public Event +{ +public: + UserEvent( + const Context& context, + cl_int * err = NULL) + { + cl_int error; + object_ = ::clCreateUserEvent( + context(), + &error); + + detail::errHandler(error, __CREATE_USER_EVENT_ERR); + if (err != NULL) { + *err = error; + } + } + + UserEvent() : Event() { } + + UserEvent(const UserEvent& event) : Event(event) { } + + UserEvent& operator = (const UserEvent& rhs) + { + if (this != &rhs) { + Event::operator=(rhs); + } + return *this; + } + + cl_int setStatus(cl_int status) + { + return detail::errHandler( + ::clSetUserEventStatus(object_,status), + __SET_USER_EVENT_STATUS_ERR); + } +}; +#endif + +inline static cl_int +WaitForEvents(const VECTOR_CLASS& events) +{ + return detail::errHandler( + ::clWaitForEvents( + (cl_uint) events.size(), (cl_event*)&events.front()), + __WAIT_FOR_EVENTS_ERR); +} + +/*! \class Memory + * \brief Memory interface for cl_mem. + */ +class Memory : public detail::Wrapper +{ +public: + Memory() : detail::Wrapper() { } + + Memory(const Memory& memory) : detail::Wrapper(memory) { } + + Memory(const cl_mem& memory) : detail::Wrapper(memory) { } + + Memory& operator = (const Memory& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Memory& operator = (const cl_mem& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_mem_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetMemObjectInfo, object_, name, param), + __GET_MEM_OBJECT_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_mem_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + +#if defined(CL_VERSION_1_1) + cl_int setDestructorCallback( + void (CL_CALLBACK * pfn_notify)(cl_mem, void *), + void * user_data = NULL) + { + return detail::errHandler( + ::clSetMemObjectDestructorCallback( + object_, + pfn_notify, + user_data), + __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR); + } +#endif + +}; + +__GET_INFO_HELPER_WITH_RETAIN(cl::Memory) + +/*! \class Buffer + * \brief Memory buffer interface. + */ +class Buffer : public Memory +{ +public: + Buffer( + const Context& context, + cl_mem_flags flags, + ::size_t size, + void* host_ptr = NULL, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error); + + detail::errHandler(error, __CREATE_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + } + + Buffer( + cl_mem_flags flags, + ::size_t size, + void* host_ptr = NULL, + cl_int* err = NULL) + { + cl_int error; + + Context context = Context::getDefault(err); + + object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error); + + detail::errHandler(error, __CREATE_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + } + + + Buffer() : Memory() { } + + Buffer(const Buffer& buffer) : Memory(buffer) { } + + Buffer(const cl_mem& buffer) : Memory(buffer) { } + + Buffer& operator = (const Buffer& rhs) + { + if (this != &rhs) { + Memory::operator=(rhs); + } + return *this; + } + + Buffer& operator = (const cl_mem& rhs) + { + Memory::operator=(rhs); + return *this; + } + +#if defined(CL_VERSION_1_1) + Buffer createSubBuffer( + cl_mem_flags flags, + cl_buffer_create_type buffer_create_type, + const void * buffer_create_info, + cl_int * err = NULL) + { + Buffer result; + cl_int error; + result.object_ = ::clCreateSubBuffer( + object_, + flags, + buffer_create_type, + buffer_create_info, + &error); + + detail::errHandler(error, __CREATE_SUBBUFFER_ERR); + if (err != NULL) { + *err = error; + } + + return result; + } +#endif +}; + +#if defined (USE_DX_INTEROP) +class BufferD3D10 : public Buffer +{ +public: + typedef CL_API_ENTRY cl_mem (CL_API_CALL *PFN_clCreateFromD3D10BufferKHR)( + cl_context context, cl_mem_flags flags, ID3D10Buffer* buffer, + cl_int* errcode_ret); + + BufferD3D10( + const Context& context, + cl_mem_flags flags, + ID3D10Buffer* bufobj, + cl_int * err = NULL) + { + static PFN_clCreateFromD3D10BufferKHR pfn_clCreateFromD3D10BufferKHR = NULL; + __INIT_CL_EXT_FCN_PTR(clCreateFromD3D10BufferKHR); + + cl_int error; + object_ = pfn_clCreateFromD3D10BufferKHR( + context(), + flags, + bufobj, + &error); + + detail::errHandler(error, __CREATE_GL_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + } + + BufferD3D10() : Buffer() { } + + BufferD3D10(const BufferD3D10& buffer) : Buffer(buffer) { } + + BufferD3D10(const cl_mem& buffer) : Buffer(buffer) { } + + BufferD3D10& operator = (const BufferD3D10& rhs) + { + if (this != &rhs) { + Buffer::operator=(rhs); + } + return *this; + } + + BufferD3D10& operator = (const cl_mem& rhs) + { + Buffer::operator=(rhs); + return *this; + } +}; +#endif + +/*! \class BufferGL + * \brief Memory buffer interface for GL interop. + */ +class BufferGL : public Buffer +{ +public: + BufferGL( + const Context& context, + cl_mem_flags flags, + GLuint bufobj, + cl_int * err = NULL) + { + cl_int error; + object_ = ::clCreateFromGLBuffer( + context(), + flags, + bufobj, + &error); + + detail::errHandler(error, __CREATE_GL_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + } + + BufferGL() : Buffer() { } + + BufferGL(const BufferGL& buffer) : Buffer(buffer) { } + + BufferGL(const cl_mem& buffer) : Buffer(buffer) { } + + BufferGL& operator = (const BufferGL& rhs) + { + if (this != &rhs) { + Buffer::operator=(rhs); + } + return *this; + } + + BufferGL& operator = (const cl_mem& rhs) + { + Buffer::operator=(rhs); + return *this; + } + + cl_int getObjectInfo( + cl_gl_object_type *type, + GLuint * gl_object_name) + { + return detail::errHandler( + ::clGetGLObjectInfo(object_,type,gl_object_name), + __GET_GL_OBJECT_INFO_ERR); + } +}; + +/*! \class BufferRenderGL + * \brief Memory buffer interface for GL interop with renderbuffer. + */ +class BufferRenderGL : public Buffer +{ +public: + BufferRenderGL( + const Context& context, + cl_mem_flags flags, + GLuint bufobj, + cl_int * err = NULL) + { + cl_int error; + object_ = ::clCreateFromGLRenderbuffer( + context(), + flags, + bufobj, + &error); + + detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + } + + BufferRenderGL() : Buffer() { } + + BufferRenderGL(const BufferGL& buffer) : Buffer(buffer) { } + + BufferRenderGL(const cl_mem& buffer) : Buffer(buffer) { } + + BufferRenderGL& operator = (const BufferRenderGL& rhs) + { + if (this != &rhs) { + Buffer::operator=(rhs); + } + return *this; + } + + BufferRenderGL& operator = (const cl_mem& rhs) + { + Buffer::operator=(rhs); + return *this; + } + + cl_int getObjectInfo( + cl_gl_object_type *type, + GLuint * gl_object_name) + { + return detail::errHandler( + ::clGetGLObjectInfo(object_,type,gl_object_name), + __GET_GL_OBJECT_INFO_ERR); + } +}; + +/*! \class Image + * \brief Base class interface for all images. + */ +class Image : public Memory +{ +protected: + Image() : Memory() { } + + Image(const Image& image) : Memory(image) { } + + Image(const cl_mem& image) : Memory(image) { } + + Image& operator = (const Image& rhs) + { + if (this != &rhs) { + Memory::operator=(rhs); + } + return *this; + } + + Image& operator = (const cl_mem& rhs) + { + Memory::operator=(rhs); + return *this; + } + +public: + template + cl_int getImageInfo(cl_image_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetImageInfo, object_, name, param), + __GET_IMAGE_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getImageInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_image_info, name>::param_type param; + cl_int result = getImageInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } +}; + +/*! \class Image2D + * \brief Image interface for 2D images. + */ +class Image2D : public Image +{ +public: + Image2D( + const Context& context, + cl_mem_flags flags, + ImageFormat format, + ::size_t width, + ::size_t height, + ::size_t row_pitch = 0, + void* host_ptr = NULL, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateImage2D( + context(), flags,&format, width, height, row_pitch, host_ptr, &error); + + detail::errHandler(error, __CREATE_IMAGE2D_ERR); + if (err != NULL) { + *err = error; + } + } + + Image2D() { } + + Image2D(const Image2D& image2D) : Image(image2D) { } + + Image2D(const cl_mem& image2D) : Image(image2D) { } + + Image2D& operator = (const Image2D& rhs) + { + if (this != &rhs) { + Image::operator=(rhs); + } + return *this; + } + + Image2D& operator = (const cl_mem& rhs) + { + Image::operator=(rhs); + return *this; + } +}; + +/*! \class Image2DGL + * \brief 2D image interface for GL interop. + */ +class Image2DGL : public Image2D +{ +public: + Image2DGL( + const Context& context, + cl_mem_flags flags, + GLenum target, + GLint miplevel, + GLuint texobj, + cl_int * err = NULL) + { + cl_int error; + object_ = ::clCreateFromGLTexture2D( + context(), + flags, + target, + miplevel, + texobj, + &error); + + detail::errHandler(error, __CREATE_GL_TEXTURE_2D_ERR); + if (err != NULL) { + *err = error; + } + } + + Image2DGL() : Image2D() { } + + Image2DGL(const Image2DGL& image) : Image2D(image) { } + + Image2DGL(const cl_mem& image) : Image2D(image) { } + + Image2DGL& operator = (const Image2DGL& rhs) + { + if (this != &rhs) { + Image2D::operator=(rhs); + } + return *this; + } + + Image2DGL& operator = (const cl_mem& rhs) + { + Image2D::operator=(rhs); + return *this; + } +}; + +/*! \class Image3D + * \brief Image interface for 3D images. + */ +class Image3D : public Image +{ +public: + Image3D( + const Context& context, + cl_mem_flags flags, + ImageFormat format, + ::size_t width, + ::size_t height, + ::size_t depth, + ::size_t row_pitch = 0, + ::size_t slice_pitch = 0, + void* host_ptr = NULL, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateImage3D( + context(), flags, &format, width, height, depth, row_pitch, + slice_pitch, host_ptr, &error); + + detail::errHandler(error, __CREATE_IMAGE3D_ERR); + if (err != NULL) { + *err = error; + } + } + + Image3D() { } + + Image3D(const Image3D& image3D) : Image(image3D) { } + + Image3D(const cl_mem& image3D) : Image(image3D) { } + + Image3D& operator = (const Image3D& rhs) + { + if (this != &rhs) { + Image::operator=(rhs); + } + return *this; + } + + Image3D& operator = (const cl_mem& rhs) + { + Image::operator=(rhs); + return *this; + } +}; + +/*! \class Image2DGL + * \brief 2D image interface for GL interop. + */ +class Image3DGL : public Image3D +{ +public: + Image3DGL( + const Context& context, + cl_mem_flags flags, + GLenum target, + GLint miplevel, + GLuint texobj, + cl_int * err = NULL) + { + cl_int error; + object_ = ::clCreateFromGLTexture3D( + context(), + flags, + target, + miplevel, + texobj, + &error); + + detail::errHandler(error, __CREATE_GL_TEXTURE_3D_ERR); + if (err != NULL) { + *err = error; + } + } + + Image3DGL() : Image3D() { } + + Image3DGL(const Image3DGL& image) : Image3D(image) { } + + Image3DGL(const cl_mem& image) : Image3D(image) { } + + Image3DGL& operator = (const Image3DGL& rhs) + { + if (this != &rhs) { + Image3D::operator=(rhs); + } + return *this; + } + + Image3DGL& operator = (const cl_mem& rhs) + { + Image3D::operator=(rhs); + return *this; + } +}; + +/*! \class Sampler + * \brief Sampler interface for cl_sampler. + */ +class Sampler : public detail::Wrapper +{ +public: + Sampler() { } + + Sampler( + const Context& context, + cl_bool normalized_coords, + cl_addressing_mode addressing_mode, + cl_filter_mode filter_mode, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateSampler( + context(), + normalized_coords, + addressing_mode, + filter_mode, + &error); + + detail::errHandler(error, __CREATE_SAMPLER_ERR); + if (err != NULL) { + *err = error; + } + } + + Sampler(const Sampler& sampler) : detail::Wrapper(sampler) { } + + Sampler(const cl_sampler& sampler) : detail::Wrapper(sampler) { } + + Sampler& operator = (const Sampler& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Sampler& operator = (const cl_sampler& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_sampler_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetSamplerInfo, object_, name, param), + __GET_SAMPLER_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_sampler_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } +}; + +__GET_INFO_HELPER_WITH_RETAIN(cl::Sampler) + +class Program; +class CommandQueue; +class Kernel; + +/*! \class NDRange + * \brief NDRange interface + */ +class NDRange +{ +private: + size_t<3> sizes_; + cl_uint dimensions_; + +public: + NDRange() + : dimensions_(0) + { } + + NDRange(::size_t size0) + : dimensions_(1) + { + sizes_.push_back(size0); + } + + NDRange(::size_t size0, ::size_t size1) + : dimensions_(2) + { + sizes_.push_back(size0); + sizes_.push_back(size1); + } + + NDRange(::size_t size0, ::size_t size1, ::size_t size2) + : dimensions_(3) + { + sizes_.push_back(size0); + sizes_.push_back(size1); + sizes_.push_back(size2); + } + + operator const ::size_t*() const { return (const ::size_t*) sizes_; } + ::size_t dimensions() const { return dimensions_; } +}; + +static const NDRange NullRange; + +/*! + * \struct LocalSpaceArg + * \brief Local address raper for use with Kernel::setArg + */ +struct LocalSpaceArg +{ + ::size_t size_; +}; + +namespace detail { + +template +struct KernelArgumentHandler +{ + static ::size_t size(const T&) { return sizeof(T); } + static T* ptr(T& value) { return &value; } +}; + +template <> +struct KernelArgumentHandler +{ + static ::size_t size(const LocalSpaceArg& value) { return value.size_; } + static void* ptr(LocalSpaceArg&) { return NULL; } +}; + +} +//! \endcond + +inline LocalSpaceArg +__local(::size_t size) +{ + LocalSpaceArg ret = { size }; + return ret; +} + +//class KernelFunctor; + +/*! \class Kernel + * \brief Kernel interface that implements cl_kernel + */ +class Kernel : public detail::Wrapper +{ +public: + inline Kernel(const Program& program, const char* name, cl_int* err = NULL); + + Kernel() { } + + Kernel(const Kernel& kernel) : detail::Wrapper(kernel) { } + + Kernel(const cl_kernel& kernel) : detail::Wrapper(kernel) { } + + Kernel& operator = (const Kernel& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Kernel& operator = (const cl_kernel& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_kernel_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetKernelInfo, object_, name, param), + __GET_KERNEL_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_kernel_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + template + cl_int getWorkGroupInfo( + const Device& device, cl_kernel_work_group_info name, T* param) const + { + return detail::errHandler( + detail::getInfo( + &::clGetKernelWorkGroupInfo, object_, device(), name, param), + __GET_KERNEL_WORK_GROUP_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getWorkGroupInfo(const Device& device, cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_kernel_work_group_info, name>::param_type param; + cl_int result = getWorkGroupInfo(device, name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + template + cl_int setArg(cl_uint index, T value) + { + return detail::errHandler( + ::clSetKernelArg( + object_, + index, + detail::KernelArgumentHandler::size(value), + detail::KernelArgumentHandler::ptr(value)), + __SET_KERNEL_ARGS_ERR); + } + + cl_int setArg(cl_uint index, ::size_t size, void* argPtr) + { + return detail::errHandler( + ::clSetKernelArg(object_, index, size, argPtr), + __SET_KERNEL_ARGS_ERR); + } +}; + +__GET_INFO_HELPER_WITH_RETAIN(cl::Kernel) + +/*! \class Program + * \brief Program interface that implements cl_program. + */ +class Program : public detail::Wrapper +{ +public: + typedef VECTOR_CLASS > Binaries; + typedef VECTOR_CLASS > Sources; + + Program( + const STRING_CLASS& source, + cl_int* err = NULL) + { + cl_int error; + + const char * strings = source.c_str(); + const ::size_t length = source.size(); + + Context context = Context::getDefault(err); + + object_ = ::clCreateProgramWithSource( + context(), (cl_uint)1, &strings, &length, &error); + + detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); + + if (error == CL_SUCCESS) { + + error = ::clBuildProgram( + object_, + 0, + NULL, + "", + NULL, + NULL); + + detail::errHandler(error, __BUILD_PROGRAM_ERR); + } + + if (err != NULL) { + *err = error; + } + } + + Program( + const STRING_CLASS& source, + bool build, + cl_int* err = NULL) + { + cl_int error; + + const char * strings = source.c_str(); + const ::size_t length = source.size(); + + Context context = Context::getDefault(err); + + object_ = ::clCreateProgramWithSource( + context(), (cl_uint)1, &strings, &length, &error); + + detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); + + if (error == CL_SUCCESS && build) { + + error = ::clBuildProgram( + object_, + 0, + NULL, + "", + NULL, + NULL); + + detail::errHandler(error, __BUILD_PROGRAM_ERR); + } + + if (err != NULL) { + *err = error; + } + } + + Program( + const Context& context, + const STRING_CLASS& source, + bool build = false, + cl_int* err = NULL) + { + cl_int error; + + const char * strings = source.c_str(); + const ::size_t length = source.size(); + + object_ = ::clCreateProgramWithSource( + context(), (cl_uint)1, &strings, &length, &error); + + detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); + + if (error == CL_SUCCESS && build) { + + error = ::clBuildProgram( + object_, + 0, + NULL, + "", + NULL, + NULL); + + detail::errHandler(error, __BUILD_PROGRAM_ERR); + } + + if (err != NULL) { + *err = error; + } + } + + Program( + const Context& context, + const Sources& sources, + cl_int* err = NULL) + { + cl_int error; + + const ::size_t n = (::size_t)sources.size(); + ::size_t* lengths = (::size_t*) alloca(n * sizeof(::size_t)); + const char** strings = (const char**) alloca(n * sizeof(const char*)); + + for (::size_t i = 0; i < n; ++i) { + strings[i] = sources[(int)i].first; + lengths[i] = sources[(int)i].second; + } + + object_ = ::clCreateProgramWithSource( + context(), (cl_uint)n, strings, lengths, &error); + + detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); + if (err != NULL) { + *err = error; + } + } + + Program( + const Context& context, + const VECTOR_CLASS& devices, + const Binaries& binaries, + VECTOR_CLASS* binaryStatus = NULL, + cl_int* err = NULL) + { + cl_int error; + const ::size_t n = binaries.size(); + ::size_t* lengths = (::size_t*) alloca(n * sizeof(::size_t)); + const unsigned char** images = (const unsigned char**) alloca(n * sizeof(const void*)); + + for (::size_t i = 0; i < n; ++i) { + images[i] = (const unsigned char*)binaries[(int)i].first; + lengths[i] = binaries[(int)i].second; + } + + object_ = ::clCreateProgramWithBinary( + context(), (cl_uint) devices.size(), + (cl_device_id*)&devices.front(), + lengths, images, binaryStatus != NULL + ? (cl_int*) &binaryStatus->front() + : NULL, &error); + + detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR); + if (err != NULL) { + *err = error; + } + } + + Program() { } + + Program(const Program& program) : detail::Wrapper(program) { } + + Program(const cl_program& program) : detail::Wrapper(program) { } + + Program& operator = (const Program& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + Program& operator = (const cl_program& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + cl_int build( + const VECTOR_CLASS& devices, + const char* options = NULL, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, + void* data = NULL) const + { + return detail::errHandler( + ::clBuildProgram( + object_, + (cl_uint) + devices.size(), + (cl_device_id*)&devices.front(), + options, + notifyFptr, + data), + __BUILD_PROGRAM_ERR); + } + + cl_int build( + const char* options = NULL, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, + void* data = NULL) const + { + return detail::errHandler( + ::clBuildProgram( + object_, + 0, + NULL, + options, + notifyFptr, + data), + __BUILD_PROGRAM_ERR); + } + + template + cl_int getInfo(cl_program_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetProgramInfo, object_, name, param), + __GET_PROGRAM_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_program_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + template + cl_int getBuildInfo( + const Device& device, cl_program_build_info name, T* param) const + { + return detail::errHandler( + detail::getInfo( + &::clGetProgramBuildInfo, object_, device(), name, param), + __GET_PROGRAM_BUILD_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getBuildInfo(const Device& device, cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_program_build_info, name>::param_type param; + cl_int result = getBuildInfo(device, name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + cl_int createKernels(VECTOR_CLASS* kernels) + { + cl_uint numKernels; + cl_int err = ::clCreateKernelsInProgram(object_, 0, NULL, &numKernels); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR); + } + + Kernel* value = (Kernel*) alloca(numKernels * sizeof(Kernel)); + err = ::clCreateKernelsInProgram( + object_, numKernels, (cl_kernel*) value, NULL); + if (err != CL_SUCCESS) { + return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR); + } + + kernels->assign(&value[0], &value[numKernels]); + return CL_SUCCESS; + } +}; + +template<> +inline VECTOR_CLASS cl::Program::getInfo(cl_int* err) const +{ + VECTOR_CLASS< ::size_t> sizes = getInfo(); + VECTOR_CLASS binaries; + for (VECTOR_CLASS< ::size_t>::iterator s = sizes.begin(); s != sizes.end(); ++s) + { + char *ptr = NULL; + if (*s != 0) + ptr = new char[*s]; + binaries.push_back(ptr); + } + + cl_int result = getInfo(CL_PROGRAM_BINARIES, &binaries); + if (err != NULL) { + *err = result; + } + return binaries; +} + +__GET_INFO_HELPER_WITH_RETAIN(cl::Program) + +inline Kernel::Kernel(const Program& program, const char* name, cl_int* err) +{ + cl_int error; + + object_ = ::clCreateKernel(program(), name, &error); + detail::errHandler(error, __CREATE_KERNEL_ERR); + + if (err != NULL) { + *err = error; + } + +} + +/*! \class CommandQueue + * \brief CommandQueue interface for cl_command_queue. + */ +class CommandQueue : public detail::Wrapper +{ +private: + static volatile int default_initialized_; + static CommandQueue default_; + static volatile cl_int default_error_; +public: + CommandQueue( + cl_command_queue_properties properties, + cl_int* err = NULL) + { + cl_int error; + + Context context = Context::getDefault(&error); + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + + if (error != CL_SUCCESS) { + if (err != NULL) { + *err = error; + } + } + else { + Device device = context.getInfo()[0]; + + object_ = ::clCreateCommandQueue( + context(), device(), properties, &error); + + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + if (err != NULL) { + *err = error; + } + } + } + + CommandQueue( + const Context& context, + const Device& device, + cl_command_queue_properties properties = 0, + cl_int* err = NULL) + { + cl_int error; + object_ = ::clCreateCommandQueue( + context(), device(), properties, &error); + + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + if (err != NULL) { + *err = error; + } + } + + static CommandQueue getDefault(cl_int * err = NULL) + { + int state = detail::compare_exchange( + &default_initialized_, + __DEFAULT_BEING_INITIALIZED, __DEFAULT_NOT_INITIALIZED); + + if (state & __DEFAULT_INITIALIZED) { + if (err != NULL) { + *err = default_error_; + } + return default_; + } + + if (state & __DEFAULT_BEING_INITIALIZED) { + // Assume writes will propagate eventually... + while(default_initialized_ != __DEFAULT_INITIALIZED) { + ; + } + + if (err != NULL) { + *err = default_error_; + } + return default_; + } + + cl_int error; + + Context context = Context::getDefault(&error); + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + + if (error != CL_SUCCESS) { + if (err != NULL) { + *err = error; + } + } + else { + Device device = context.getInfo()[0]; + + + default_ = CommandQueue(context, device, 0, &error); + + detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); + if (err != NULL) { + *err = error; + } + } + + default_error_ = error; + // Assume writes will propagate eventually... + default_initialized_ = __DEFAULT_INITIALIZED; + if (err != NULL) { + *err = default_error_; + } + return default_; + + } + + CommandQueue() { } + + CommandQueue(const CommandQueue& commandQueue) : detail::Wrapper(commandQueue) { } + + CommandQueue(const cl_command_queue& commandQueue) : detail::Wrapper(commandQueue) { } + + CommandQueue& operator = (const CommandQueue& rhs) + { + if (this != &rhs) { + detail::Wrapper::operator=(rhs); + } + return *this; + } + + CommandQueue& operator = (const cl_command_queue& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_command_queue_info name, T* param) const + { + return detail::errHandler( + detail::getInfo( + &::clGetCommandQueueInfo, object_, name, param), + __GET_COMMAND_QUEUE_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = NULL) const + { + typename detail::param_traits< + detail::cl_command_queue_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != NULL) { + *err = result; + } + return param; + } + + cl_int enqueueReadBuffer( + const Buffer& buffer, + cl_bool blocking, + ::size_t offset, + ::size_t size, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueReadBuffer( + object_, buffer(), blocking, offset, size, + ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_READ_BUFFER_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueWriteBuffer( + const Buffer& buffer, + cl_bool blocking, + ::size_t offset, + ::size_t size, + const void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueWriteBuffer( + object_, buffer(), blocking, offset, size, + ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_WRITE_BUFFER_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueCopyBuffer( + const Buffer& src, + const Buffer& dst, + ::size_t src_offset, + ::size_t dst_offset, + ::size_t size, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueCopyBuffer( + object_, src(), dst(), src_offset, dst_offset, size, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQEUE_COPY_BUFFER_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + +#if defined(CL_VERSION_1_1) + cl_int enqueueReadBufferRect( + const Buffer& buffer, + cl_bool blocking, + const size_t<3>& buffer_offset, + const size_t<3>& host_offset, + const size_t<3>& region, + ::size_t buffer_row_pitch, + ::size_t buffer_slice_pitch, + ::size_t host_row_pitch, + ::size_t host_slice_pitch, + void *ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueReadBufferRect( + object_, + buffer(), + blocking, + (const ::size_t *)buffer_offset, + (const ::size_t *)host_offset, + (const ::size_t *)region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_READ_BUFFER_RECT_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + + cl_int enqueueWriteBufferRect( + const Buffer& buffer, + cl_bool blocking, + const size_t<3>& buffer_offset, + const size_t<3>& host_offset, + const size_t<3>& region, + ::size_t buffer_row_pitch, + ::size_t buffer_slice_pitch, + ::size_t host_row_pitch, + ::size_t host_slice_pitch, + void *ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueWriteBufferRect( + object_, + buffer(), + blocking, + (const ::size_t *)buffer_offset, + (const ::size_t *)host_offset, + (const ::size_t *)region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_WRITE_BUFFER_RECT_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueCopyBufferRect( + const Buffer& src, + const Buffer& dst, + const size_t<3>& src_origin, + const size_t<3>& dst_origin, + const size_t<3>& region, + ::size_t src_row_pitch, + ::size_t src_slice_pitch, + ::size_t dst_row_pitch, + ::size_t dst_slice_pitch, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueCopyBufferRect( + object_, + src(), + dst(), + (const ::size_t *)src_origin, + (const ::size_t *)dst_origin, + (const ::size_t *)region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQEUE_COPY_BUFFER_RECT_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } +#endif + + cl_int enqueueReadImage( + const Image& image, + cl_bool blocking, + const size_t<3>& origin, + const size_t<3>& region, + ::size_t row_pitch, + ::size_t slice_pitch, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueReadImage( + object_, image(), blocking, (const ::size_t *) origin, + (const ::size_t *) region, row_pitch, slice_pitch, ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_READ_IMAGE_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueWriteImage( + const Image& image, + cl_bool blocking, + const size_t<3>& origin, + const size_t<3>& region, + ::size_t row_pitch, + ::size_t slice_pitch, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueWriteImage( + object_, image(), blocking, (const ::size_t *) origin, + (const ::size_t *) region, row_pitch, slice_pitch, ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_WRITE_IMAGE_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueCopyImage( + const Image& src, + const Image& dst, + const size_t<3>& src_origin, + const size_t<3>& dst_origin, + const size_t<3>& region, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueCopyImage( + object_, src(), dst(), (const ::size_t *) src_origin, + (const ::size_t *)dst_origin, (const ::size_t *) region, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_COPY_IMAGE_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueCopyImageToBuffer( + const Image& src, + const Buffer& dst, + const size_t<3>& src_origin, + const size_t<3>& region, + ::size_t dst_offset, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueCopyImageToBuffer( + object_, src(), dst(), (const ::size_t *) src_origin, + (const ::size_t *) region, dst_offset, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueCopyBufferToImage( + const Buffer& src, + const Image& dst, + ::size_t src_offset, + const size_t<3>& dst_origin, + const size_t<3>& region, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueCopyBufferToImage( + object_, src(), dst(), src_offset, + (const ::size_t *) dst_origin, (const ::size_t *) region, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + void* enqueueMapBuffer( + const Buffer& buffer, + cl_bool blocking, + cl_map_flags flags, + ::size_t offset, + ::size_t size, + const VECTOR_CLASS* events = NULL, + Event* event = NULL, + cl_int* err = NULL) const + { + cl_int error; + void * result = ::clEnqueueMapBuffer( + object_, buffer(), blocking, flags, offset, size, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (cl_event*) event, + &error); + + detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); + if (err != NULL) { + *err = error; + } + return result; + } + + void* enqueueMapImage( + const Image& buffer, + cl_bool blocking, + cl_map_flags flags, + const size_t<3>& origin, + const size_t<3>& region, + ::size_t * row_pitch, + ::size_t * slice_pitch, + const VECTOR_CLASS* events = NULL, + Event* event = NULL, + cl_int* err = NULL) const + { + cl_int error; + void * result = ::clEnqueueMapImage( + object_, buffer(), blocking, flags, + (const ::size_t *) origin, (const ::size_t *) region, + row_pitch, slice_pitch, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (cl_event*) event, + &error); + + detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR); + if (err != NULL) { + *err = error; + } + return result; + } + + cl_int enqueueUnmapMemObject( + const Memory& memory, + void* mapped_ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueUnmapMemObject( + object_, memory(), mapped_ptr, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueNDRangeKernel( + const Kernel& kernel, + const NDRange& offset, + const NDRange& global, + const NDRange& local = NullRange, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueNDRangeKernel( + object_, kernel(), (cl_uint) global.dimensions(), + offset.dimensions() != 0 ? (const ::size_t*) offset : NULL, + (const ::size_t*) global, + local.dimensions() != 0 ? (const ::size_t*) local : NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_NDRANGE_KERNEL_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueTask( + const Kernel& kernel, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueTask( + object_, kernel(), + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_TASK_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueNativeKernel( + void (CL_CALLBACK *userFptr)(void *), + std::pair args, + const VECTOR_CLASS* mem_objects = NULL, + const VECTOR_CLASS* mem_locs = NULL, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_mem * mems = (mem_objects != NULL && mem_objects->size() > 0) + ? (cl_mem*) alloca(mem_objects->size() * sizeof(cl_mem)) + : NULL; + + if (mems != NULL) { + for (unsigned int i = 0; i < mem_objects->size(); i++) { + mems[i] = ((*mem_objects)[i])(); + } + } + + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueNativeKernel( + object_, userFptr, args.first, args.second, + (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, + mems, + (mem_locs != NULL) ? (const void **) &mem_locs->front() : NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_NATIVE_KERNEL); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueMarker(Event* event = NULL) const + { + return detail::errHandler( + ::clEnqueueMarker(object_, (cl_event*) event), + __ENQUEUE_MARKER_ERR); + } + + cl_int enqueueWaitForEvents(const VECTOR_CLASS& events) const + { + return detail::errHandler( + ::clEnqueueWaitForEvents( + object_, + (cl_uint) events.size(), + (const cl_event*) &events.front()), + __ENQUEUE_WAIT_FOR_EVENTS_ERR); + } + + cl_int enqueueAcquireGLObjects( + const VECTOR_CLASS* mem_objects = NULL, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueAcquireGLObjects( + object_, + (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_ACQUIRE_GL_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueReleaseGLObjects( + const VECTOR_CLASS* mem_objects = NULL, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + cl_event tmp; + cl_int err = detail::errHandler( + ::clEnqueueReleaseGLObjects( + object_, + (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_RELEASE_GL_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + +#if defined (USE_DX_INTEROP) +typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueAcquireD3D10ObjectsKHR)( + 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); +typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)( + 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); + + cl_int enqueueAcquireD3D10Objects( + const VECTOR_CLASS* mem_objects = NULL, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + static PFN_clEnqueueAcquireD3D10ObjectsKHR pfn_clEnqueueAcquireD3D10ObjectsKHR = NULL; + __INIT_CL_EXT_FCN_PTR(clEnqueueAcquireD3D10ObjectsKHR); + + cl_event tmp; + cl_int err = detail::errHandler( + pfn_clEnqueueAcquireD3D10ObjectsKHR( + object_, + (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_ACQUIRE_GL_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueReleaseD3D10Objects( + const VECTOR_CLASS* mem_objects = NULL, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) const + { + static PFN_clEnqueueReleaseD3D10ObjectsKHR pfn_clEnqueueReleaseD3D10ObjectsKHR = NULL; + __INIT_CL_EXT_FCN_PTR(clEnqueueReleaseD3D10ObjectsKHR); + + cl_event tmp; + cl_int err = detail::errHandler( + pfn_clEnqueueReleaseD3D10ObjectsKHR( + object_, + (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL, + (events != NULL) ? (cl_uint) events->size() : 0, + (events != NULL) ? (cl_event*) &events->front() : NULL, + (event != NULL) ? &tmp : NULL), + __ENQUEUE_RELEASE_GL_ERR); + + if (event != NULL && err == CL_SUCCESS) + *event = tmp; + + return err; + } +#endif + + cl_int enqueueBarrier() const + { + return detail::errHandler( + ::clEnqueueBarrier(object_), + __ENQUEUE_BARRIER_ERR); + } + + cl_int flush() const + { + return detail::errHandler(::clFlush(object_), __FLUSH_ERR); + } + + cl_int finish() const + { + return detail::errHandler(::clFinish(object_), __FINISH_ERR); + } +}; + +__GET_INFO_HELPER_WITH_RETAIN(cl::CommandQueue) + +#ifdef _WIN32 +__declspec(selectany) volatile int CommandQueue::default_initialized_ = __DEFAULT_NOT_INITIALIZED; +__declspec(selectany) CommandQueue CommandQueue::default_; +__declspec(selectany) volatile cl_int CommandQueue::default_error_ = CL_SUCCESS; +#else +__attribute__((weak)) volatile int CommandQueue::default_initialized_ = __DEFAULT_NOT_INITIALIZED; +__attribute__((weak)) CommandQueue CommandQueue::default_; +__attribute__((weak)) volatile cl_int CommandQueue::default_error_ = CL_SUCCESS; +#endif + +inline cl_int enqueueReadBuffer( + const Buffer& buffer, + cl_bool blocking, + ::size_t offset, + ::size_t size, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueReadBuffer(buffer, blocking, offset, size, ptr, events, event); +} + +inline cl_int enqueueWriteBuffer( + const Buffer& buffer, + cl_bool blocking, + ::size_t offset, + ::size_t size, + const void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueWriteBuffer(buffer, blocking, offset, size, ptr, events, event); +} + +inline cl_int enqueueCopyBuffer( + const Buffer& src, + const Buffer& dst, + ::size_t src_offset, + ::size_t dst_offset, + ::size_t size, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueCopyBuffer(src, dst, src_offset, dst_offset, size, events, event); +} + +#if defined(CL_VERSION_1_1) +inline cl_int enqueueReadBufferRect( + const Buffer& buffer, + cl_bool blocking, + const size_t<3>& buffer_offset, + const size_t<3>& host_offset, + const size_t<3>& region, + ::size_t buffer_row_pitch, + ::size_t buffer_slice_pitch, + ::size_t host_row_pitch, + ::size_t host_slice_pitch, + void *ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueReadBufferRect( + buffer, + blocking, + buffer_offset, + host_offset, + region, + buffer_row_pitch, + host_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); +} + +inline cl_int enqueueWriteBufferRect( + const Buffer& buffer, + cl_bool blocking, + const size_t<3>& buffer_offset, + const size_t<3>& host_offset, + const size_t<3>& region, + ::size_t buffer_row_pitch, + ::size_t buffer_slice_pitch, + ::size_t host_row_pitch, + ::size_t host_slice_pitch, + void *ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueWriteBufferRect( + buffer, + blocking, + buffer_offset, + host_offset, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); +} + +inline cl_int enqueueCopyBufferRect( + const Buffer& src, + const Buffer& dst, + const size_t<3>& src_origin, + const size_t<3>& dst_origin, + const size_t<3>& region, + ::size_t src_row_pitch, + ::size_t src_slice_pitch, + ::size_t dst_row_pitch, + ::size_t dst_slice_pitch, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueCopyBufferRect( + src, + dst, + src_origin, + dst_origin, + region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + events, + event); +} +#endif + +inline cl_int enqueueReadImage( + const Image& image, + cl_bool blocking, + const size_t<3>& origin, + const size_t<3>& region, + ::size_t row_pitch, + ::size_t slice_pitch, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueReadImage( + image, + blocking, + origin, + region, + row_pitch, + slice_pitch, + ptr, + events, + event); +} + +inline cl_int enqueueWriteImage( + const Image& image, + cl_bool blocking, + const size_t<3>& origin, + const size_t<3>& region, + ::size_t row_pitch, + ::size_t slice_pitch, + void* ptr, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueWriteImage( + image, + blocking, + origin, + region, + row_pitch, + slice_pitch, + ptr, + events, + event); +} + +inline cl_int enqueueCopyImage( + const Image& src, + const Image& dst, + const size_t<3>& src_origin, + const size_t<3>& dst_origin, + const size_t<3>& region, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueCopyImage( + src, + dst, + src_origin, + dst_origin, + region, + events, + event); +} + +inline cl_int enqueueCopyImageToBuffer( + const Image& src, + const Buffer& dst, + const size_t<3>& src_origin, + const size_t<3>& region, + ::size_t dst_offset, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueCopyImageToBuffer( + src, + dst, + src_origin, + region, + dst_offset, + events, + event); +} + +inline cl_int enqueueCopyBufferToImage( + const Buffer& src, + const Image& dst, + ::size_t src_offset, + const size_t<3>& dst_origin, + const size_t<3>& region, + const VECTOR_CLASS* events = NULL, + Event* event = NULL) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.enqueueCopyBufferToImage( + src, + dst, + src_offset, + dst_origin, + region, + events, + event); +} + + +inline cl_int flush(void) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return queue.flush(); +} + +inline cl_int finish(void) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + + return queue.finish(); +} + + +// Kernel Functor support +// New interface as of September 2011 +// Requires the C++11 std::tr1::function (note do not support TR1) +// Visual Studio 2010 and GCC 4.2 + +#if (defined(_WIN32) && (_MSC_VER >= 1600)) || defined(linux) || defined(__APPLE__) || defined(__MACOSX) +struct EnqueueArgs +{ + CommandQueue queue_; + NDRange offset_; + NDRange global_; + NDRange local_; + + EnqueueArgs(NDRange global) : + queue_(CommandQueue::getDefault()), + offset_(NullRange), + global_(global), + local_(NullRange) + { + + } + + EnqueueArgs(NDRange global, NDRange local) : + queue_(CommandQueue::getDefault()), + offset_(NullRange), + global_(global), + local_(local) + { + + } + + EnqueueArgs(NDRange offset, NDRange global, NDRange local) : + queue_(CommandQueue::getDefault()), + offset_(offset), + global_(global), + local_(local) + { + + } + + EnqueueArgs(CommandQueue queue, NDRange global) : + queue_(queue), + offset_(NullRange), + global_(global), + local_(NullRange) + { + + } + + EnqueueArgs(CommandQueue queue, NDRange global, NDRange local) : + queue_(queue), + offset_(NullRange), + global_(global), + local_(local) + { + + } + + EnqueueArgs(CommandQueue queue, NDRange offset, NDRange global, NDRange local) : + queue_(queue), + offset_(offset), + global_(global), + local_(local) + { + + } +}; + +namespace detail { + +class NullType {}; + +template +struct SetArg +{ + static void set (Kernel kernel, T0 arg) + { + kernel.setArg(index, arg); + } +}; + + +template +struct SetArg +{ + static void set (Kernel kernel, NullType) + { + } +}; + +template +struct MoveToDevice +{ + static void move(CommandQueue, T) + { + } +}; + + +template +struct MoveFromDevice +{ + static void move(CommandQueue, T) + { + } +}; + + +template < + typename T0, typename T1, typename T2, typename T3, + typename T4, typename T5, typename T6, typename T7, + typename T8, typename T9, typename T10, typename T11, + typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, + typename T20, typename T21, typename T22, typename T23, + typename T24, typename T25, typename T26, typename T27, + typename T28, typename T29, typename T30, typename T31, + typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, + typename T40, typename T41, typename T42, typename T43, + typename T44, typename T45, typename T46, typename T47, + typename T48, typename T49, typename T50, typename T51, + typename T52, typename T53, typename T54, typename T55, + typename T56, typename T57, typename T58, typename T59, + typename T60, typename T61, typename T62, typename T63, + typename T64, typename T65, typename T66, typename T67, + typename T68, typename T69, typename T70, typename T71, + typename T72, typename T73, typename T74, typename T75, + typename T76, typename T77, typename T78, typename T79, + typename T80, typename T81, typename T82, typename T83, + typename T84, typename T85, typename T86, typename T87, + typename T88, typename T89, typename T90, typename T91, + typename T92, typename T93, typename T94, typename T95, + typename T96, typename T97, typename T98, typename T99, + typename T100, typename T101, typename T102, typename T103, + typename T104, typename T105, typename T106, typename T107, + typename T108, typename T109, typename T110, typename T111, + typename T112, typename T113, typename T114, typename T115, + typename T116, typename T117, typename T118, typename T119, + typename T120, typename T121, typename T122, typename T123, + typename T124, typename T125, typename T126, typename T127> +class KernelFunctorGlobal +{ +private: + Kernel kernel_; + +public: + KernelFunctorGlobal( + Kernel kernel, + cl_int * err = NULL) : + kernel_(kernel) + {} + + KernelFunctorGlobal( + const Program& program, + const STRING_CLASS name, + cl_int * err = NULL) : + kernel_(program, name.c_str(), err) + {} + + Event operator() ( + const EnqueueArgs& args, + T0 t0, + T1 t1 = NullType(), + T2 t2 = NullType(), + T3 t3 = NullType(), + T4 t4 = NullType(), + T5 t5 = NullType(), + T6 t6 = NullType(), + T7 t7 = NullType(), + T8 t8 = NullType(), + T9 t9 = NullType(), + T10 t10 = NullType(), + T11 t11 = NullType(), + T12 t12 = NullType(), + T13 t13 = NullType(), + T14 t14 = NullType(), + T15 t15 = NullType(), + T16 t16 = NullType(), + T17 t17 = NullType(), + T18 t18 = NullType(), + T19 t19 = NullType(), + T20 t20 = NullType(), + T21 t21 = NullType(), + T22 t22 = NullType(), + T23 t23 = NullType(), + T24 t24 = NullType(), + T25 t25 = NullType(), + T26 t26 = NullType(), + T27 t27 = NullType(), + T28 t28 = NullType(), + T29 t29 = NullType(), + T30 t30 = NullType(), + T31 t31 = NullType(), + T32 t32 = NullType(), + T33 t33 = NullType(), + T34 t34 = NullType(), + T35 t35 = NullType(), + T36 t36 = NullType(), + T37 t37 = NullType(), + T38 t38 = NullType(), + T39 t39 = NullType(), + T40 t40 = NullType(), + T41 t41 = NullType(), + T42 t42 = NullType(), + T43 t43 = NullType(), + T44 t44 = NullType(), + T45 t45 = NullType(), + T46 t46 = NullType(), + T47 t47 = NullType(), + T48 t48 = NullType(), + T49 t49 = NullType(), + T50 t50 = NullType(), + T51 t51 = NullType(), + T52 t52 = NullType(), + T53 t53 = NullType(), + T54 t54 = NullType(), + T55 t55 = NullType(), + T56 t56 = NullType(), + T57 t57 = NullType(), + T58 t58 = NullType(), + T59 t59 = NullType(), + T60 t60 = NullType(), + T61 t61 = NullType(), + T62 t62 = NullType(), + T63 t63 = NullType(), + T64 t64 = NullType(), + T65 t65 = NullType(), + T66 t66 = NullType(), + T67 t67 = NullType(), + T68 t68 = NullType(), + T69 t69 = NullType(), + T70 t70 = NullType(), + T71 t71 = NullType(), + T72 t72 = NullType(), + T73 t73 = NullType(), + T74 t74 = NullType(), + T75 t75 = NullType(), + T76 t76 = NullType(), + T77 t77 = NullType(), + T78 t78 = NullType(), + T79 t79 = NullType(), + T80 t80 = NullType(), + T81 t81 = NullType(), + T82 t82 = NullType(), + T83 t83 = NullType(), + T84 t84 = NullType(), + T85 t85 = NullType(), + T86 t86 = NullType(), + T87 t87 = NullType(), + T88 t88 = NullType(), + T89 t89 = NullType(), + T90 t90 = NullType(), + T91 t91 = NullType(), + T92 t92 = NullType(), + T93 t93 = NullType(), + T94 t94 = NullType(), + T95 t95 = NullType(), + T96 t96 = NullType(), + T97 t97 = NullType(), + T98 t98 = NullType(), + T99 t99 = NullType(), + T100 t100 = NullType(), + T101 t101 = NullType(), + T102 t102 = NullType(), + T103 t103 = NullType(), + T104 t104 = NullType(), + T105 t105 = NullType(), + T106 t106 = NullType(), + T107 t107 = NullType(), + T108 t108 = NullType(), + T109 t109 = NullType(), + T110 t110 = NullType(), + T111 t111 = NullType(), + T112 t112 = NullType(), + T113 t113 = NullType(), + T114 t114 = NullType(), + T115 t115 = NullType(), + T116 t116 = NullType(), + T117 t117 = NullType(), + T118 t118 = NullType(), + T119 t119 = NullType(), + T120 t120 = NullType(), + T121 t121 = NullType(), + T122 t122 = NullType(), + T123 t123 = NullType(), + T124 t124 = NullType(), + T125 t125 = NullType(), + T126 t126 = NullType(), + T127 t127 = NullType()) + { + Event event; + SetArg<0, T0>::set(kernel_, t0); + SetArg<1, T1>::set(kernel_, t1); + SetArg<2, T2>::set(kernel_, t2); + SetArg<3, T3>::set(kernel_, t3); + SetArg<4, T4>::set(kernel_, t4); + SetArg<5, T5>::set(kernel_, t5); + SetArg<6, T6>::set(kernel_, t6); + SetArg<7, T7>::set(kernel_, t7); + SetArg<8, T8>::set(kernel_, t8); + SetArg<9, T9>::set(kernel_, t9); + SetArg<10, T10>::set(kernel_, t10); + SetArg<11, T11>::set(kernel_, t11); + SetArg<12, T12>::set(kernel_, t12); + SetArg<13, T13>::set(kernel_, t13); + SetArg<14, T14>::set(kernel_, t14); + SetArg<15, T15>::set(kernel_, t15); + SetArg<16, T16>::set(kernel_, t16); + SetArg<17, T17>::set(kernel_, t17); + SetArg<18, T18>::set(kernel_, t18); + SetArg<19, T19>::set(kernel_, t19); + SetArg<20, T20>::set(kernel_, t20); + SetArg<21, T21>::set(kernel_, t21); + SetArg<22, T22>::set(kernel_, t22); + SetArg<23, T23>::set(kernel_, t23); + SetArg<24, T24>::set(kernel_, t24); + SetArg<25, T25>::set(kernel_, t25); + SetArg<26, T26>::set(kernel_, t26); + SetArg<27, T27>::set(kernel_, t27); + SetArg<28, T28>::set(kernel_, t28); + SetArg<29, T29>::set(kernel_, t29); + SetArg<30, T30>::set(kernel_, t30); + SetArg<31, T31>::set(kernel_, t31); + SetArg<32, T32>::set(kernel_, t32); + SetArg<33, T33>::set(kernel_, t33); + SetArg<34, T34>::set(kernel_, t34); + SetArg<35, T35>::set(kernel_, t35); + SetArg<36, T36>::set(kernel_, t36); + SetArg<37, T37>::set(kernel_, t37); + SetArg<38, T38>::set(kernel_, t38); + SetArg<39, T39>::set(kernel_, t39); + SetArg<40, T40>::set(kernel_, t40); + SetArg<41, T41>::set(kernel_, t41); + SetArg<42, T42>::set(kernel_, t42); + SetArg<43, T43>::set(kernel_, t43); + SetArg<44, T44>::set(kernel_, t44); + SetArg<45, T45>::set(kernel_, t45); + SetArg<46, T46>::set(kernel_, t46); + SetArg<47, T47>::set(kernel_, t47); + SetArg<48, T48>::set(kernel_, t48); + SetArg<49, T49>::set(kernel_, t49); + SetArg<50, T50>::set(kernel_, t50); + SetArg<51, T51>::set(kernel_, t51); + SetArg<52, T52>::set(kernel_, t52); + SetArg<53, T53>::set(kernel_, t53); + SetArg<54, T54>::set(kernel_, t54); + SetArg<55, T55>::set(kernel_, t55); + SetArg<56, T56>::set(kernel_, t56); + SetArg<57, T57>::set(kernel_, t57); + SetArg<58, T58>::set(kernel_, t58); + SetArg<59, T59>::set(kernel_, t59); + SetArg<60, T60>::set(kernel_, t60); + SetArg<61, T61>::set(kernel_, t61); + SetArg<62, T62>::set(kernel_, t62); + SetArg<63, T63>::set(kernel_, t63); + SetArg<64, T64>::set(kernel_, t64); + SetArg<65, T65>::set(kernel_, t65); + SetArg<66, T66>::set(kernel_, t66); + SetArg<67, T67>::set(kernel_, t67); + SetArg<68, T68>::set(kernel_, t68); + SetArg<69, T69>::set(kernel_, t69); + SetArg<70, T70>::set(kernel_, t70); + SetArg<71, T71>::set(kernel_, t71); + SetArg<72, T72>::set(kernel_, t72); + SetArg<73, T73>::set(kernel_, t73); + SetArg<74, T74>::set(kernel_, t74); + SetArg<75, T75>::set(kernel_, t75); + SetArg<76, T76>::set(kernel_, t76); + SetArg<77, T77>::set(kernel_, t77); + SetArg<78, T78>::set(kernel_, t78); + SetArg<79, T79>::set(kernel_, t79); + SetArg<80, T80>::set(kernel_, t80); + SetArg<81, T81>::set(kernel_, t81); + SetArg<82, T82>::set(kernel_, t82); + SetArg<83, T83>::set(kernel_, t83); + SetArg<84, T84>::set(kernel_, t84); + SetArg<85, T85>::set(kernel_, t85); + SetArg<86, T86>::set(kernel_, t86); + SetArg<87, T87>::set(kernel_, t87); + SetArg<88, T88>::set(kernel_, t88); + SetArg<89, T89>::set(kernel_, t89); + SetArg<90, T90>::set(kernel_, t90); + SetArg<91, T91>::set(kernel_, t91); + SetArg<92, T92>::set(kernel_, t92); + SetArg<93, T93>::set(kernel_, t93); + SetArg<94, T94>::set(kernel_, t94); + SetArg<95, T95>::set(kernel_, t95); + SetArg<96, T96>::set(kernel_, t96); + SetArg<97, T97>::set(kernel_, t97); + SetArg<98, T98>::set(kernel_, t98); + SetArg<99, T99>::set(kernel_, t99); + SetArg<100, T100>::set(kernel_, t100); + SetArg<101, T101>::set(kernel_, t101); + SetArg<102, T102>::set(kernel_, t102); + SetArg<103, T103>::set(kernel_, t103); + SetArg<104, T104>::set(kernel_, t104); + SetArg<105, T105>::set(kernel_, t105); + SetArg<106, T106>::set(kernel_, t106); + SetArg<107, T107>::set(kernel_, t107); + SetArg<108, T108>::set(kernel_, t108); + SetArg<109, T109>::set(kernel_, t109); + SetArg<110, T110>::set(kernel_, t110); + SetArg<111, T111>::set(kernel_, t111); + SetArg<112, T112>::set(kernel_, t112); + SetArg<113, T113>::set(kernel_, t113); + SetArg<114, T114>::set(kernel_, t114); + SetArg<115, T115>::set(kernel_, t115); + SetArg<116, T116>::set(kernel_, t116); + SetArg<117, T117>::set(kernel_, t117); + SetArg<118, T118>::set(kernel_, t118); + SetArg<119, T119>::set(kernel_, t119); + SetArg<120, T120>::set(kernel_, t120); + SetArg<121, T121>::set(kernel_, t121); + SetArg<122, T122>::set(kernel_, t122); + SetArg<123, T123>::set(kernel_, t123); + SetArg<124, T124>::set(kernel_, t124); + SetArg<125, T125>::set(kernel_, t125); + SetArg<126, T126>::set(kernel_, t126); + SetArg<127, T127>::set(kernel_, t127); + + // Move any arguments that need moving + MoveToDevice::move(args.queue_, t0); + MoveToDevice::move(args.queue_, t1); + MoveToDevice::move(args.queue_, t2); + MoveToDevice::move(args.queue_, t3); + MoveToDevice::move(args.queue_, t4); + MoveToDevice::move(args.queue_, t5); + MoveToDevice::move(args.queue_, t6); + MoveToDevice::move(args.queue_, t7); + MoveToDevice::move(args.queue_, t8); + MoveToDevice::move(args.queue_, t9); + MoveToDevice::move(args.queue_, t10); + MoveToDevice::move(args.queue_, t11); + MoveToDevice::move(args.queue_, t12); + MoveToDevice::move(args.queue_, t13); + MoveToDevice::move(args.queue_, t14); + MoveToDevice::move(args.queue_, t15); + MoveToDevice::move(args.queue_, t16); + MoveToDevice::move(args.queue_, t17); + MoveToDevice::move(args.queue_, t18); + MoveToDevice::move(args.queue_, t19); + MoveToDevice::move(args.queue_, t20); + MoveToDevice::move(args.queue_, t21); + MoveToDevice::move(args.queue_, t22); + MoveToDevice::move(args.queue_, t23); + MoveToDevice::move(args.queue_, t24); + MoveToDevice::move(args.queue_, t25); + MoveToDevice::move(args.queue_, t26); + MoveToDevice::move(args.queue_, t27); + MoveToDevice::move(args.queue_, t28); + MoveToDevice::move(args.queue_, t29); + MoveToDevice::move(args.queue_, t30); + MoveToDevice::move(args.queue_, t31); + MoveToDevice::move(args.queue_, t32); + MoveToDevice::move(args.queue_, t33); + MoveToDevice::move(args.queue_, t34); + MoveToDevice::move(args.queue_, t35); + MoveToDevice::move(args.queue_, t36); + MoveToDevice::move(args.queue_, t37); + MoveToDevice::move(args.queue_, t38); + MoveToDevice::move(args.queue_, t39); + MoveToDevice::move(args.queue_, t40); + MoveToDevice::move(args.queue_, t41); + MoveToDevice::move(args.queue_, t42); + MoveToDevice::move(args.queue_, t43); + MoveToDevice::move(args.queue_, t44); + MoveToDevice::move(args.queue_, t45); + MoveToDevice::move(args.queue_, t46); + MoveToDevice::move(args.queue_, t47); + MoveToDevice::move(args.queue_, t48); + MoveToDevice::move(args.queue_, t49); + MoveToDevice::move(args.queue_, t50); + MoveToDevice::move(args.queue_, t51); + MoveToDevice::move(args.queue_, t52); + MoveToDevice::move(args.queue_, t53); + MoveToDevice::move(args.queue_, t54); + MoveToDevice::move(args.queue_, t55); + MoveToDevice::move(args.queue_, t56); + MoveToDevice::move(args.queue_, t57); + MoveToDevice::move(args.queue_, t58); + MoveToDevice::move(args.queue_, t59); + MoveToDevice::move(args.queue_, t60); + MoveToDevice::move(args.queue_, t61); + MoveToDevice::move(args.queue_, t62); + MoveToDevice::move(args.queue_, t63); + MoveToDevice::move(args.queue_, t64); + MoveToDevice::move(args.queue_, t65); + MoveToDevice::move(args.queue_, t66); + MoveToDevice::move(args.queue_, t67); + MoveToDevice::move(args.queue_, t68); + MoveToDevice::move(args.queue_, t69); + MoveToDevice::move(args.queue_, t70); + MoveToDevice::move(args.queue_, t71); + MoveToDevice::move(args.queue_, t72); + MoveToDevice::move(args.queue_, t73); + MoveToDevice::move(args.queue_, t74); + MoveToDevice::move(args.queue_, t75); + MoveToDevice::move(args.queue_, t76); + MoveToDevice::move(args.queue_, t77); + MoveToDevice::move(args.queue_, t78); + MoveToDevice::move(args.queue_, t79); + MoveToDevice::move(args.queue_, t80); + MoveToDevice::move(args.queue_, t81); + MoveToDevice::move(args.queue_, t82); + MoveToDevice::move(args.queue_, t83); + MoveToDevice::move(args.queue_, t84); + MoveToDevice::move(args.queue_, t85); + MoveToDevice::move(args.queue_, t86); + MoveToDevice::move(args.queue_, t87); + MoveToDevice::move(args.queue_, t88); + MoveToDevice::move(args.queue_, t89); + MoveToDevice::move(args.queue_, t90); + MoveToDevice::move(args.queue_, t91); + MoveToDevice::move(args.queue_, t92); + MoveToDevice::move(args.queue_, t93); + MoveToDevice::move(args.queue_, t94); + MoveToDevice::move(args.queue_, t95); + MoveToDevice::move(args.queue_, t96); + MoveToDevice::move(args.queue_, t97); + MoveToDevice::move(args.queue_, t98); + MoveToDevice::move(args.queue_, t99); + MoveToDevice::move(args.queue_, t100); + MoveToDevice::move(args.queue_, t101); + MoveToDevice::move(args.queue_, t102); + MoveToDevice::move(args.queue_, t103); + MoveToDevice::move(args.queue_, t104); + MoveToDevice::move(args.queue_, t105); + MoveToDevice::move(args.queue_, t106); + MoveToDevice::move(args.queue_, t107); + MoveToDevice::move(args.queue_, t108); + MoveToDevice::move(args.queue_, t109); + MoveToDevice::move(args.queue_, t110); + MoveToDevice::move(args.queue_, t111); + MoveToDevice::move(args.queue_, t112); + MoveToDevice::move(args.queue_, t113); + MoveToDevice::move(args.queue_, t114); + MoveToDevice::move(args.queue_, t115); + MoveToDevice::move(args.queue_, t116); + MoveToDevice::move(args.queue_, t117); + MoveToDevice::move(args.queue_, t118); + MoveToDevice::move(args.queue_, t119); + MoveToDevice::move(args.queue_, t120); + MoveToDevice::move(args.queue_, t121); + MoveToDevice::move(args.queue_, t122); + MoveToDevice::move(args.queue_, t123); + MoveToDevice::move(args.queue_, t124); + MoveToDevice::move(args.queue_, t125); + MoveToDevice::move(args.queue_, t126); + MoveToDevice::move(args.queue_, t127); + + args.queue_.enqueueNDRangeKernel( + kernel_, + args.offset_, + args.global_, + args.local_, + NULL, + &event); + + // Move any arguments that need moving + MoveFromDevice::move(args.queue_, t0); + MoveFromDevice::move(args.queue_, t1); + MoveFromDevice::move(args.queue_, t2); + MoveFromDevice::move(args.queue_, t3); + MoveFromDevice::move(args.queue_, t4); + MoveFromDevice::move(args.queue_, t5); + MoveFromDevice::move(args.queue_, t6); + MoveFromDevice::move(args.queue_, t7); + MoveFromDevice::move(args.queue_, t8); + MoveFromDevice::move(args.queue_, t9); + MoveFromDevice::move(args.queue_, t10); + MoveFromDevice::move(args.queue_, t11); + MoveFromDevice::move(args.queue_, t12); + MoveFromDevice::move(args.queue_, t13); + MoveFromDevice::move(args.queue_, t14); + MoveFromDevice::move(args.queue_, t15); + MoveFromDevice::move(args.queue_, t16); + MoveFromDevice::move(args.queue_, t17); + MoveFromDevice::move(args.queue_, t18); + MoveFromDevice::move(args.queue_, t19); + MoveFromDevice::move(args.queue_, t20); + MoveFromDevice::move(args.queue_, t21); + MoveFromDevice::move(args.queue_, t22); + MoveFromDevice::move(args.queue_, t23); + MoveFromDevice::move(args.queue_, t24); + MoveFromDevice::move(args.queue_, t25); + MoveFromDevice::move(args.queue_, t26); + MoveFromDevice::move(args.queue_, t27); + MoveFromDevice::move(args.queue_, t28); + MoveFromDevice::move(args.queue_, t29); + MoveFromDevice::move(args.queue_, t30); + MoveFromDevice::move(args.queue_, t31); + MoveFromDevice::move(args.queue_, t32); + MoveFromDevice::move(args.queue_, t33); + MoveFromDevice::move(args.queue_, t34); + MoveFromDevice::move(args.queue_, t35); + MoveFromDevice::move(args.queue_, t36); + MoveFromDevice::move(args.queue_, t37); + MoveFromDevice::move(args.queue_, t38); + MoveFromDevice::move(args.queue_, t39); + MoveFromDevice::move(args.queue_, t40); + MoveFromDevice::move(args.queue_, t41); + MoveFromDevice::move(args.queue_, t42); + MoveFromDevice::move(args.queue_, t43); + MoveFromDevice::move(args.queue_, t44); + MoveFromDevice::move(args.queue_, t45); + MoveFromDevice::move(args.queue_, t46); + MoveFromDevice::move(args.queue_, t47); + MoveFromDevice::move(args.queue_, t48); + MoveFromDevice::move(args.queue_, t49); + MoveFromDevice::move(args.queue_, t50); + MoveFromDevice::move(args.queue_, t51); + MoveFromDevice::move(args.queue_, t52); + MoveFromDevice::move(args.queue_, t53); + MoveFromDevice::move(args.queue_, t54); + MoveFromDevice::move(args.queue_, t55); + MoveFromDevice::move(args.queue_, t56); + MoveFromDevice::move(args.queue_, t57); + MoveFromDevice::move(args.queue_, t58); + MoveFromDevice::move(args.queue_, t59); + MoveFromDevice::move(args.queue_, t60); + MoveFromDevice::move(args.queue_, t61); + MoveFromDevice::move(args.queue_, t62); + MoveFromDevice::move(args.queue_, t63); + MoveFromDevice::move(args.queue_, t64); + MoveFromDevice::move(args.queue_, t65); + MoveFromDevice::move(args.queue_, t66); + MoveFromDevice::move(args.queue_, t67); + MoveFromDevice::move(args.queue_, t68); + MoveFromDevice::move(args.queue_, t69); + MoveFromDevice::move(args.queue_, t70); + MoveFromDevice::move(args.queue_, t71); + MoveFromDevice::move(args.queue_, t72); + MoveFromDevice::move(args.queue_, t73); + MoveFromDevice::move(args.queue_, t74); + MoveFromDevice::move(args.queue_, t75); + MoveFromDevice::move(args.queue_, t76); + MoveFromDevice::move(args.queue_, t77); + MoveFromDevice::move(args.queue_, t78); + MoveFromDevice::move(args.queue_, t79); + MoveFromDevice::move(args.queue_, t80); + MoveFromDevice::move(args.queue_, t81); + MoveFromDevice::move(args.queue_, t82); + MoveFromDevice::move(args.queue_, t83); + MoveFromDevice::move(args.queue_, t84); + MoveFromDevice::move(args.queue_, t85); + MoveFromDevice::move(args.queue_, t86); + MoveFromDevice::move(args.queue_, t87); + MoveFromDevice::move(args.queue_, t88); + MoveFromDevice::move(args.queue_, t89); + MoveFromDevice::move(args.queue_, t90); + MoveFromDevice::move(args.queue_, t91); + MoveFromDevice::move(args.queue_, t92); + MoveFromDevice::move(args.queue_, t93); + MoveFromDevice::move(args.queue_, t94); + MoveFromDevice::move(args.queue_, t95); + MoveFromDevice::move(args.queue_, t96); + MoveFromDevice::move(args.queue_, t97); + MoveFromDevice::move(args.queue_, t98); + MoveFromDevice::move(args.queue_, t99); + MoveFromDevice::move(args.queue_, t100); + MoveFromDevice::move(args.queue_, t101); + MoveFromDevice::move(args.queue_, t102); + MoveFromDevice::move(args.queue_, t103); + MoveFromDevice::move(args.queue_, t104); + MoveFromDevice::move(args.queue_, t105); + MoveFromDevice::move(args.queue_, t106); + MoveFromDevice::move(args.queue_, t107); + MoveFromDevice::move(args.queue_, t108); + MoveFromDevice::move(args.queue_, t109); + MoveFromDevice::move(args.queue_, t110); + MoveFromDevice::move(args.queue_, t111); + MoveFromDevice::move(args.queue_, t112); + MoveFromDevice::move(args.queue_, t113); + MoveFromDevice::move(args.queue_, t114); + MoveFromDevice::move(args.queue_, t115); + MoveFromDevice::move(args.queue_, t116); + MoveFromDevice::move(args.queue_, t117); + MoveFromDevice::move(args.queue_, t118); + MoveFromDevice::move(args.queue_, t119); + MoveFromDevice::move(args.queue_, t120); + MoveFromDevice::move(args.queue_, t121); + MoveFromDevice::move(args.queue_, t122); + MoveFromDevice::move(args.queue_, t123); + MoveFromDevice::move(args.queue_, t124); + MoveFromDevice::move(args.queue_, t125); + MoveFromDevice::move(args.queue_, t126); + MoveFromDevice::move(args.queue_, t127); + + return event; + } + + Event operator() ( + const EnqueueArgs& args, + const Event& waitEvent, + T0 t0, + T1 t1 = NullType(), + T2 t2 = NullType(), + T3 t3 = NullType(), + T4 t4 = NullType(), + T5 t5 = NullType(), + T6 t6 = NullType(), + T7 t7 = NullType(), + T8 t8 = NullType(), + T9 t9 = NullType(), + T10 t10 = NullType(), + T11 t11 = NullType(), + T12 t12 = NullType(), + T13 t13 = NullType(), + T14 t14 = NullType(), + T15 t15 = NullType(), + T16 t16 = NullType(), + T17 t17 = NullType(), + T18 t18 = NullType(), + T19 t19 = NullType(), + T20 t20 = NullType(), + T21 t21 = NullType(), + T22 t22 = NullType(), + T23 t23 = NullType(), + T24 t24 = NullType(), + T25 t25 = NullType(), + T26 t26 = NullType(), + T27 t27 = NullType(), + T28 t28 = NullType(), + T29 t29 = NullType(), + T30 t30 = NullType(), + T31 t31 = NullType(), + T32 t32 = NullType(), + T33 t33 = NullType(), + T34 t34 = NullType(), + T35 t35 = NullType(), + T36 t36 = NullType(), + T37 t37 = NullType(), + T38 t38 = NullType(), + T39 t39 = NullType(), + T40 t40 = NullType(), + T41 t41 = NullType(), + T42 t42 = NullType(), + T43 t43 = NullType(), + T44 t44 = NullType(), + T45 t45 = NullType(), + T46 t46 = NullType(), + T47 t47 = NullType(), + T48 t48 = NullType(), + T49 t49 = NullType(), + T50 t50 = NullType(), + T51 t51 = NullType(), + T52 t52 = NullType(), + T53 t53 = NullType(), + T54 t54 = NullType(), + T55 t55 = NullType(), + T56 t56 = NullType(), + T57 t57 = NullType(), + T58 t58 = NullType(), + T59 t59 = NullType(), + T60 t60 = NullType(), + T61 t61 = NullType(), + T62 t62 = NullType(), + T63 t63 = NullType(), + T64 t64 = NullType(), + T65 t65 = NullType(), + T66 t66 = NullType(), + T67 t67 = NullType(), + T68 t68 = NullType(), + T69 t69 = NullType(), + T70 t70 = NullType(), + T71 t71 = NullType(), + T72 t72 = NullType(), + T73 t73 = NullType(), + T74 t74 = NullType(), + T75 t75 = NullType(), + T76 t76 = NullType(), + T77 t77 = NullType(), + T78 t78 = NullType(), + T79 t79 = NullType(), + T80 t80 = NullType(), + T81 t81 = NullType(), + T82 t82 = NullType(), + T83 t83 = NullType(), + T84 t84 = NullType(), + T85 t85 = NullType(), + T86 t86 = NullType(), + T87 t87 = NullType(), + T88 t88 = NullType(), + T89 t89 = NullType(), + T90 t90 = NullType(), + T91 t91 = NullType(), + T92 t92 = NullType(), + T93 t93 = NullType(), + T94 t94 = NullType(), + T95 t95 = NullType(), + T96 t96 = NullType(), + T97 t97 = NullType(), + T98 t98 = NullType(), + T99 t99 = NullType(), + T100 t100 = NullType(), + T101 t101 = NullType(), + T102 t102 = NullType(), + T103 t103 = NullType(), + T104 t104 = NullType(), + T105 t105 = NullType(), + T106 t106 = NullType(), + T107 t107 = NullType(), + T108 t108 = NullType(), + T109 t109 = NullType(), + T110 t110 = NullType(), + T111 t111 = NullType(), + T112 t112 = NullType(), + T113 t113 = NullType(), + T114 t114 = NullType(), + T115 t115 = NullType(), + T116 t116 = NullType(), + T117 t117 = NullType(), + T118 t118 = NullType(), + T119 t119 = NullType(), + T120 t120 = NullType(), + T121 t121 = NullType(), + T122 t122 = NullType(), + T123 t123 = NullType(), + T124 t124 = NullType(), + T125 t125 = NullType(), + T126 t126 = NullType(), + T127 t127 = NullType()) + { + Event event; + SetArg<0, T0>::set(kernel_, t0); + SetArg<1, T1>::set(kernel_, t1); + SetArg<2, T2>::set(kernel_, t2); + SetArg<3, T3>::set(kernel_, t3); + SetArg<4, T4>::set(kernel_, t4); + SetArg<5, T5>::set(kernel_, t5); + SetArg<6, T6>::set(kernel_, t6); + SetArg<7, T7>::set(kernel_, t7); + SetArg<8, T8>::set(kernel_, t8); + SetArg<9, T9>::set(kernel_, t9); + SetArg<10, T10>::set(kernel_, t10); + SetArg<11, T11>::set(kernel_, t11); + SetArg<12, T12>::set(kernel_, t12); + SetArg<13, T13>::set(kernel_, t13); + SetArg<14, T14>::set(kernel_, t14); + SetArg<15, T15>::set(kernel_, t15); + SetArg<16, T16>::set(kernel_, t16); + SetArg<17, T17>::set(kernel_, t17); + SetArg<18, T18>::set(kernel_, t18); + SetArg<19, T19>::set(kernel_, t19); + SetArg<20, T20>::set(kernel_, t20); + SetArg<21, T21>::set(kernel_, t21); + SetArg<22, T22>::set(kernel_, t22); + SetArg<23, T23>::set(kernel_, t23); + SetArg<24, T24>::set(kernel_, t24); + SetArg<25, T25>::set(kernel_, t25); + SetArg<26, T26>::set(kernel_, t26); + SetArg<27, T27>::set(kernel_, t27); + SetArg<28, T28>::set(kernel_, t28); + SetArg<29, T29>::set(kernel_, t29); + SetArg<30, T30>::set(kernel_, t30); + SetArg<31, T31>::set(kernel_, t31); + SetArg<32, T32>::set(kernel_, t32); + SetArg<33, T33>::set(kernel_, t33); + SetArg<34, T34>::set(kernel_, t34); + SetArg<35, T35>::set(kernel_, t35); + SetArg<36, T36>::set(kernel_, t36); + SetArg<37, T37>::set(kernel_, t37); + SetArg<38, T38>::set(kernel_, t38); + SetArg<39, T39>::set(kernel_, t39); + SetArg<40, T40>::set(kernel_, t40); + SetArg<41, T41>::set(kernel_, t41); + SetArg<42, T42>::set(kernel_, t42); + SetArg<43, T43>::set(kernel_, t43); + SetArg<44, T44>::set(kernel_, t44); + SetArg<45, T45>::set(kernel_, t45); + SetArg<46, T46>::set(kernel_, t46); + SetArg<47, T47>::set(kernel_, t47); + SetArg<48, T48>::set(kernel_, t48); + SetArg<49, T49>::set(kernel_, t49); + SetArg<50, T50>::set(kernel_, t50); + SetArg<51, T51>::set(kernel_, t51); + SetArg<52, T52>::set(kernel_, t52); + SetArg<53, T53>::set(kernel_, t53); + SetArg<54, T54>::set(kernel_, t54); + SetArg<55, T55>::set(kernel_, t55); + SetArg<56, T56>::set(kernel_, t56); + SetArg<57, T57>::set(kernel_, t57); + SetArg<58, T58>::set(kernel_, t58); + SetArg<59, T59>::set(kernel_, t59); + SetArg<60, T60>::set(kernel_, t60); + SetArg<61, T61>::set(kernel_, t61); + SetArg<62, T62>::set(kernel_, t62); + SetArg<63, T63>::set(kernel_, t63); + SetArg<64, T64>::set(kernel_, t64); + SetArg<65, T65>::set(kernel_, t65); + SetArg<66, T66>::set(kernel_, t66); + SetArg<67, T67>::set(kernel_, t67); + SetArg<68, T68>::set(kernel_, t68); + SetArg<69, T69>::set(kernel_, t69); + SetArg<70, T70>::set(kernel_, t70); + SetArg<71, T71>::set(kernel_, t71); + SetArg<72, T72>::set(kernel_, t72); + SetArg<73, T73>::set(kernel_, t73); + SetArg<74, T74>::set(kernel_, t74); + SetArg<75, T75>::set(kernel_, t75); + SetArg<76, T76>::set(kernel_, t76); + SetArg<77, T77>::set(kernel_, t77); + SetArg<78, T78>::set(kernel_, t78); + SetArg<79, T79>::set(kernel_, t79); + SetArg<80, T80>::set(kernel_, t80); + SetArg<81, T81>::set(kernel_, t81); + SetArg<82, T82>::set(kernel_, t82); + SetArg<83, T83>::set(kernel_, t83); + SetArg<84, T84>::set(kernel_, t84); + SetArg<85, T85>::set(kernel_, t85); + SetArg<86, T86>::set(kernel_, t86); + SetArg<87, T87>::set(kernel_, t87); + SetArg<88, T88>::set(kernel_, t88); + SetArg<89, T89>::set(kernel_, t89); + SetArg<90, T90>::set(kernel_, t90); + SetArg<91, T91>::set(kernel_, t91); + SetArg<92, T92>::set(kernel_, t92); + SetArg<93, T93>::set(kernel_, t93); + SetArg<94, T94>::set(kernel_, t94); + SetArg<95, T95>::set(kernel_, t95); + SetArg<96, T96>::set(kernel_, t96); + SetArg<97, T97>::set(kernel_, t97); + SetArg<98, T98>::set(kernel_, t98); + SetArg<99, T99>::set(kernel_, t99); + SetArg<100, T100>::set(kernel_, t100); + SetArg<101, T101>::set(kernel_, t101); + SetArg<102, T102>::set(kernel_, t102); + SetArg<103, T103>::set(kernel_, t103); + SetArg<104, T104>::set(kernel_, t104); + SetArg<105, T105>::set(kernel_, t105); + SetArg<106, T106>::set(kernel_, t106); + SetArg<107, T107>::set(kernel_, t107); + SetArg<108, T108>::set(kernel_, t108); + SetArg<109, T109>::set(kernel_, t109); + SetArg<110, T110>::set(kernel_, t110); + SetArg<111, T111>::set(kernel_, t111); + SetArg<112, T112>::set(kernel_, t112); + SetArg<113, T113>::set(kernel_, t113); + SetArg<114, T114>::set(kernel_, t114); + SetArg<115, T115>::set(kernel_, t115); + SetArg<116, T116>::set(kernel_, t116); + SetArg<117, T117>::set(kernel_, t117); + SetArg<118, T118>::set(kernel_, t118); + SetArg<119, T119>::set(kernel_, t119); + SetArg<120, T120>::set(kernel_, t120); + SetArg<121, T121>::set(kernel_, t121); + SetArg<122, T122>::set(kernel_, t122); + SetArg<123, T123>::set(kernel_, t123); + SetArg<124, T124>::set(kernel_, t124); + SetArg<125, T125>::set(kernel_, t125); + SetArg<126, T126>::set(kernel_, t126); + SetArg<127, T127>::set(kernel_, t127); + + // Move any arguments that need moving + MoveToDevice::move(args.queue_, t0); + MoveToDevice::move(args.queue_, t1); + MoveToDevice::move(args.queue_, t2); + MoveToDevice::move(args.queue_, t3); + MoveToDevice::move(args.queue_, t4); + MoveToDevice::move(args.queue_, t5); + MoveToDevice::move(args.queue_, t6); + MoveToDevice::move(args.queue_, t7); + MoveToDevice::move(args.queue_, t8); + MoveToDevice::move(args.queue_, t9); + MoveToDevice::move(args.queue_, t10); + MoveToDevice::move(args.queue_, t11); + MoveToDevice::move(args.queue_, t12); + MoveToDevice::move(args.queue_, t13); + MoveToDevice::move(args.queue_, t14); + MoveToDevice::move(args.queue_, t15); + MoveToDevice::move(args.queue_, t16); + MoveToDevice::move(args.queue_, t17); + MoveToDevice::move(args.queue_, t18); + MoveToDevice::move(args.queue_, t19); + MoveToDevice::move(args.queue_, t20); + MoveToDevice::move(args.queue_, t21); + MoveToDevice::move(args.queue_, t22); + MoveToDevice::move(args.queue_, t23); + MoveToDevice::move(args.queue_, t24); + MoveToDevice::move(args.queue_, t25); + MoveToDevice::move(args.queue_, t26); + MoveToDevice::move(args.queue_, t27); + MoveToDevice::move(args.queue_, t28); + MoveToDevice::move(args.queue_, t29); + MoveToDevice::move(args.queue_, t30); + MoveToDevice::move(args.queue_, t31); + MoveToDevice::move(args.queue_, t32); + MoveToDevice::move(args.queue_, t33); + MoveToDevice::move(args.queue_, t34); + MoveToDevice::move(args.queue_, t35); + MoveToDevice::move(args.queue_, t36); + MoveToDevice::move(args.queue_, t37); + MoveToDevice::move(args.queue_, t38); + MoveToDevice::move(args.queue_, t39); + MoveToDevice::move(args.queue_, t40); + MoveToDevice::move(args.queue_, t41); + MoveToDevice::move(args.queue_, t42); + MoveToDevice::move(args.queue_, t43); + MoveToDevice::move(args.queue_, t44); + MoveToDevice::move(args.queue_, t45); + MoveToDevice::move(args.queue_, t46); + MoveToDevice::move(args.queue_, t47); + MoveToDevice::move(args.queue_, t48); + MoveToDevice::move(args.queue_, t49); + MoveToDevice::move(args.queue_, t50); + MoveToDevice::move(args.queue_, t51); + MoveToDevice::move(args.queue_, t52); + MoveToDevice::move(args.queue_, t53); + MoveToDevice::move(args.queue_, t54); + MoveToDevice::move(args.queue_, t55); + MoveToDevice::move(args.queue_, t56); + MoveToDevice::move(args.queue_, t57); + MoveToDevice::move(args.queue_, t58); + MoveToDevice::move(args.queue_, t59); + MoveToDevice::move(args.queue_, t60); + MoveToDevice::move(args.queue_, t61); + MoveToDevice::move(args.queue_, t62); + MoveToDevice::move(args.queue_, t63); + MoveToDevice::move(args.queue_, t64); + MoveToDevice::move(args.queue_, t65); + MoveToDevice::move(args.queue_, t66); + MoveToDevice::move(args.queue_, t67); + MoveToDevice::move(args.queue_, t68); + MoveToDevice::move(args.queue_, t69); + MoveToDevice::move(args.queue_, t70); + MoveToDevice::move(args.queue_, t71); + MoveToDevice::move(args.queue_, t72); + MoveToDevice::move(args.queue_, t73); + MoveToDevice::move(args.queue_, t74); + MoveToDevice::move(args.queue_, t75); + MoveToDevice::move(args.queue_, t76); + MoveToDevice::move(args.queue_, t77); + MoveToDevice::move(args.queue_, t78); + MoveToDevice::move(args.queue_, t79); + MoveToDevice::move(args.queue_, t80); + MoveToDevice::move(args.queue_, t81); + MoveToDevice::move(args.queue_, t82); + MoveToDevice::move(args.queue_, t83); + MoveToDevice::move(args.queue_, t84); + MoveToDevice::move(args.queue_, t85); + MoveToDevice::move(args.queue_, t86); + MoveToDevice::move(args.queue_, t87); + MoveToDevice::move(args.queue_, t88); + MoveToDevice::move(args.queue_, t89); + MoveToDevice::move(args.queue_, t90); + MoveToDevice::move(args.queue_, t91); + MoveToDevice::move(args.queue_, t92); + MoveToDevice::move(args.queue_, t93); + MoveToDevice::move(args.queue_, t94); + MoveToDevice::move(args.queue_, t95); + MoveToDevice::move(args.queue_, t96); + MoveToDevice::move(args.queue_, t97); + MoveToDevice::move(args.queue_, t98); + MoveToDevice::move(args.queue_, t99); + MoveToDevice::move(args.queue_, t100); + MoveToDevice::move(args.queue_, t101); + MoveToDevice::move(args.queue_, t102); + MoveToDevice::move(args.queue_, t103); + MoveToDevice::move(args.queue_, t104); + MoveToDevice::move(args.queue_, t105); + MoveToDevice::move(args.queue_, t106); + MoveToDevice::move(args.queue_, t107); + MoveToDevice::move(args.queue_, t108); + MoveToDevice::move(args.queue_, t109); + MoveToDevice::move(args.queue_, t110); + MoveToDevice::move(args.queue_, t111); + MoveToDevice::move(args.queue_, t112); + MoveToDevice::move(args.queue_, t113); + MoveToDevice::move(args.queue_, t114); + MoveToDevice::move(args.queue_, t115); + MoveToDevice::move(args.queue_, t116); + MoveToDevice::move(args.queue_, t117); + MoveToDevice::move(args.queue_, t118); + MoveToDevice::move(args.queue_, t119); + MoveToDevice::move(args.queue_, t120); + MoveToDevice::move(args.queue_, t121); + MoveToDevice::move(args.queue_, t122); + MoveToDevice::move(args.queue_, t123); + MoveToDevice::move(args.queue_, t124); + MoveToDevice::move(args.queue_, t125); + MoveToDevice::move(args.queue_, t126); + MoveToDevice::move(args.queue_, t127); + + VECTOR_CLASS events(&waitEvent, &waitEvent); + + args.queue_.enqueueNDRangeKernel( + kernel_, + args.offset_, + args.global_, + args.local_, + &events, + &event); + + // Move any arguments that need moving + MoveFromDevice::move(args.queue_, t0); + MoveFromDevice::move(args.queue_, t1); + MoveFromDevice::move(args.queue_, t2); + MoveFromDevice::move(args.queue_, t3); + MoveFromDevice::move(args.queue_, t4); + MoveFromDevice::move(args.queue_, t5); + MoveFromDevice::move(args.queue_, t6); + MoveFromDevice::move(args.queue_, t7); + MoveFromDevice::move(args.queue_, t8); + MoveFromDevice::move(args.queue_, t9); + MoveFromDevice::move(args.queue_, t10); + MoveFromDevice::move(args.queue_, t11); + MoveFromDevice::move(args.queue_, t12); + MoveFromDevice::move(args.queue_, t13); + MoveFromDevice::move(args.queue_, t14); + MoveFromDevice::move(args.queue_, t15); + MoveFromDevice::move(args.queue_, t16); + MoveFromDevice::move(args.queue_, t17); + MoveFromDevice::move(args.queue_, t18); + MoveFromDevice::move(args.queue_, t19); + MoveFromDevice::move(args.queue_, t20); + MoveFromDevice::move(args.queue_, t21); + MoveFromDevice::move(args.queue_, t22); + MoveFromDevice::move(args.queue_, t23); + MoveFromDevice::move(args.queue_, t24); + MoveFromDevice::move(args.queue_, t25); + MoveFromDevice::move(args.queue_, t26); + MoveFromDevice::move(args.queue_, t27); + MoveFromDevice::move(args.queue_, t28); + MoveFromDevice::move(args.queue_, t29); + MoveFromDevice::move(args.queue_, t30); + MoveFromDevice::move(args.queue_, t31); + MoveFromDevice::move(args.queue_, t32); + MoveFromDevice::move(args.queue_, t33); + MoveFromDevice::move(args.queue_, t34); + MoveFromDevice::move(args.queue_, t35); + MoveFromDevice::move(args.queue_, t36); + MoveFromDevice::move(args.queue_, t37); + MoveFromDevice::move(args.queue_, t38); + MoveFromDevice::move(args.queue_, t39); + MoveFromDevice::move(args.queue_, t40); + MoveFromDevice::move(args.queue_, t41); + MoveFromDevice::move(args.queue_, t42); + MoveFromDevice::move(args.queue_, t43); + MoveFromDevice::move(args.queue_, t44); + MoveFromDevice::move(args.queue_, t45); + MoveFromDevice::move(args.queue_, t46); + MoveFromDevice::move(args.queue_, t47); + MoveFromDevice::move(args.queue_, t48); + MoveFromDevice::move(args.queue_, t49); + MoveFromDevice::move(args.queue_, t50); + MoveFromDevice::move(args.queue_, t51); + MoveFromDevice::move(args.queue_, t52); + MoveFromDevice::move(args.queue_, t53); + MoveFromDevice::move(args.queue_, t54); + MoveFromDevice::move(args.queue_, t55); + MoveFromDevice::move(args.queue_, t56); + MoveFromDevice::move(args.queue_, t57); + MoveFromDevice::move(args.queue_, t58); + MoveFromDevice::move(args.queue_, t59); + MoveFromDevice::move(args.queue_, t60); + MoveFromDevice::move(args.queue_, t61); + MoveFromDevice::move(args.queue_, t62); + MoveFromDevice::move(args.queue_, t63); + MoveFromDevice::move(args.queue_, t64); + MoveFromDevice::move(args.queue_, t65); + MoveFromDevice::move(args.queue_, t66); + MoveFromDevice::move(args.queue_, t67); + MoveFromDevice::move(args.queue_, t68); + MoveFromDevice::move(args.queue_, t69); + MoveFromDevice::move(args.queue_, t70); + MoveFromDevice::move(args.queue_, t71); + MoveFromDevice::move(args.queue_, t72); + MoveFromDevice::move(args.queue_, t73); + MoveFromDevice::move(args.queue_, t74); + MoveFromDevice::move(args.queue_, t75); + MoveFromDevice::move(args.queue_, t76); + MoveFromDevice::move(args.queue_, t77); + MoveFromDevice::move(args.queue_, t78); + MoveFromDevice::move(args.queue_, t79); + MoveFromDevice::move(args.queue_, t80); + MoveFromDevice::move(args.queue_, t81); + MoveFromDevice::move(args.queue_, t82); + MoveFromDevice::move(args.queue_, t83); + MoveFromDevice::move(args.queue_, t84); + MoveFromDevice::move(args.queue_, t85); + MoveFromDevice::move(args.queue_, t86); + MoveFromDevice::move(args.queue_, t87); + MoveFromDevice::move(args.queue_, t88); + MoveFromDevice::move(args.queue_, t89); + MoveFromDevice::move(args.queue_, t90); + MoveFromDevice::move(args.queue_, t91); + MoveFromDevice::move(args.queue_, t92); + MoveFromDevice::move(args.queue_, t93); + MoveFromDevice::move(args.queue_, t94); + MoveFromDevice::move(args.queue_, t95); + MoveFromDevice::move(args.queue_, t96); + MoveFromDevice::move(args.queue_, t97); + MoveFromDevice::move(args.queue_, t98); + MoveFromDevice::move(args.queue_, t99); + MoveFromDevice::move(args.queue_, t100); + MoveFromDevice::move(args.queue_, t101); + MoveFromDevice::move(args.queue_, t102); + MoveFromDevice::move(args.queue_, t103); + MoveFromDevice::move(args.queue_, t104); + MoveFromDevice::move(args.queue_, t105); + MoveFromDevice::move(args.queue_, t106); + MoveFromDevice::move(args.queue_, t107); + MoveFromDevice::move(args.queue_, t108); + MoveFromDevice::move(args.queue_, t109); + MoveFromDevice::move(args.queue_, t110); + MoveFromDevice::move(args.queue_, t111); + MoveFromDevice::move(args.queue_, t112); + MoveFromDevice::move(args.queue_, t113); + MoveFromDevice::move(args.queue_, t114); + MoveFromDevice::move(args.queue_, t115); + MoveFromDevice::move(args.queue_, t116); + MoveFromDevice::move(args.queue_, t117); + MoveFromDevice::move(args.queue_, t118); + MoveFromDevice::move(args.queue_, t119); + MoveFromDevice::move(args.queue_, t120); + MoveFromDevice::move(args.queue_, t121); + MoveFromDevice::move(args.queue_, t122); + MoveFromDevice::move(args.queue_, t123); + MoveFromDevice::move(args.queue_, t124); + MoveFromDevice::move(args.queue_, t125); + MoveFromDevice::move(args.queue_, t126); + MoveFromDevice::move(args.queue_, t127); + return event; + } + + Event operator() ( + const EnqueueArgs& args, + const VECTOR_CLASS& waitEvents, + T0 t0, + T1 t1 = NullType(), + T2 t2 = NullType(), + T3 t3 = NullType(), + T4 t4 = NullType(), + T5 t5 = NullType(), + T6 t6 = NullType(), + T7 t7 = NullType(), + T8 t8 = NullType(), + T9 t9 = NullType(), + T10 t10 = NullType(), + T11 t11 = NullType(), + T12 t12 = NullType(), + T13 t13 = NullType(), + T14 t14 = NullType(), + T15 t15 = NullType(), + T16 t16 = NullType(), + T17 t17 = NullType(), + T18 t18 = NullType(), + T19 t19 = NullType(), + T20 t20 = NullType(), + T21 t21 = NullType(), + T22 t22 = NullType(), + T23 t23 = NullType(), + T24 t24 = NullType(), + T25 t25 = NullType(), + T26 t26 = NullType(), + T27 t27 = NullType(), + T28 t28 = NullType(), + T29 t29 = NullType(), + T30 t30 = NullType(), + T31 t31 = NullType(), + T32 t32 = NullType(), + T33 t33 = NullType(), + T34 t34 = NullType(), + T35 t35 = NullType(), + T36 t36 = NullType(), + T37 t37 = NullType(), + T38 t38 = NullType(), + T39 t39 = NullType(), + T40 t40 = NullType(), + T41 t41 = NullType(), + T42 t42 = NullType(), + T43 t43 = NullType(), + T44 t44 = NullType(), + T45 t45 = NullType(), + T46 t46 = NullType(), + T47 t47 = NullType(), + T48 t48 = NullType(), + T49 t49 = NullType(), + T50 t50 = NullType(), + T51 t51 = NullType(), + T52 t52 = NullType(), + T53 t53 = NullType(), + T54 t54 = NullType(), + T55 t55 = NullType(), + T56 t56 = NullType(), + T57 t57 = NullType(), + T58 t58 = NullType(), + T59 t59 = NullType(), + T60 t60 = NullType(), + T61 t61 = NullType(), + T62 t62 = NullType(), + T63 t63 = NullType(), + T64 t64 = NullType(), + T65 t65 = NullType(), + T66 t66 = NullType(), + T67 t67 = NullType(), + T68 t68 = NullType(), + T69 t69 = NullType(), + T70 t70 = NullType(), + T71 t71 = NullType(), + T72 t72 = NullType(), + T73 t73 = NullType(), + T74 t74 = NullType(), + T75 t75 = NullType(), + T76 t76 = NullType(), + T77 t77 = NullType(), + T78 t78 = NullType(), + T79 t79 = NullType(), + T80 t80 = NullType(), + T81 t81 = NullType(), + T82 t82 = NullType(), + T83 t83 = NullType(), + T84 t84 = NullType(), + T85 t85 = NullType(), + T86 t86 = NullType(), + T87 t87 = NullType(), + T88 t88 = NullType(), + T89 t89 = NullType(), + T90 t90 = NullType(), + T91 t91 = NullType(), + T92 t92 = NullType(), + T93 t93 = NullType(), + T94 t94 = NullType(), + T95 t95 = NullType(), + T96 t96 = NullType(), + T97 t97 = NullType(), + T98 t98 = NullType(), + T99 t99 = NullType(), + T100 t100 = NullType(), + T101 t101 = NullType(), + T102 t102 = NullType(), + T103 t103 = NullType(), + T104 t104 = NullType(), + T105 t105 = NullType(), + T106 t106 = NullType(), + T107 t107 = NullType(), + T108 t108 = NullType(), + T109 t109 = NullType(), + T110 t110 = NullType(), + T111 t111 = NullType(), + T112 t112 = NullType(), + T113 t113 = NullType(), + T114 t114 = NullType(), + T115 t115 = NullType(), + T116 t116 = NullType(), + T117 t117 = NullType(), + T118 t118 = NullType(), + T119 t119 = NullType(), + T120 t120 = NullType(), + T121 t121 = NullType(), + T122 t122 = NullType(), + T123 t123 = NullType(), + T124 t124 = NullType(), + T125 t125 = NullType(), + T126 t126 = NullType(), + T127 t127 = NullType()) + { + Event event; + SetArg<0, T0>::set(kernel_, t0); + SetArg<1, T1>::set(kernel_, t1); + SetArg<2, T2>::set(kernel_, t2); + SetArg<3, T3>::set(kernel_, t3); + SetArg<4, T4>::set(kernel_, t4); + SetArg<5, T5>::set(kernel_, t5); + SetArg<6, T6>::set(kernel_, t6); + SetArg<7, T7>::set(kernel_, t7); + SetArg<8, T8>::set(kernel_, t8); + SetArg<9, T9>::set(kernel_, t9); + SetArg<10, T10>::set(kernel_, t10); + SetArg<11, T11>::set(kernel_, t11); + SetArg<12, T12>::set(kernel_, t12); + SetArg<13, T13>::set(kernel_, t13); + SetArg<14, T14>::set(kernel_, t14); + SetArg<15, T15>::set(kernel_, t15); + SetArg<16, T16>::set(kernel_, t16); + SetArg<17, T17>::set(kernel_, t17); + SetArg<18, T18>::set(kernel_, t18); + SetArg<19, T19>::set(kernel_, t19); + SetArg<20, T20>::set(kernel_, t20); + SetArg<21, T21>::set(kernel_, t21); + SetArg<22, T22>::set(kernel_, t22); + SetArg<23, T23>::set(kernel_, t23); + SetArg<24, T24>::set(kernel_, t24); + SetArg<25, T25>::set(kernel_, t25); + SetArg<26, T26>::set(kernel_, t26); + SetArg<27, T27>::set(kernel_, t27); + SetArg<28, T28>::set(kernel_, t28); + SetArg<29, T29>::set(kernel_, t29); + SetArg<30, T30>::set(kernel_, t30); + SetArg<31, T31>::set(kernel_, t31); + SetArg<32, T32>::set(kernel_, t32); + SetArg<33, T33>::set(kernel_, t33); + SetArg<34, T34>::set(kernel_, t34); + SetArg<35, T35>::set(kernel_, t35); + SetArg<36, T36>::set(kernel_, t36); + SetArg<37, T37>::set(kernel_, t37); + SetArg<38, T38>::set(kernel_, t38); + SetArg<39, T39>::set(kernel_, t39); + SetArg<40, T40>::set(kernel_, t40); + SetArg<41, T41>::set(kernel_, t41); + SetArg<42, T42>::set(kernel_, t42); + SetArg<43, T43>::set(kernel_, t43); + SetArg<44, T44>::set(kernel_, t44); + SetArg<45, T45>::set(kernel_, t45); + SetArg<46, T46>::set(kernel_, t46); + SetArg<47, T47>::set(kernel_, t47); + SetArg<48, T48>::set(kernel_, t48); + SetArg<49, T49>::set(kernel_, t49); + SetArg<50, T50>::set(kernel_, t50); + SetArg<51, T51>::set(kernel_, t51); + SetArg<52, T52>::set(kernel_, t52); + SetArg<53, T53>::set(kernel_, t53); + SetArg<54, T54>::set(kernel_, t54); + SetArg<55, T55>::set(kernel_, t55); + SetArg<56, T56>::set(kernel_, t56); + SetArg<57, T57>::set(kernel_, t57); + SetArg<58, T58>::set(kernel_, t58); + SetArg<59, T59>::set(kernel_, t59); + SetArg<60, T60>::set(kernel_, t60); + SetArg<61, T61>::set(kernel_, t61); + SetArg<62, T62>::set(kernel_, t62); + SetArg<63, T63>::set(kernel_, t63); + SetArg<64, T64>::set(kernel_, t64); + SetArg<65, T65>::set(kernel_, t65); + SetArg<66, T66>::set(kernel_, t66); + SetArg<67, T67>::set(kernel_, t67); + SetArg<68, T68>::set(kernel_, t68); + SetArg<69, T69>::set(kernel_, t69); + SetArg<70, T70>::set(kernel_, t70); + SetArg<71, T71>::set(kernel_, t71); + SetArg<72, T72>::set(kernel_, t72); + SetArg<73, T73>::set(kernel_, t73); + SetArg<74, T74>::set(kernel_, t74); + SetArg<75, T75>::set(kernel_, t75); + SetArg<76, T76>::set(kernel_, t76); + SetArg<77, T77>::set(kernel_, t77); + SetArg<78, T78>::set(kernel_, t78); + SetArg<79, T79>::set(kernel_, t79); + SetArg<80, T80>::set(kernel_, t80); + SetArg<81, T81>::set(kernel_, t81); + SetArg<82, T82>::set(kernel_, t82); + SetArg<83, T83>::set(kernel_, t83); + SetArg<84, T84>::set(kernel_, t84); + SetArg<85, T85>::set(kernel_, t85); + SetArg<86, T86>::set(kernel_, t86); + SetArg<87, T87>::set(kernel_, t87); + SetArg<88, T88>::set(kernel_, t88); + SetArg<89, T89>::set(kernel_, t89); + SetArg<90, T90>::set(kernel_, t90); + SetArg<91, T91>::set(kernel_, t91); + SetArg<92, T92>::set(kernel_, t92); + SetArg<93, T93>::set(kernel_, t93); + SetArg<94, T94>::set(kernel_, t94); + SetArg<95, T95>::set(kernel_, t95); + SetArg<96, T96>::set(kernel_, t96); + SetArg<97, T97>::set(kernel_, t97); + SetArg<98, T98>::set(kernel_, t98); + SetArg<99, T99>::set(kernel_, t99); + SetArg<100, T100>::set(kernel_, t100); + SetArg<101, T101>::set(kernel_, t101); + SetArg<102, T102>::set(kernel_, t102); + SetArg<103, T103>::set(kernel_, t103); + SetArg<104, T104>::set(kernel_, t104); + SetArg<105, T105>::set(kernel_, t105); + SetArg<106, T106>::set(kernel_, t106); + SetArg<107, T107>::set(kernel_, t107); + SetArg<108, T108>::set(kernel_, t108); + SetArg<109, T109>::set(kernel_, t109); + SetArg<110, T110>::set(kernel_, t110); + SetArg<111, T111>::set(kernel_, t111); + SetArg<112, T112>::set(kernel_, t112); + SetArg<113, T113>::set(kernel_, t113); + SetArg<114, T114>::set(kernel_, t114); + SetArg<115, T115>::set(kernel_, t115); + SetArg<116, T116>::set(kernel_, t116); + SetArg<117, T117>::set(kernel_, t117); + SetArg<118, T118>::set(kernel_, t118); + SetArg<119, T119>::set(kernel_, t119); + SetArg<120, T120>::set(kernel_, t120); + SetArg<121, T121>::set(kernel_, t121); + SetArg<122, T122>::set(kernel_, t122); + SetArg<123, T123>::set(kernel_, t123); + SetArg<124, T124>::set(kernel_, t124); + SetArg<125, T125>::set(kernel_, t125); + SetArg<126, T126>::set(kernel_, t126); + SetArg<127, T127>::set(kernel_, t127); + + // Move any arguments that need moving + MoveToDevice::move(args.queue_, t0); + MoveToDevice::move(args.queue_, t1); + MoveToDevice::move(args.queue_, t2); + MoveToDevice::move(args.queue_, t3); + MoveToDevice::move(args.queue_, t4); + MoveToDevice::move(args.queue_, t5); + MoveToDevice::move(args.queue_, t6); + MoveToDevice::move(args.queue_, t7); + MoveToDevice::move(args.queue_, t8); + MoveToDevice::move(args.queue_, t9); + MoveToDevice::move(args.queue_, t10); + MoveToDevice::move(args.queue_, t11); + MoveToDevice::move(args.queue_, t12); + MoveToDevice::move(args.queue_, t13); + MoveToDevice::move(args.queue_, t14); + MoveToDevice::move(args.queue_, t15); + MoveToDevice::move(args.queue_, t16); + MoveToDevice::move(args.queue_, t17); + MoveToDevice::move(args.queue_, t18); + MoveToDevice::move(args.queue_, t19); + MoveToDevice::move(args.queue_, t20); + MoveToDevice::move(args.queue_, t21); + MoveToDevice::move(args.queue_, t22); + MoveToDevice::move(args.queue_, t23); + MoveToDevice::move(args.queue_, t24); + MoveToDevice::move(args.queue_, t25); + MoveToDevice::move(args.queue_, t26); + MoveToDevice::move(args.queue_, t27); + MoveToDevice::move(args.queue_, t28); + MoveToDevice::move(args.queue_, t29); + MoveToDevice::move(args.queue_, t30); + MoveToDevice::move(args.queue_, t31); + MoveToDevice::move(args.queue_, t32); + MoveToDevice::move(args.queue_, t33); + MoveToDevice::move(args.queue_, t34); + MoveToDevice::move(args.queue_, t35); + MoveToDevice::move(args.queue_, t36); + MoveToDevice::move(args.queue_, t37); + MoveToDevice::move(args.queue_, t38); + MoveToDevice::move(args.queue_, t39); + MoveToDevice::move(args.queue_, t40); + MoveToDevice::move(args.queue_, t41); + MoveToDevice::move(args.queue_, t42); + MoveToDevice::move(args.queue_, t43); + MoveToDevice::move(args.queue_, t44); + MoveToDevice::move(args.queue_, t45); + MoveToDevice::move(args.queue_, t46); + MoveToDevice::move(args.queue_, t47); + MoveToDevice::move(args.queue_, t48); + MoveToDevice::move(args.queue_, t49); + MoveToDevice::move(args.queue_, t50); + MoveToDevice::move(args.queue_, t51); + MoveToDevice::move(args.queue_, t52); + MoveToDevice::move(args.queue_, t53); + MoveToDevice::move(args.queue_, t54); + MoveToDevice::move(args.queue_, t55); + MoveToDevice::move(args.queue_, t56); + MoveToDevice::move(args.queue_, t57); + MoveToDevice::move(args.queue_, t58); + MoveToDevice::move(args.queue_, t59); + MoveToDevice::move(args.queue_, t60); + MoveToDevice::move(args.queue_, t61); + MoveToDevice::move(args.queue_, t62); + MoveToDevice::move(args.queue_, t63); + MoveToDevice::move(args.queue_, t64); + MoveToDevice::move(args.queue_, t65); + MoveToDevice::move(args.queue_, t66); + MoveToDevice::move(args.queue_, t67); + MoveToDevice::move(args.queue_, t68); + MoveToDevice::move(args.queue_, t69); + MoveToDevice::move(args.queue_, t70); + MoveToDevice::move(args.queue_, t71); + MoveToDevice::move(args.queue_, t72); + MoveToDevice::move(args.queue_, t73); + MoveToDevice::move(args.queue_, t74); + MoveToDevice::move(args.queue_, t75); + MoveToDevice::move(args.queue_, t76); + MoveToDevice::move(args.queue_, t77); + MoveToDevice::move(args.queue_, t78); + MoveToDevice::move(args.queue_, t79); + MoveToDevice::move(args.queue_, t80); + MoveToDevice::move(args.queue_, t81); + MoveToDevice::move(args.queue_, t82); + MoveToDevice::move(args.queue_, t83); + MoveToDevice::move(args.queue_, t84); + MoveToDevice::move(args.queue_, t85); + MoveToDevice::move(args.queue_, t86); + MoveToDevice::move(args.queue_, t87); + MoveToDevice::move(args.queue_, t88); + MoveToDevice::move(args.queue_, t89); + MoveToDevice::move(args.queue_, t90); + MoveToDevice::move(args.queue_, t91); + MoveToDevice::move(args.queue_, t92); + MoveToDevice::move(args.queue_, t93); + MoveToDevice::move(args.queue_, t94); + MoveToDevice::move(args.queue_, t95); + MoveToDevice::move(args.queue_, t96); + MoveToDevice::move(args.queue_, t97); + MoveToDevice::move(args.queue_, t98); + MoveToDevice::move(args.queue_, t99); + MoveToDevice::move(args.queue_, t100); + MoveToDevice::move(args.queue_, t101); + MoveToDevice::move(args.queue_, t102); + MoveToDevice::move(args.queue_, t103); + MoveToDevice::move(args.queue_, t104); + MoveToDevice::move(args.queue_, t105); + MoveToDevice::move(args.queue_, t106); + MoveToDevice::move(args.queue_, t107); + MoveToDevice::move(args.queue_, t108); + MoveToDevice::move(args.queue_, t109); + MoveToDevice::move(args.queue_, t110); + MoveToDevice::move(args.queue_, t111); + MoveToDevice::move(args.queue_, t112); + MoveToDevice::move(args.queue_, t113); + MoveToDevice::move(args.queue_, t114); + MoveToDevice::move(args.queue_, t115); + MoveToDevice::move(args.queue_, t116); + MoveToDevice::move(args.queue_, t117); + MoveToDevice::move(args.queue_, t118); + MoveToDevice::move(args.queue_, t119); + MoveToDevice::move(args.queue_, t120); + MoveToDevice::move(args.queue_, t121); + MoveToDevice::move(args.queue_, t122); + MoveToDevice::move(args.queue_, t123); + MoveToDevice::move(args.queue_, t124); + MoveToDevice::move(args.queue_, t125); + MoveToDevice::move(args.queue_, t126); + MoveToDevice::move(args.queue_, t127); + + args.queue_.enqueueNDRangeKernel( + kernel_, + args.offset_, + args.global_, + args.local_, + &waitEvents, + &event); + + // Move any arguments that need moving + MoveFromDevice::move(args.queue_, t0); + MoveFromDevice::move(args.queue_, t1); + MoveFromDevice::move(args.queue_, t2); + MoveFromDevice::move(args.queue_, t3); + MoveFromDevice::move(args.queue_, t4); + MoveFromDevice::move(args.queue_, t5); + MoveFromDevice::move(args.queue_, t6); + MoveFromDevice::move(args.queue_, t7); + MoveFromDevice::move(args.queue_, t8); + MoveFromDevice::move(args.queue_, t9); + MoveFromDevice::move(args.queue_, t10); + MoveFromDevice::move(args.queue_, t11); + MoveFromDevice::move(args.queue_, t12); + MoveFromDevice::move(args.queue_, t13); + MoveFromDevice::move(args.queue_, t14); + MoveFromDevice::move(args.queue_, t15); + MoveFromDevice::move(args.queue_, t16); + MoveFromDevice::move(args.queue_, t17); + MoveFromDevice::move(args.queue_, t18); + MoveFromDevice::move(args.queue_, t19); + MoveFromDevice::move(args.queue_, t20); + MoveFromDevice::move(args.queue_, t21); + MoveFromDevice::move(args.queue_, t22); + MoveFromDevice::move(args.queue_, t23); + MoveFromDevice::move(args.queue_, t24); + MoveFromDevice::move(args.queue_, t25); + MoveFromDevice::move(args.queue_, t26); + MoveFromDevice::move(args.queue_, t27); + MoveFromDevice::move(args.queue_, t28); + MoveFromDevice::move(args.queue_, t29); + MoveFromDevice::move(args.queue_, t30); + MoveFromDevice::move(args.queue_, t31); + MoveFromDevice::move(args.queue_, t32); + MoveFromDevice::move(args.queue_, t33); + MoveFromDevice::move(args.queue_, t34); + MoveFromDevice::move(args.queue_, t35); + MoveFromDevice::move(args.queue_, t36); + MoveFromDevice::move(args.queue_, t37); + MoveFromDevice::move(args.queue_, t38); + MoveFromDevice::move(args.queue_, t39); + MoveFromDevice::move(args.queue_, t40); + MoveFromDevice::move(args.queue_, t41); + MoveFromDevice::move(args.queue_, t42); + MoveFromDevice::move(args.queue_, t43); + MoveFromDevice::move(args.queue_, t44); + MoveFromDevice::move(args.queue_, t45); + MoveFromDevice::move(args.queue_, t46); + MoveFromDevice::move(args.queue_, t47); + MoveFromDevice::move(args.queue_, t48); + MoveFromDevice::move(args.queue_, t49); + MoveFromDevice::move(args.queue_, t50); + MoveFromDevice::move(args.queue_, t51); + MoveFromDevice::move(args.queue_, t52); + MoveFromDevice::move(args.queue_, t53); + MoveFromDevice::move(args.queue_, t54); + MoveFromDevice::move(args.queue_, t55); + MoveFromDevice::move(args.queue_, t56); + MoveFromDevice::move(args.queue_, t57); + MoveFromDevice::move(args.queue_, t58); + MoveFromDevice::move(args.queue_, t59); + MoveFromDevice::move(args.queue_, t60); + MoveFromDevice::move(args.queue_, t61); + MoveFromDevice::move(args.queue_, t62); + MoveFromDevice::move(args.queue_, t63); + MoveFromDevice::move(args.queue_, t64); + MoveFromDevice::move(args.queue_, t65); + MoveFromDevice::move(args.queue_, t66); + MoveFromDevice::move(args.queue_, t67); + MoveFromDevice::move(args.queue_, t68); + MoveFromDevice::move(args.queue_, t69); + MoveFromDevice::move(args.queue_, t70); + MoveFromDevice::move(args.queue_, t71); + MoveFromDevice::move(args.queue_, t72); + MoveFromDevice::move(args.queue_, t73); + MoveFromDevice::move(args.queue_, t74); + MoveFromDevice::move(args.queue_, t75); + MoveFromDevice::move(args.queue_, t76); + MoveFromDevice::move(args.queue_, t77); + MoveFromDevice::move(args.queue_, t78); + MoveFromDevice::move(args.queue_, t79); + MoveFromDevice::move(args.queue_, t80); + MoveFromDevice::move(args.queue_, t81); + MoveFromDevice::move(args.queue_, t82); + MoveFromDevice::move(args.queue_, t83); + MoveFromDevice::move(args.queue_, t84); + MoveFromDevice::move(args.queue_, t85); + MoveFromDevice::move(args.queue_, t86); + MoveFromDevice::move(args.queue_, t87); + MoveFromDevice::move(args.queue_, t88); + MoveFromDevice::move(args.queue_, t89); + MoveFromDevice::move(args.queue_, t90); + MoveFromDevice::move(args.queue_, t91); + MoveFromDevice::move(args.queue_, t92); + MoveFromDevice::move(args.queue_, t93); + MoveFromDevice::move(args.queue_, t94); + MoveFromDevice::move(args.queue_, t95); + MoveFromDevice::move(args.queue_, t96); + MoveFromDevice::move(args.queue_, t97); + MoveFromDevice::move(args.queue_, t98); + MoveFromDevice::move(args.queue_, t99); + MoveFromDevice::move(args.queue_, t100); + MoveFromDevice::move(args.queue_, t101); + MoveFromDevice::move(args.queue_, t102); + MoveFromDevice::move(args.queue_, t103); + MoveFromDevice::move(args.queue_, t104); + MoveFromDevice::move(args.queue_, t105); + MoveFromDevice::move(args.queue_, t106); + MoveFromDevice::move(args.queue_, t107); + MoveFromDevice::move(args.queue_, t108); + MoveFromDevice::move(args.queue_, t109); + MoveFromDevice::move(args.queue_, t110); + MoveFromDevice::move(args.queue_, t111); + MoveFromDevice::move(args.queue_, t112); + MoveFromDevice::move(args.queue_, t113); + MoveFromDevice::move(args.queue_, t114); + MoveFromDevice::move(args.queue_, t115); + MoveFromDevice::move(args.queue_, t116); + MoveFromDevice::move(args.queue_, t117); + MoveFromDevice::move(args.queue_, t118); + MoveFromDevice::move(args.queue_, t119); + MoveFromDevice::move(args.queue_, t120); + MoveFromDevice::move(args.queue_, t121); + MoveFromDevice::move(args.queue_, t122); + MoveFromDevice::move(args.queue_, t123); + MoveFromDevice::move(args.queue_, t124); + MoveFromDevice::move(args.queue_, t125); + MoveFromDevice::move(args.queue_, t126); + MoveFromDevice::move(args.queue_, t127); + + return event; + } +}; + +//------------------------------------------------------------------------------------------------------ + + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122, + typename T123, + typename T124, + typename T125, + typename T126, + typename T127> +struct functionImplementation_ +{ +}; + +template< + typename T0> +struct functionImplementation_< + T0, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0) + { + return functor_( + enqueueArgs, + arg0); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1> +struct functionImplementation_< + T0, + T1, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1) + { + return functor_( + enqueueArgs, + arg0, + arg1); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2> +struct functionImplementation_< + T0, + T1, + T2, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3> +struct functionImplementation_< + T0, + T1, + T2, + T3, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + NullType, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + NullType, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + NullType, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121, + T122 arg122) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121, + arg122); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122, + typename T123> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + NullType, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + NullType, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121, + T122 arg122, + T123 arg123) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121, + arg122, + arg123); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122, + typename T123, + typename T124> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + NullType, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + NullType, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121, + T122 arg122, + T123 arg123, + T124 arg124) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121, + arg122, + arg123, + arg124); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122, + typename T123, + typename T124, + typename T125> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + T125, + NullType, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + T125, + NullType, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121, + T122 arg122, + T123 arg123, + T124 arg124, + T125 arg125) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121, + arg122, + arg123, + arg124, + arg125); + } + + operator type_ () + { + return type_(*this); + } + +}; + +template< + typename T0, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5, + typename T6, + typename T7, + typename T8, + typename T9, + typename T10, + typename T11, + typename T12, + typename T13, + typename T14, + typename T15, + typename T16, + typename T17, + typename T18, + typename T19, + typename T20, + typename T21, + typename T22, + typename T23, + typename T24, + typename T25, + typename T26, + typename T27, + typename T28, + typename T29, + typename T30, + typename T31, + typename T32, + typename T33, + typename T34, + typename T35, + typename T36, + typename T37, + typename T38, + typename T39, + typename T40, + typename T41, + typename T42, + typename T43, + typename T44, + typename T45, + typename T46, + typename T47, + typename T48, + typename T49, + typename T50, + typename T51, + typename T52, + typename T53, + typename T54, + typename T55, + typename T56, + typename T57, + typename T58, + typename T59, + typename T60, + typename T61, + typename T62, + typename T63, + typename T64, + typename T65, + typename T66, + typename T67, + typename T68, + typename T69, + typename T70, + typename T71, + typename T72, + typename T73, + typename T74, + typename T75, + typename T76, + typename T77, + typename T78, + typename T79, + typename T80, + typename T81, + typename T82, + typename T83, + typename T84, + typename T85, + typename T86, + typename T87, + typename T88, + typename T89, + typename T90, + typename T91, + typename T92, + typename T93, + typename T94, + typename T95, + typename T96, + typename T97, + typename T98, + typename T99, + typename T100, + typename T101, + typename T102, + typename T103, + typename T104, + typename T105, + typename T106, + typename T107, + typename T108, + typename T109, + typename T110, + typename T111, + typename T112, + typename T113, + typename T114, + typename T115, + typename T116, + typename T117, + typename T118, + typename T119, + typename T120, + typename T121, + typename T122, + typename T123, + typename T124, + typename T125, + typename T126> +struct functionImplementation_< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + T125, + T126, + NullType> +{ + typedef detail::KernelFunctorGlobal< + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + T16, + T17, + T18, + T19, + T20, + T21, + T22, + T23, + T24, + T25, + T26, + T27, + T28, + T29, + T30, + T31, + T32, + T33, + T34, + T35, + T36, + T37, + T38, + T39, + T40, + T41, + T42, + T43, + T44, + T45, + T46, + T47, + T48, + T49, + T50, + T51, + T52, + T53, + T54, + T55, + T56, + T57, + T58, + T59, + T60, + T61, + T62, + T63, + T64, + T65, + T66, + T67, + T68, + T69, + T70, + T71, + T72, + T73, + T74, + T75, + T76, + T77, + T78, + T79, + T80, + T81, + T82, + T83, + T84, + T85, + T86, + T87, + T88, + T89, + T90, + T91, + T92, + T93, + T94, + T95, + T96, + T97, + T98, + T99, + T100, + T101, + T102, + T103, + T104, + T105, + T106, + T107, + T108, + T109, + T110, + T111, + T112, + T113, + T114, + T115, + T116, + T117, + T118, + T119, + T120, + T121, + T122, + T123, + T124, + T125, + T126, + NullType> FunctorType; + + FunctorType functor_; + + functionImplementation_(const FunctorType &functor) : + functor_(functor) + { + } + + typedef std::tr1::function type_; + + Event operator()(const EnqueueArgs& enqueueArgs, + T0 arg0, + T1 arg1, + T2 arg2, + T3 arg3, + T4 arg4, + T5 arg5, + T6 arg6, + T7 arg7, + T8 arg8, + T9 arg9, + T10 arg10, + T11 arg11, + T12 arg12, + T13 arg13, + T14 arg14, + T15 arg15, + T16 arg16, + T17 arg17, + T18 arg18, + T19 arg19, + T20 arg20, + T21 arg21, + T22 arg22, + T23 arg23, + T24 arg24, + T25 arg25, + T26 arg26, + T27 arg27, + T28 arg28, + T29 arg29, + T30 arg30, + T31 arg31, + T32 arg32, + T33 arg33, + T34 arg34, + T35 arg35, + T36 arg36, + T37 arg37, + T38 arg38, + T39 arg39, + T40 arg40, + T41 arg41, + T42 arg42, + T43 arg43, + T44 arg44, + T45 arg45, + T46 arg46, + T47 arg47, + T48 arg48, + T49 arg49, + T50 arg50, + T51 arg51, + T52 arg52, + T53 arg53, + T54 arg54, + T55 arg55, + T56 arg56, + T57 arg57, + T58 arg58, + T59 arg59, + T60 arg60, + T61 arg61, + T62 arg62, + T63 arg63, + T64 arg64, + T65 arg65, + T66 arg66, + T67 arg67, + T68 arg68, + T69 arg69, + T70 arg70, + T71 arg71, + T72 arg72, + T73 arg73, + T74 arg74, + T75 arg75, + T76 arg76, + T77 arg77, + T78 arg78, + T79 arg79, + T80 arg80, + T81 arg81, + T82 arg82, + T83 arg83, + T84 arg84, + T85 arg85, + T86 arg86, + T87 arg87, + T88 arg88, + T89 arg89, + T90 arg90, + T91 arg91, + T92 arg92, + T93 arg93, + T94 arg94, + T95 arg95, + T96 arg96, + T97 arg97, + T98 arg98, + T99 arg99, + T100 arg100, + T101 arg101, + T102 arg102, + T103 arg103, + T104 arg104, + T105 arg105, + T106 arg106, + T107 arg107, + T108 arg108, + T109 arg109, + T110 arg110, + T111 arg111, + T112 arg112, + T113 arg113, + T114 arg114, + T115 arg115, + T116 arg116, + T117 arg117, + T118 arg118, + T119 arg119, + T120 arg120, + T121 arg121, + T122 arg122, + T123 arg123, + T124 arg124, + T125 arg125, + T126 arg126) + { + return functor_( + enqueueArgs, + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + arg7, + arg8, + arg9, + arg10, + arg11, + arg12, + arg13, + arg14, + arg15, + arg16, + arg17, + arg18, + arg19, + arg20, + arg21, + arg22, + arg23, + arg24, + arg25, + arg26, + arg27, + arg28, + arg29, + arg30, + arg31, + arg32, + arg33, + arg34, + arg35, + arg36, + arg37, + arg38, + arg39, + arg40, + arg41, + arg42, + arg43, + arg44, + arg45, + arg46, + arg47, + arg48, + arg49, + arg50, + arg51, + arg52, + arg53, + arg54, + arg55, + arg56, + arg57, + arg58, + arg59, + arg60, + arg61, + arg62, + arg63, + arg64, + arg65, + arg66, + arg67, + arg68, + arg69, + arg70, + arg71, + arg72, + arg73, + arg74, + arg75, + arg76, + arg77, + arg78, + arg79, + arg80, + arg81, + arg82, + arg83, + arg84, + arg85, + arg86, + arg87, + arg88, + arg89, + arg90, + arg91, + arg92, + arg93, + arg94, + arg95, + arg96, + arg97, + arg98, + arg99, + arg100, + arg101, + arg102, + arg103, + arg104, + arg105, + arg106, + arg107, + arg108, + arg109, + arg110, + arg111, + arg112, + arg113, + arg114, + arg115, + arg116, + arg117, + arg118, + arg119, + arg120, + arg121, + arg122, + arg123, + arg124, + arg125, + arg126); + } + + operator type_ () + { + return type_(*this); + } + +}; + + + + + +} // namespace detail + +//---------------------------------------------------------------------------------------------- + +template < + typename T0, typename T1 = detail::NullType, typename T2 = detail::NullType, + typename T3 = detail::NullType, typename T4 = detail::NullType, + typename T5 = detail::NullType, typename T6 = detail::NullType, + typename T7 = detail::NullType, typename T8 = detail::NullType, + typename T9 = detail::NullType, typename T10 = detail::NullType, + typename T11 = detail::NullType, typename T12 = detail::NullType, + typename T13 = detail::NullType, typename T14 = detail::NullType, + typename T15 = detail::NullType, typename T16 = detail::NullType, + typename T17 = detail::NullType, typename T18 = detail::NullType, + typename T19 = detail::NullType, typename T20 = detail::NullType, + typename T21 = detail::NullType, typename T22 = detail::NullType, + typename T23 = detail::NullType, typename T24 = detail::NullType, + typename T25 = detail::NullType, typename T26 = detail::NullType, + typename T27 = detail::NullType, typename T28 = detail::NullType, + typename T29 = detail::NullType, typename T30 = detail::NullType, + typename T31 = detail::NullType, typename T32 = detail::NullType, + typename T33 = detail::NullType, typename T34 = detail::NullType, + typename T35 = detail::NullType, typename T36 = detail::NullType, + typename T37 = detail::NullType, typename T38 = detail::NullType, + typename T39 = detail::NullType, typename T40 = detail::NullType, + typename T41 = detail::NullType, typename T42 = detail::NullType, + typename T43 = detail::NullType, typename T44 = detail::NullType, + typename T45 = detail::NullType, typename T46 = detail::NullType, + typename T47 = detail::NullType, typename T48 = detail::NullType, + typename T49 = detail::NullType, typename T50 = detail::NullType, + typename T51 = detail::NullType, typename T52 = detail::NullType, + typename T53 = detail::NullType, typename T54 = detail::NullType, + typename T55 = detail::NullType, typename T56 = detail::NullType, + typename T57 = detail::NullType, typename T58 = detail::NullType, + typename T59 = detail::NullType, typename T60 = detail::NullType, + typename T61 = detail::NullType, typename T62 = detail::NullType, + typename T63 = detail::NullType, typename T64 = detail::NullType, + typename T65 = detail::NullType, typename T66 = detail::NullType, + typename T67 = detail::NullType, typename T68 = detail::NullType, + typename T69 = detail::NullType, typename T70 = detail::NullType, + typename T71 = detail::NullType, typename T72 = detail::NullType, + typename T73 = detail::NullType, typename T74 = detail::NullType, + typename T75 = detail::NullType, typename T76 = detail::NullType, + typename T77 = detail::NullType, typename T78 = detail::NullType, + typename T79 = detail::NullType, typename T80 = detail::NullType, + typename T81 = detail::NullType, typename T82 = detail::NullType, + typename T83 = detail::NullType, typename T84 = detail::NullType, + typename T85 = detail::NullType, typename T86 = detail::NullType, + typename T87 = detail::NullType, typename T88 = detail::NullType, + typename T89 = detail::NullType, typename T90 = detail::NullType, + typename T91 = detail::NullType, typename T92 = detail::NullType, + typename T93 = detail::NullType, typename T94 = detail::NullType, + typename T95 = detail::NullType, typename T96 = detail::NullType, + typename T97 = detail::NullType, typename T98 = detail::NullType, + typename T99 = detail::NullType, typename T100 = detail::NullType, + typename T101 = detail::NullType, typename T102 = detail::NullType, + typename T103 = detail::NullType, typename T104 = detail::NullType, + typename T105 = detail::NullType, typename T106 = detail::NullType, + typename T107 = detail::NullType, typename T108 = detail::NullType, + typename T109 = detail::NullType, typename T110 = detail::NullType, + typename T111 = detail::NullType, typename T112 = detail::NullType, + typename T113 = detail::NullType, typename T114 = detail::NullType, + typename T115 = detail::NullType, typename T116 = detail::NullType, + typename T117 = detail::NullType, typename T118 = detail::NullType, + typename T119 = detail::NullType, typename T120 = detail::NullType, + typename T121 = detail::NullType, typename T122 = detail::NullType, + typename T123 = detail::NullType, typename T124 = detail::NullType, + typename T125 = detail::NullType, typename T126 = detail::NullType, + typename T127 = detail::NullType> +struct make_kernel : + public detail::functionImplementation_< + T0, T1, T2, T3, + T4, T5, T6, T7, + T8, T9, T10, T11, + T12, T13, T14, T15, + T16, T17, T18, T19, + T20, T21, T22, T23, + T24, T25, T26, T27, + T28, T29, T30, T31, + T32, T33, T34, T35, + T36, T37, T38, T39, + T40, T41, T42, T43, + T44, T45, T46, T47, + T48, T49, T50, T51, + T52, T53, T54, T55, + T56, T57, T58, T59, + T60, T61, T62, T63, + T64, T65, T66, T67, + T68, T69, T70, T71, + T72, T73, T74, T75, + T76, T77, T78, T79, + T80, T81, T82, T83, + T84, T85, T86, T87, + T88, T89, T90, T91, + T92, T93, T94, T95, + T96, T97, T98, T99, + T100, T101, T102, T103, + T104, T105, T106, T107, + T108, T109, T110, T111, + T112, T113, T114, T115, + T116, T117, T118, T119, + T120, T121, T122, T123, + T124, T125, T126, T127> +{ +public: + typedef detail::KernelFunctorGlobal< + T0, T1, T2, T3, + T4, T5, T6, T7, + T8, T9, T10, T11, + T12, T13, T14, T15, + T16, T17, T18, T19, + T20, T21, T22, T23, + T24, T25, T26, T27, + T28, T29, T30, T31, + T32, T33, T34, T35, + T36, T37, T38, T39, + T40, T41, T42, T43, + T44, T45, T46, T47, + T48, T49, T50, T51, + T52, T53, T54, T55, + T56, T57, T58, T59, + T60, T61, T62, T63, + T64, T65, T66, T67, + T68, T69, T70, T71, + T72, T73, T74, T75, + T76, T77, T78, T79, + T80, T81, T82, T83, + T84, T85, T86, T87, + T88, T89, T90, T91, + T92, T93, T94, T95, + T96, T97, T98, T99, + T100, T101, T102, T103, + T104, T105, T106, T107, + T108, T109, T110, T111, + T112, T113, T114, T115, + T116, T117, T118, T119, + T120, T121, T122, T123, + T124, T125, T126, T127> FunctorType; + + make_kernel( + const Program& program, + const STRING_CLASS name, + cl_int * err = NULL) : + detail::functionImplementation_< + T0, T1, T2, T3, + T4, T5, T6, T7, + T8, T9, T10, T11, + T12, T13, T14, T15, + T16, T17, T18, T19, + T20, T21, T22, T23, + T24, T25, T26, T27, + T28, T29, T30, T31, + T32, T33, T34, T35, + T36, T37, T38, T39, + T40, T41, T42, T43, + T44, T45, T46, T47, + T48, T49, T50, T51, + T52, T53, T54, T55, + T56, T57, T58, T59, + T60, T61, T62, T63, + T64, T65, T66, T67, + T68, T69, T70, T71, + T72, T73, T74, T75, + T76, T77, T78, T79, + T80, T81, T82, T83, + T84, T85, T86, T87, + T88, T89, T90, T91, + T92, T93, T94, T95, + T96, T97, T98, T99, + T100, T101, T102, T103, + T104, T105, T106, T107, + T108, T109, T110, T111, + T112, T113, T114, T115, + T116, T117, T118, T119, + T120, T121, T122, T123, + T124, T125, T126, T127>( + FunctorType(program, name, err)) + {} + + make_kernel( + const Kernel kernel, + cl_int * err = NULL) : + detail::functionImplementation_< + T0, T1, T2, T3, + T4, T5, T6, T7, + T8, T9, T10, T11, + T12, T13, T14, T15, + T16, T17, T18, T19, + T20, T21, T22, T23, + T24, T25, T26, T27, + T28, T29, T30, T31, + T32, T33, T34, T35, + T36, T37, T38, T39, + T40, T41, T42, T43, + T44, T45, T46, T47, + T48, T49, T50, T51, + T52, T53, T54, T55, + T56, T57, T58, T59, + T60, T61, T62, T63, + T64, T65, T66, T67, + T68, T69, T70, T71, + T72, T73, T74, T75, + T76, T77, T78, T79, + T80, T81, T82, T83, + T84, T85, T86, T87, + T88, T89, T90, T91, + T92, T93, T94, T95, + T96, T97, T98, T99, + T100, T101, T102, T103, + T104, T105, T106, T107, + T108, T109, T110, T111, + T112, T113, T114, T115, + T116, T117, T118, T119, + T120, T121, T122, T123, + T124, T125, T126, T127>( + FunctorType(kernel, err)) + {} +}; + +#endif + +//---------------------------------------------------------------------------------------------------------------------- + +#undef __ERR_STR +#if !defined(__CL_USER_OVERRIDE_ERROR_STRINGS) +#undef __GET_DEVICE_INFO_ERR +#undef __GET_PLATFORM_INFO_ERR +#undef __GET_DEVICE_IDS_ERR +#undef __GET_CONTEXT_INFO_ERR +#undef __GET_EVENT_INFO_ERR +#undef __GET_EVENT_PROFILE_INFO_ERR +#undef __GET_MEM_OBJECT_INFO_ERR +#undef __GET_IMAGE_INFO_ERR +#undef __GET_SAMPLER_INFO_ERR +#undef __GET_KERNEL_INFO_ERR +#undef __GET_KERNEL_WORK_GROUP_INFO_ERR +#undef __GET_PROGRAM_INFO_ERR +#undef __GET_PROGRAM_BUILD_INFO_ERR +#undef __GET_COMMAND_QUEUE_INFO_ERR + +#undef __CREATE_CONTEXT_ERR +#undef __CREATE_CONTEXT_FROM_TYPE_ERR +#undef __GET_SUPPORTED_IMAGE_FORMATS_ERR + +#undef __CREATE_BUFFER_ERR +#undef __CREATE_SUBBUFFER_ERR +#undef __CREATE_IMAGE2D_ERR +#undef __CREATE_IMAGE3D_ERR +#undef __CREATE_SAMPLER_ERR +#undef __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR + +#undef __CREATE_USER_EVENT_ERR +#undef __SET_USER_EVENT_STATUS_ERR +#undef __SET_EVENT_CALLBACK_ERR + +#undef __WAIT_FOR_EVENTS_ERR + +#undef __CREATE_KERNEL_ERR +#undef __SET_KERNEL_ARGS_ERR +#undef __CREATE_PROGRAM_WITH_SOURCE_ERR +#undef __CREATE_PROGRAM_WITH_BINARY_ERR +#undef __BUILD_PROGRAM_ERR +#undef __CREATE_KERNELS_IN_PROGRAM_ERR + +#undef __CREATE_COMMAND_QUEUE_ERR +#undef __SET_COMMAND_QUEUE_PROPERTY_ERR +#undef __ENQUEUE_READ_BUFFER_ERR +#undef __ENQUEUE_WRITE_BUFFER_ERR +#undef __ENQUEUE_READ_BUFFER_RECT_ERR +#undef __ENQUEUE_WRITE_BUFFER_RECT_ERR +#undef __ENQEUE_COPY_BUFFER_ERR +#undef __ENQEUE_COPY_BUFFER_RECT_ERR +#undef __ENQUEUE_READ_IMAGE_ERR +#undef __ENQUEUE_WRITE_IMAGE_ERR +#undef __ENQUEUE_COPY_IMAGE_ERR +#undef __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR +#undef __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR +#undef __ENQUEUE_MAP_BUFFER_ERR +#undef __ENQUEUE_MAP_IMAGE_ERR +#undef __ENQUEUE_UNMAP_MEM_OBJECT_ERR +#undef __ENQUEUE_NDRANGE_KERNEL_ERR +#undef __ENQUEUE_TASK_ERR +#undef __ENQUEUE_NATIVE_KERNEL + +#undef __UNLOAD_COMPILER_ERR +#endif //__CL_USER_OVERRIDE_ERROR_STRINGS + +#undef __GET_INFO_HELPER_WITH_RETAIN + +// Extensions +#undef __INIT_CL_EXT_FCN_PTR +#undef __CREATE_SUB_DEVICES + +#if defined(USE_CL_DEVICE_FISSION) +#undef __PARAM_NAME_DEVICE_FISSION +#endif // USE_CL_DEVICE_FISSION + +#undef __DEFAULT_NOT_INITIALIZED +#undef __DEFAULT_BEING_INITIALIZED +#undef __DEFAULT_INITIALIZED + +} // namespace cl + +#ifdef _WIN32 +#pragma pop_macro("max") +#endif // _WIN32 + +#endif // CL_HPP_