OpenCL 1.0.2.3 → 1.0.2.4
raw patch · 12 files changed
+7915/−8 lines, 12 filesdep +OpenCLdep +QuickCheck
Dependencies added: OpenCL, QuickCheck
Files
- OpenCL.cabal +20/−8
- include/CL/cl.h +1239/−0
- include/CL/cl.hpp +4472/−0
- include/CL/cl_d3d10.h +126/−0
- include/CL/cl_d3d11.h +126/−0
- include/CL/cl_dx9_media_sharing.h +119/−0
- include/CL/cl_ext.h +213/−0
- include/CL/cl_gl.h +163/−0
- include/CL/cl_gl_ext.h +69/−0
- include/CL/cl_platform.h +1201/−0
- include/CL/opencl.h +54/−0
- src/test/test-opencl.hs +113/−0
OpenCL.cabal view
@@ -1,5 +1,5 @@ Name: OpenCL-Version: 1.0.2.3+Version: 1.0.2.4 License: BSD3 License-File: LICENSE Author: Luis Cabellos@@ -20,11 +20,15 @@ Most of the functions can throw a 'CLError' exception. Using the module 'Control.Exception' helps to work with this package's exceptions. -Extra-source-files: README.org - examples/example01.hs- examples/example02.hs- examples/example03.hs- examples/example04.hs+Extra-source-files:+ README.org+ examples/example01.hs+ examples/example02.hs+ examples/example03.hs+ examples/example04.hs+ include/CL/*.h+ include/CL/*.hpp+ src/test/*.hs Library Build-tools: c2hs@@ -47,12 +51,20 @@ else cpp-options: "-DCALLCONV=ccall" - cpp-options: -I include+ cpp-options: -Iinclude +Test-suite tests+ type: exitcode-stdio-1.0+ main-is: test-opencl.hs+ hs-Source-Dirs: src/test+ ghc-options: -Wall+ extra-libraries: OpenCL+ build-depends: base >=4.0 && < 5, QuickCheck==2.4.0.*, OpenCL+ source-repository this type: git location: https://zhensydow@github.com/zhensydow/opencl.git- tag: 1.0.2.3+ tag: 1.0.2.4 branch: master source-repository head
+ include/CL/cl.h view
@@ -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 <OpenCL/cl_platform.h>+#else+#include <CL/cl_platform.h>+#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 */+
+ include/CL/cl.hpp view
@@ -0,0 +1,4472 @@+/*******************************************************************************+ * 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 <OpenCL/cl.hpp>+ * #else+ * #include <CL/cl.hpp>+ * #endif+ * #include <cstdio>+ * #include <cstdlib>+ * #include <iostream>+ * + * const char * helloStr = "__kernel void "+ * "hello(void) "+ * "{ "+ * " "+ * "} ";+ * + * int+ * main(void)+ * {+ * cl_int err = CL_SUCCESS;+ * try {+ *+ * std::vector<cl::Platform> 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<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();+ * + * 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_++#ifdef _WIN32+#include <windows.h>+#include <malloc.h>+#if defined(USE_DX_INTEROP)+#include <CL/cl_d3d10.h>+#endif+#endif // _WIN32++// +#if defined(USE_CL_DEVICE_FISSION)+#include <CL/cl_ext.h>+#endif++#if defined(__APPLE__) || defined(__MACOSX)+#include <OpenGL/OpenGL.h>+#include <OpenCL/opencl.h>+#else+#include <GL/gl.h>+#include <CL/opencl.h>+#endif // !__APPLE__++#if !defined(CL_CALLBACK)+#define CL_CALLBACK+#endif //CL_CALLBACK++#include <utility>++#if !defined(__NO_STD_VECTOR)+#include <vector>+#endif++#if !defined(__NO_STD_STRING)+#include <string>+#endif ++#if defined(linux) || defined(__APPLE__) || defined(__MACOSX)+# include <alloca.h>+#endif // linux++#include <cstring>++/*! \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 <exception>+/*! \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 __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 <string>+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 <vector>+#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 <typename T, unsigned int N = __MAX_DEFAULT_VECTOR_SIZE>+class vector+{+private:+ T data_[N];+ unsigned int size_;+ bool empty_;+public:+ vector() : + size_(static_cast<unsigned int>(-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<T, N>& 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<T, N>& operator=(const vector<T, N>& 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<T,N> &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<class I>+ 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<T,N> vec_;+ int index_;+ bool initialized_;+ public:+ iterator(void) : + index_(-1),+ initialized_(false)+ {+ index_ = -1;+ initialized_ = false;+ }++ ~iterator(void) {}++ static iterator begin(vector<T,N> &vec)+ {+ iterator i;++ if (!vec.empty()) {+ i.index_ = 0;+ }++ i.vec_ = vec;+ i.initialized_ = true;+ return i;+ }++ static iterator end(vector<T,N> &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_];+ }+}; + +/*!+ * \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 <int N>+struct size_t : public cl::vector< ::size_t, N> { };++namespace detail {++// GetInfo help struct+template <typename Functor, typename T>+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 <typename Func, typename T>+struct GetInfoHelper<Func, VECTOR_CLASS<T> >+{+ static cl_int get(Func f, cl_uint name, VECTOR_CLASS<T>* 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<CL_PROGRAM_BINARIES>+template <typename Func>+struct GetInfoHelper<Func, VECTOR_CLASS<char *> >+{+ static cl_int+ get(Func f, cl_uint name, VECTOR_CLASS<char *>* param)+ {+ cl_uint err = f(name, param->size() * sizeof(char *), &(*param)[0], NULL);+ if (err != CL_SUCCESS) {+ return err;+ }+ + return CL_SUCCESS;+ }+};++// Specialized GetInfoHelper for STRING_CLASS params+template <typename Func>+struct GetInfoHelper<Func, STRING_CLASS>+{+ 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;+ }+};++#define __GET_INFO_HELPER_WITH_RETAIN(CPP_TYPE) \+namespace detail { \+template <typename Func> \+struct GetInfoHelper<Func, CPP_TYPE> \+{ \+ 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<CPP_TYPE::cl_type>::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_bitfield) \+ 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<Device>) \+ F(cl_context_info, CL_CONTEXT_PROPERTIES, VECTOR_CLASS<cl_context_properties>) \+ \+ 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<cl_device_id>) \+ 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<char *>) \+ \+ 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<cl_device_partition_property_ext>) \+ F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, VECTOR_CLASS<cl_device_partition_property_ext>) \+ F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT , cl_uint) \+ F(cl_device_info, CL_DEVICE_PARTITION_STYLE_EXT, VECTOR_CLASS<cl_device_partition_property_ext>)+#endif // USE_CL_DEVICE_FISSION++template <typename enum_type, cl_int Name>+struct param_traits {};++#define __CL_DECLARE_PARAM_TRAITS(token, param_name, T) \+struct token; \+template<> \+struct param_traits<detail:: token,param_name> \+{ \+ 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 <typename Func, typename T>+inline cl_int+getInfo(Func f, cl_uint name, T* param)+{+ return GetInfoHelper<Func, T>::get(f, name, param);+}++template <typename Func, typename Arg0>+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 <typename Func, typename Arg0, typename Arg1>+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 <typename Func, typename Arg0, typename T>+inline cl_int+getInfo(Func f, const Arg0& arg0, cl_uint name, T* param)+{+ GetInfoFunctor0<Func, Arg0> f0 = { f, arg0 };+ return GetInfoHelper<GetInfoFunctor0<Func, Arg0>, T>+ ::get(f0, name, param);+}++template <typename Func, typename Arg0, typename Arg1, typename T>+inline cl_int+getInfo(Func f, const Arg0& arg0, const Arg1& arg1, cl_uint name, T* param)+{+ GetInfoFunctor1<Func, Arg0, Arg1> f0 = { f, arg0, arg1 };+ return GetInfoHelper<GetInfoFunctor1<Func, Arg0, Arg1>, T>+ ::get(f0, name, param);+}++template<typename T>+struct ReferenceHandler+{ };++template <>+struct ReferenceHandler<cl_device_id>+{+ // 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>+{+ // 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<cl_context>+{+ static cl_int retain(cl_context context)+ { return ::clRetainContext(context); }+ static cl_int release(cl_context context)+ { return ::clReleaseContext(context); }+};++template <>+struct ReferenceHandler<cl_command_queue>+{+ 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<cl_mem>+{+ static cl_int retain(cl_mem memory)+ { return ::clRetainMemObject(memory); }+ static cl_int release(cl_mem memory)+ { return ::clReleaseMemObject(memory); }+};++template <>+struct ReferenceHandler<cl_sampler>+{+ static cl_int retain(cl_sampler sampler)+ { return ::clRetainSampler(sampler); }+ static cl_int release(cl_sampler sampler)+ { return ::clReleaseSampler(sampler); }+};++template <>+struct ReferenceHandler<cl_program>+{+ static cl_int retain(cl_program program)+ { return ::clRetainProgram(program); }+ static cl_int release(cl_program program)+ { return ::clReleaseProgram(program); }+};++template <>+struct ReferenceHandler<cl_kernel>+{+ static cl_int retain(cl_kernel kernel)+ { return ::clRetainKernel(kernel); }+ static cl_int release(cl_kernel kernel)+ { return ::clReleaseKernel(kernel); }+};++template <>+struct ReferenceHandler<cl_event>+{+ static cl_int retain(cl_event event)+ { return ::clRetainEvent(event); }+ static cl_int release(cl_event event)+ { return ::clReleaseEvent(event); }+};++template <typename T>+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<cl_type>& rhs)+ {+ object_ = rhs.object_;+ if (object_ != NULL) { retain(); }+ }++ Wrapper<cl_type>& operator = (const Wrapper<cl_type>& rhs)+ {+ if (object_ != NULL) { release(); }+ object_ = rhs.object_;+ if (object_ != NULL) { retain(); }+ return *this;+ }++ Wrapper<cl_type>& 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<cl_type>::retain(object_);+ }++ cl_int release() const+ {+ return ReferenceHandler<cl_type>::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<cl_device_id>+{+public:+ Device() : detail::Wrapper<cl_type>() { }++ Device(const Device& device) : detail::Wrapper<cl_type>(device) { }++ Device(const cl_device_id &device) : detail::Wrapper<cl_type>(device) { }++ Device& operator = (const Device& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Device& operator = (const cl_device_id& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ cl_int getInfo(cl_device_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetDeviceInfo, object_, name, param),+ __GET_DEVICE_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_device_info, name>::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<Device>* 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<cl_platform_id>+{+public:+ static const Platform null();++ Platform() : detail::Wrapper<cl_type>() { }++ Platform(const Platform& platform) : detail::Wrapper<cl_type>(platform) { }++ Platform(const cl_platform_id &platform) : detail::Wrapper<cl_type>(platform) { }++ Platform& operator = (const Platform& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Platform& operator = (const cl_platform_id& rhs)+ {+ detail::Wrapper<cl_type>::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 <cl_int name> typename+ detail::param_traits<detail::cl_platform_info, name>::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<Device>* 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<Device>* 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<Platform>* 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 inline cl_int+UnloadCompiler()+{+ return ::clUnloadCompiler();+}++class Context : public detail::Wrapper<cl_context>+{+public:+ Context(+ const VECTOR_CLASS<Device>& 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;+ object_ = ::clCreateContextFromType(+ properties, type, notifyFptr, data, &error);++ detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);+ if (err != NULL) {+ *err = error;+ }+ }++ Context() : detail::Wrapper<cl_type>() { }++ Context(const Context& context) : detail::Wrapper<cl_type>(context) { }++ Context(const cl_context& context) : detail::Wrapper<cl_type>(context) { }++ Context& operator = (const Context& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Context& operator = (const cl_context& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ cl_int getInfo(cl_context_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetContextInfo, object_, name, param),+ __GET_CONTEXT_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_context_info, name>::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<ImageFormat>* 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;+ }+};++__GET_INFO_HELPER_WITH_RETAIN(cl::Context)++/*! \class Event+ * \brief Event interface for cl_event.+ */+class Event : public detail::Wrapper<cl_event>+{+public:+ Event() : detail::Wrapper<cl_type>() { }++ Event(const Event& event) : detail::Wrapper<cl_type>(event) { }++ Event(const cl_event& event) : detail::Wrapper<cl_type>(event) { }++ Event& operator = (const Event& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Event& operator = (const cl_event& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ cl_int getInfo(cl_event_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetEventInfo, object_, name, param),+ __GET_EVENT_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_event_info, name>::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 <typename T>+ 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 <cl_int name> typename+ detail::param_traits<detail::cl_profiling_info, name>::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<Event>& 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<Event>& 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<cl_mem>+{+public:+ Memory() : detail::Wrapper<cl_type>() { }++ Memory(const Memory& memory) : detail::Wrapper<cl_type>(memory) { }++ Memory(const cl_mem& memory) : detail::Wrapper<cl_type>(memory) { }++ Memory& operator = (const Memory& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Memory& operator = (const cl_mem& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ 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 <cl_int name> typename+ detail::param_traits<detail::cl_mem_info, name>::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() : 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_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 <typename T>+ cl_int getImageInfo(cl_image_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetImageInfo, object_, name, param),+ __GET_IMAGE_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_image_info, name>::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_BUFFER_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_BUFFER_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<cl_sampler>+{+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<cl_type>(sampler) { }++ Sampler(const cl_sampler& sampler) : detail::Wrapper<cl_type>(sampler) { }++ Sampler& operator = (const Sampler& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Sampler& operator = (const cl_sampler& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ cl_int getInfo(cl_sampler_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetSamplerInfo, object_, name, param),+ __GET_SAMPLER_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_sampler_info, name>::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 <typename T>+struct KernelArgumentHandler+{+ static ::size_t size(const T&) { return sizeof(T); }+ static T* ptr(T& value) { return &value; }+};++template <>+struct KernelArgumentHandler<LocalSpaceArg>+{+ 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<cl_kernel>+{+public:+ inline Kernel(const Program& program, const char* name, cl_int* err = NULL);++ Kernel() { }++ Kernel(const Kernel& kernel) : detail::Wrapper<cl_type>(kernel) { }++ Kernel(const cl_kernel& kernel) : detail::Wrapper<cl_type>(kernel) { }++ Kernel& operator = (const Kernel& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Kernel& operator = (const cl_kernel& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ cl_int getInfo(cl_kernel_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetKernelInfo, object_, name, param),+ __GET_KERNEL_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_kernel_info, name>::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 <typename T>+ 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 <cl_int name> typename+ detail::param_traits<detail::cl_kernel_work_group_info, name>::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 <typename T>+ cl_int setArg(cl_uint index, T value)+ {+ return detail::errHandler(+ ::clSetKernelArg(+ object_,+ index,+ detail::KernelArgumentHandler<T>::size(value),+ detail::KernelArgumentHandler<T>::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);+ }++ KernelFunctor bind(+ const CommandQueue& queue,+ const NDRange& offset,+ const NDRange& global,+ const NDRange& local);++ KernelFunctor bind(+ const CommandQueue& queue,+ const NDRange& global,+ const NDRange& local);++ template<typename A0>+ inline void setArgs(+ const A0& a0)+ {+ setArg(0, a0);+ }++ template<typename A0, typename A1>+ inline void setArgs(+ const A0& a0,+ const A1& a1)+ {+ setArgs(a0);+ setArg(1, a1);+ }++ template<typename A0, typename A1, typename A2>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2)+ {+ setArgs(a0, a1);+ setArg(2, a2);+ }++ template<typename A0, typename A1, typename A2, typename A3>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3)+ {+ setArgs(a0, a1, a2);+ setArg(3, a3);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4)+ {+ setArgs(a0, a1, a2, a3);+ setArg(4, a4);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5)+ {+ setArgs(a0, a1, a2, a3, a4);+ setArg(5, a5);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6)+ {+ setArgs(a0, a1, a2, a3, a4, a5);+ setArg(6, a6);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6);+ setArg(7, a7);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7);+ setArg(8, a8);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8);+ setArg(9, a9);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9,+ typename A10>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9,+ const A10& a10)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);+ setArg(10, a10);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9,+ typename A10, typename A11>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9,+ const A10& a10,+ const A11& a11)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);+ setArg(11, a11);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9,+ typename A10, typename A11, typename A12>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9,+ const A10& a10,+ const A11& a11,+ const A12& a12)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);+ setArg(12, a12);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9,+ typename A10, typename A11, typename A12, typename A13>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9,+ const A10& a10,+ const A11& a11,+ const A12& a12,+ const A13& a13)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);+ setArg(13, a13);+ }++ template<typename A0, typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7, typename A8, typename A9,+ typename A10, typename A11, typename A12, typename A13, typename A14>+ inline void setArgs(+ const A0& a0,+ const A1& a1,+ const A2& a2,+ const A3& a3,+ const A4& a4,+ const A5& a5,+ const A6& a6,+ const A7& a7,+ const A8& a8,+ const A9& a9,+ const A10& a10,+ const A11& a11,+ const A12& a12,+ const A13& a13,+ const A13& a14)+ {+ setArgs(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);+ setArg(14, a14);+ }+};++__GET_INFO_HELPER_WITH_RETAIN(cl::Kernel)++/*! \class Program+ * \brief Program interface that implements cl_program.+ */+class Program : public detail::Wrapper<cl_program>+{+public:+ typedef VECTOR_CLASS<std::pair<const void*, ::size_t> > Binaries;+ typedef VECTOR_CLASS<std::pair<const char*, ::size_t> > Sources;++ 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<Device>& devices,+ const Binaries& binaries,+ VECTOR_CLASS<cl_int>* 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<cl_type>(program) { }++ Program(const cl_program& program) : detail::Wrapper<cl_type>(program) { }++ Program& operator = (const Program& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ Program& operator = (const cl_program& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ cl_int build(+ const VECTOR_CLASS<Device>& 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);+ }++ template <typename T>+ cl_int getInfo(cl_program_info name, T* param) const+ {+ return detail::errHandler(+ detail::getInfo(&::clGetProgramInfo, object_, name, param),+ __GET_PROGRAM_INFO_ERR);+ }++ template <cl_int name> typename+ detail::param_traits<detail::cl_program_info, name>::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 <typename T>+ 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 <cl_int name> typename+ detail::param_traits<detail::cl_program_build_info, name>::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<Kernel>* 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<char *> cl::Program::getInfo<CL_PROGRAM_BINARIES>(cl_int* err) const+{+ VECTOR_CLASS< ::size_t> sizes = getInfo<CL_PROGRAM_BINARY_SIZES>();+ VECTOR_CLASS<char *> 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<cl_command_queue>+{+public:+ 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;+ }+ }++ CommandQueue() { }++ CommandQueue(const CommandQueue& commandQueue) : detail::Wrapper<cl_type>(commandQueue) { }++ CommandQueue(const cl_command_queue& commandQueue) : detail::Wrapper<cl_type>(commandQueue) { }++ CommandQueue& operator = (const CommandQueue& rhs)+ {+ if (this != &rhs) {+ detail::Wrapper<cl_type>::operator=(rhs);+ }+ return *this;+ }++ CommandQueue& operator = (const cl_command_queue& rhs)+ {+ detail::Wrapper<cl_type>::operator=(rhs);+ return *this;+ }++ template <typename T>+ 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 <cl_int name> typename+ detail::param_traits<detail::cl_command_queue_info, name>::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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* 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<Event>* events = NULL,+ Event* event = NULL,+ cl_int* err = NULL) const+ {+ cl_event tmp;+ 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,+ (event != NULL) ? &tmp : NULL,+ &error);++ detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);++ if (event != NULL && error == CL_SUCCESS) {+ *event = tmp;+ }++ 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<Event>* events = NULL,+ Event* event = NULL,+ cl_int* err = NULL) const+ {+ cl_event tmp;+ 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,+ (event != NULL) ? &tmp : NULL,+ &error);++ detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR);++ if (event != NULL && error == CL_SUCCESS) {+ *event = tmp;+ }++ if (err != NULL) {+ *err = error;+ }+ return result;+ }++ cl_int enqueueUnmapMemObject(+ const Memory& memory,+ void* mapped_ptr,+ const VECTOR_CLASS<Event>* 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,+ const VECTOR_CLASS<Event>* 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<Event>* 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 (*userFptr)(void *),+ std::pair<void*, ::size_t> args,+ const VECTOR_CLASS<Memory>* mem_objects = NULL,+ const VECTOR_CLASS<const void*>* mem_locs = NULL,+ const VECTOR_CLASS<Event>* 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<Event>& 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<Memory>* mem_objects = NULL,+ const VECTOR_CLASS<Event>* 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<Memory>* mem_objects = NULL,+ const VECTOR_CLASS<Event>* 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<Memory>* mem_objects = NULL,+ const VECTOR_CLASS<Event>* 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<Memory>* mem_objects = NULL,+ const VECTOR_CLASS<Event>* 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)++/*! \class KernelFunctor+ * \brief Kernel functor interface+ *+ * \note Currently only functors of zero to ten arguments are supported. It+ * is straightforward to add more and a more general solution, similar to+ * Boost.Lambda could be followed if required in the future.+ */+class KernelFunctor+{+private:+ Kernel kernel_;+ CommandQueue queue_;+ NDRange offset_;+ NDRange global_;+ NDRange local_;++ cl_int err_;+public:+ KernelFunctor() { }++ KernelFunctor(+ const Kernel& kernel,+ const CommandQueue& queue,+ const NDRange& offset,+ const NDRange& global,+ const NDRange& local) :+ kernel_(kernel),+ queue_(queue),+ offset_(offset),+ global_(global),+ local_(local),+ err_(CL_SUCCESS)+ {}++ KernelFunctor& operator=(const KernelFunctor& rhs);++ KernelFunctor(const KernelFunctor& rhs);++ cl_int getError() { return err_; }++ inline Event operator()(const VECTOR_CLASS<Event>* events = NULL);++ template<typename A1>+ inline Event operator()(+ const A1& a1, + const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4, class A5>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4, class A5, class A6>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4,+ class A5, class A6, class A7>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6, + const A7& a7,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6, + const A7& a7, + const A8& a8,+ const VECTOR_CLASS<Event>* events = NULL);++ template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6, + const A7& a7, + const A8& a8, + const A9& a9,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11, + const A12& a12,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11, + const A12& a12, + const A13& a13,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13, class A14>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const A12& a12, + const A13& a13, + const A14& a14,+ const VECTOR_CLASS<Event>* events = NULL);+ + template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13, class A14, class A15>+ inline Event operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const A12& a12, + const A13& a13, + const A14& a14, + const A15& a15,+ const VECTOR_CLASS<Event>* events = NULL);+};++inline KernelFunctor Kernel::bind(+ const CommandQueue& queue,+ const NDRange& offset,+ const NDRange& global,+ const NDRange& local)+{+ return KernelFunctor(*this,queue,offset,global,local);+}++inline KernelFunctor Kernel::bind(+ const CommandQueue& queue,+ const NDRange& global,+ const NDRange& local)+{+ return KernelFunctor(*this,queue,NullRange,global,local);+}++inline KernelFunctor& KernelFunctor::operator=(const KernelFunctor& rhs)+{+ if (this == &rhs) {+ return *this;+ }+ + kernel_ = rhs.kernel_;+ queue_ = rhs.queue_;+ offset_ = rhs.offset_;+ global_ = rhs.global_;+ local_ = rhs.local_;+ + return *this;+}++inline KernelFunctor::KernelFunctor(const KernelFunctor& rhs) :+ kernel_(rhs.kernel_),+ queue_(rhs.queue_),+ offset_(rhs.offset_),+ global_(rhs.global_),+ local_(rhs.local_)+{+}++Event KernelFunctor::operator()(const VECTOR_CLASS<Event>* )+{+ Event event;++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1>+Event KernelFunctor::operator()(+ const A1& a1, + const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4, typename A5>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4, typename A5,+ typename A6>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4,+ typename A5, typename A6, typename A7>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6, + const A7& a7,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4, typename A5,+ typename A6, typename A7, typename A8>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6, + const A7& a7, + const A8& a8,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4, typename A5,+ typename A6, typename A7, typename A8, typename A9>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5,+ const A6& a6, + const A7& a7, + const A8& a8, + const A9& a9,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<typename A1, typename A2, typename A3, typename A4, typename A5,+ typename A6, typename A7, typename A8, typename A9, typename A10>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11, + const A12& a12,+ const VECTOR_CLASS<Event>* )+{+ Event event;++ kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11, + const A12& a12, + const A13& a13,+ const VECTOR_CLASS<Event>* )+{+ Event event;+ + kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13, class A14>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5, + const A6& a6,+ const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const A12& a12, + const A13& a13, + const A14& a14,+ const VECTOR_CLASS<Event>* )+{+ Event event;+ + kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++template<class A1, class A2, class A3, class A4, class A5,+ class A6, class A7, class A8, class A9, class A10,+ class A11, class A12, class A13, class A14, class A15>+Event KernelFunctor::operator()(+ const A1& a1, + const A2& a2, + const A3& a3, + const A4& a4, + const A5& a5,+ const A6& a6, + const A7& a7, + const A8& a8, + const A9& a9, + const A10& a10, + const A11& a11,+ const A12& a12, + const A13& a13, + const A14& a14, + const A15& a15,+ const VECTOR_CLASS<Event>* )+{+ Event event;+ + kernel_.setArgs(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);++ err_ = queue_.enqueueNDRangeKernel(+ kernel_,+ offset_,+ global_,+ local_,+ NULL, // bgaster_fixme - do we want to allow wait event lists?+ &event);++ return event;+}++#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++} // namespace cl++#endif // CL_HPP_
+ include/CL/cl_d3d10.h view
@@ -0,0 +1,126 @@+/**********************************************************************************+ * 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_CL_D3D10_H+#define __OPENCL_CL_D3D10_H++#include <d3d10.h>+#include <CL/cl.h>+#include <CL/cl_platform.h>++#ifdef __cplusplus+extern "C" {+#endif++/******************************************************************************+ * cl_khr_d3d10_sharing */+#define cl_khr_d3d10_sharing 1++typedef cl_uint cl_d3d10_device_source_khr;+typedef cl_uint cl_d3d10_device_set_khr;++/******************************************************************************/++// Error Codes+#define CL_INVALID_D3D10_DEVICE_KHR -1002+#define CL_INVALID_D3D10_RESOURCE_KHR -1003+#define CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR -1004+#define CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR -1005++// cl_d3d10_device_source_nv+#define CL_D3D10_DEVICE_KHR 0x4010+#define CL_D3D10_DXGI_ADAPTER_KHR 0x4011++// cl_d3d10_device_set_nv+#define CL_PREFERRED_DEVICES_FOR_D3D10_KHR 0x4012+#define CL_ALL_DEVICES_FOR_D3D10_KHR 0x4013++// cl_context_info+#define CL_CONTEXT_D3D10_DEVICE_KHR 0x4014+#define CL_CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR 0x402C++// cl_mem_info+#define CL_MEM_D3D10_RESOURCE_KHR 0x4015++// cl_image_info+#define CL_IMAGE_D3D10_SUBRESOURCE_KHR 0x4016++// cl_command_type+#define CL_COMMAND_ACQUIRE_D3D10_OBJECTS_KHR 0x4017+#define CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR 0x4018++/******************************************************************************/++typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceIDsFromD3D10KHR_fn)(+ 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) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D10BufferKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D10Buffer * resource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D10Texture2DKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D10Texture2D * resource,+ UINT subresource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D10Texture3DKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D10Texture3D * resource,+ UINT subresource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireD3D10ObjectsKHR_fn)(+ 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;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseD3D10ObjectsKHR_fn)(+ 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 __cplusplus+}+#endif++#endif // __OPENCL_CL_D3D10_H+
+ include/CL/cl_d3d11.h view
@@ -0,0 +1,126 @@+/**********************************************************************************+ * 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_CL_D3D11_H+#define __OPENCL_CL_D3D11_H++#include <d3d11.h>+#include <CL/cl.h>+#include <CL/cl_platform.h>++#ifdef __cplusplus+extern "C" {+#endif++/******************************************************************************+ * cl_khr_d3d11_sharing */+#define cl_khr_d3d11_sharing 1++typedef cl_uint cl_d3d11_device_source_khr;+typedef cl_uint cl_d3d11_device_set_khr;++/******************************************************************************/++// Error Codes+#define CL_INVALID_D3D11_DEVICE_KHR -1006+#define CL_INVALID_D3D11_RESOURCE_KHR -1007+#define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR -1008+#define CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR -1009++// cl_d3d11_device_source+#define CL_D3D11_DEVICE_KHR 0x4019+#define CL_D3D11_DXGI_ADAPTER_KHR 0x401A++// cl_d3d11_device_set+#define CL_PREFERRED_DEVICES_FOR_D3D11_KHR 0x401B+#define CL_ALL_DEVICES_FOR_D3D11_KHR 0x401C++// cl_context_info+#define CL_CONTEXT_D3D11_DEVICE_KHR 0x401D+#define CL_CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR 0x402D++// cl_mem_info+#define CL_MEM_D3D11_RESOURCE_KHR 0x401E++// cl_image_info+#define CL_IMAGE_D3D11_SUBRESOURCE_KHR 0x401F++// cl_command_type+#define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_KHR 0x4020+#define CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR 0x4021++/******************************************************************************/++typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceIDsFromD3D11KHR_fn)(+ cl_platform_id platform,+ cl_d3d11_device_source_khr d3d_device_source,+ void * d3d_object,+ cl_d3d11_device_set_khr d3d_device_set,+ cl_uint num_entries,+ cl_device_id * devices,+ cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11BufferKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D11Buffer * resource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11Texture2DKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D11Texture2D * resource,+ UINT subresource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromD3D11Texture3DKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ ID3D11Texture3D * resource,+ UINT subresource,+ cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireD3D11ObjectsKHR_fn)(+ 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;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseD3D11ObjectsKHR_fn)(+ 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 __cplusplus+}+#endif++#endif // __OPENCL_CL_D3D11_H+
+ include/CL/cl_dx9_media_sharing.h view
@@ -0,0 +1,119 @@+/**********************************************************************************+ * Copyright (c) 2008-2012 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_CL_DX9_MEDIA_SHARING_H+#define __OPENCL_CL_DX9_MEDIA_SHARING_H++#include <CL/cl.h>+#include <CL/cl_platform.h>++#ifdef __cplusplus+extern "C" {+#endif++/******************************************************************************+/* cl_khr_dx9_media_sharing */+#define cl_khr_dx9_media_sharing 1++typedef struct _cl_dx9_surface_info_khr+{+ IDirect3DSurface9 *resource;+ HANDLE shared_handle;+} cl_dx9_surface_info_khr;++/******************************************************************************/++// Error Codes+#define CL_INVALID_DX9_MEDIA_ADAPTER_KHR -1010+#define CL_INVALID_DX9_MEDIA_SURFACE_KHR -1011+#define CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR -1012+#define CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR -1013++// cl_media_adapter_type_khr+#define CL_ADAPTER_D3D9_KHR 0x2020+#define CL_ADAPTER_D3D9EX_KHR 0x2021+#define CL_ADAPTER_DXVA_KHR 0x2022++// cl_media_adapter_set_khr+#define CL_PREFERRED_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2023+#define CL_ALL_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2024++// cl_context_info+#define CL_CONTEXT_D3D9_DEVICE_KHR 0x2025+#define CL_CONTEXT_D3D9EX_DEVICE_KHR 0x2026+#define CL_CONTEXT_DXVA_DEVICE_KHR 0x2027++// cl_mem_info+#define CL_MEM_DX9_MEDIA_ADAPTER_TYPE_KHR 0x2028+#define CL_MEM_DX9_MEDIA_SURFACE_INFO_KHR 0x2029++// cl_image_info+#define CL_IMAGE_DX9_MEDIA_PLANE_KHR 0x202A++// cl_command_type+#define CL_COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR 0x202B+#define CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR 0x202C++/******************************************************************************/++typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceIDsForDX9MediaAdapterKHR_fn)(+ cl_platform_id platform,+ cl_dx9_media_adapter_type_khr media_adapter_type,+ void * media_adapter,+ cl_dx9_media_adapter_set_khr media_adapter_set,+ cl_uint num_entries,+ cl_device_id * devices,+ cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2;++typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromDX9MediaSurfaceKHR_fn)(+ cl_context context,+ cl_mem_flags flags,+ cl_dx9_media_adapter_type_khr adapter_type,+ void * surface_info,+ cl_uint plane, + cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireDX9MediaSurfacesKHR_fn)(+ 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_2;++typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseDX9MediaSurfacesKHR_fn)(+ cl_command_queue command_queue,+ cl_uint num_objects,+ 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_2;++#ifdef __cplusplus+}+#endif++#endif // __OPENCL_CL_DX9_MEDIA_SHARING_H+
+ include/CL/cl_ext.h view
@@ -0,0 +1,213 @@+/*******************************************************************************+ * 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: 11928 $ on $Date: 2010-07-13 09:04:56 -0700 (Tue, 13 Jul 2010) $ */++/* 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 <OpenCL/cl.h>+ #include <AvailabilityMacros.h>+#else+ #include <CL/cl.h>+#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_attribute_query *+*********************************/+#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036+++#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)++++#endif /* CL_VERSION_1_1 */++#ifdef __cplusplus+}+#endif+++#endif /* __CL_EXT_H */
+ include/CL/cl_gl.h view
@@ -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 <OpenCL/cl.h>+#else+#include <CL/cl.h>+#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 */
+ include/CL/cl_gl_ext.h view
@@ -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: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */++/* 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 <OpenCL/cl_gl.h>+#else+ #include <CL/cl_gl.h>+#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 */
+ include/CL/cl_platform.h view
@@ -0,0 +1,1201 @@+/**********************************************************************************+ * 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: 11803 $ on $Date: 2010-06-25 10:02:12 -0700 (Fri, 25 Jun 2010) $ */++#ifndef __CL_PLATFORM_H+#define __CL_PLATFORM_H++#ifdef __APPLE__+ /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */+ #include <AvailabilityMacros.h>+#endif++#ifdef __cplusplus+extern "C" {+#endif++#if defined(_WIN32)+ #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;+typedef float cl_float;+typedef double cl_double;++/* Macro names and corresponding values defined by OpenCL */+#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 340282346638528859811704183484516925440.0f+#define CL_FLT_MIN 1.175494350822287507969e-38f+#define CL_FLT_EPSILON 0x1.0p-23f++#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 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0+#define CL_DBL_MIN 2.225073858507201383090e-308+#define CL_DBL_EPSILON 2.220446049250313080847e-16++#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++#else++#include <stdint.h>++/* scalar types */+typedef int8_t cl_char;+typedef uint8_t cl_uchar;+typedef int16_t cl_short __attribute__((aligned(2)));+typedef uint16_t cl_ushort __attribute__((aligned(2)));+typedef int32_t cl_int __attribute__((aligned(4)));+typedef uint32_t cl_uint __attribute__((aligned(4)));+typedef int64_t cl_long __attribute__((aligned(8)));+typedef uint64_t cl_ulong __attribute__((aligned(8)));++typedef uint16_t cl_half __attribute__((aligned(2)));+typedef float cl_float __attribute__((aligned(4)));+typedef double cl_double __attribute__((aligned(8)));++/* Macro names and corresponding values defined by OpenCL */+#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 0x1.fffffep127f+#define CL_FLT_MIN 0x1.0p-126f+#define CL_FLT_EPSILON 0x1.0p-23f++#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 0x1.fffffffffffffp1023+#define CL_DBL_MIN 0x1.0p-1022+#define CL_DBL_EPSILON 0x1.0p-52++#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++#if defined( __GNUC__ )+ #define CL_HUGE_VALF __builtin_huge_valf()+ #define CL_HUGE_VAL __builtin_huge_val()+ #define CL_NAN __builtin_nanf( "" )+#else+ #define CL_HUGE_VALF ((cl_float) 1e50)+ #define CL_HUGE_VAL ((cl_double) 1e500)+ float nanf( const char * );+ #define CL_NAN nanf( "" ) +#endif+#define CL_MAXFLOAT CL_FLT_MAX+#define CL_INFINITY CL_HUGE_VALF++#endif++#include <stddef.h>++/* 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 <altivec.h> /* 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 <intrin.h>+ #else+ #include <xmmintrin.h>+ #endif+ #if defined( __GNUC__ )+ 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 <intrin.h>+ #else+ #include <emmintrin.h>+ #endif+ #if defined( __GNUC__ )+ 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 <mmintrin.h>+ #if defined( __GNUC__ )+ 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 <intrin.h>+ #else+ #include <immintrin.h> + #endif+ #if defined( __GNUC__ )+ 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__ )+ #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 <crtdefs.h> */+ /* #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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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( __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 */
+ include/CL/opencl.h view
@@ -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 <OpenCL/cl.h>+#include <OpenCL/cl_gl.h>+#include <OpenCL/cl_gl_ext.h>+#include <OpenCL/cl_ext.h>++#else++#include <CL/cl.h>+#include <CL/cl_gl.h>+#include <CL/cl_gl_ext.h>+#include <CL/cl_ext.h>++#endif++#ifdef __cplusplus+}+#endif++#endif /* __OPENCL_H */+
+ src/test/test-opencl.hs view
@@ -0,0 +1,113 @@+{- Copyright (c) 2011 Luis Cabellos,++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++ * Redistributions of source code must retain the above copyright+ notice, this list of conditions and the following disclaimer.++ * 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.++ * Neither the name of nor the names of other+ 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+OWNER 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.+-}++-- -----------------------------------------------------------------------------+import Foreign( castPtr, nullPtr, sizeOf )+import Foreign.C.Types( CInt )+import Foreign.Marshal.Array( newArray, peekArray )+import Test.QuickCheck( Property, Testable, quickCheckWithResult, (==>) )+import Test.QuickCheck.Monadic( monadicIO, assert, run )+import Test.QuickCheck.Test( Result, Args(..), isSuccess, stdArgs )+import Text.Printf( printf )+import System.Exit( exitSuccess, exitFailure )+import System.GPU.OpenCL++-- -----------------------------------------------------------------------------+clDupSource :: String+clDupSource = "__kernel void duparray(__global int *in, __global int *out ){\n int id = get_global_id(0);\n out[id] = 2*in[id];\n}"++dupOpencl :: [Int] -> IO [Int]+dupOpencl xs = do+ -- Initialize OpenCL+ (platform:_) <- clGetPlatformIDs+ (dev:_) <- clGetDeviceIDs platform CL_DEVICE_TYPE_ALL+ context <- clCreateContext [dev] print+ q <- clCreateCommandQueue context dev []+ + -- Initialize Kernel+ program <- clCreateProgramWithSource context clDupSource+ clBuildProgram program [dev] ""+ kernel <- clCreateKernel program "duparray"+ + -- Initialize parameters+ let original = map fromIntegral xs :: [CInt]+ elemSize = sizeOf (0 :: CInt)+ vecSize = elemSize * length original++ input <- newArray original++ mem_in <- clCreateBuffer context [CL_MEM_READ_ONLY, CL_MEM_COPY_HOST_PTR] (vecSize, castPtr input) + mem_out <- clCreateBuffer context [CL_MEM_WRITE_ONLY] (vecSize, nullPtr)++ clSetKernelArg kernel 0 mem_in+ clSetKernelArg kernel 1 mem_out+ + -- Execute Kernel+ eventExec <- clEnqueueNDRangeKernel q kernel [length original] [1] []+ + -- Get Result+ _ <- clEnqueueReadBuffer q mem_out True 0 vecSize (castPtr input) [eventExec]+ + _ <- clReleaseMemObject mem_in+ _ <- clReleaseMemObject mem_out+ + result <- peekArray (length original) input++ return $ map fromIntegral result++dupHaskell :: [Int] -> [Int]+dupHaskell = map (*2)++prop_dup :: [Int] -> Property+prop_dup xs = not (null xs) ==> monadicIO test+ where+ test = do+ ys <- run $ dupOpencl xs+ assert (dupHaskell xs == ys)++-- -----------------------------------------------------------------------------+fastCheck :: Testable prop => prop -> IO Result+fastCheck = quickCheckWithResult stdArgs{ maxSuccess = 20, maxSize = 50 }++tests :: [(String, IO Result)]+tests = + [ ("Opencl: duplicate int array", fastCheck prop_dup) ]++-- -----------------------------------------------------------------------------+main :: IO ()+main = do+ results <- mapM (\(s,a) -> printf "%-25s: " s >> a) tests+ if all isSuccess results+ then exitSuccess + else exitFailure++-- -----------------------------------------------------------------------------