Mercurial > projects > cl4d

comparison opencl/c/cl.d @ 1:5b5ace425b37

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* moved c.opencl to c.cl * updated c.cl_gl + c.d3d10
author Trass3r
date Wed, 14 Apr 2010 13:52:17 +0200
parents opencl/c/opencl.d@3cea44337083
children 01d502efe0c4
comparison
equal deleted inserted replaced
0:3cea44337083 1:5b5ace425b37
1 /*******************************************************************************
2 * Copyright (c) 2008-2009 The Khronos Group Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and/or associated documentation files (the
6 * "Materials"), to deal in the Materials without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Materials, and to
9 * permit persons to whom the Materials are furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Materials.
14 *
15 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
22 ******************************************************************************/
23
24 // $Revision: 9283 $ on $Date: 2009-10-14 10:18:57 -0700 (Wed, 14 Oct 2009) $
25
26 module opencl.c.opencl;
27
28 public import opencl.c.platform;
29
30 extern(C):
31
32 alias const(void)*
33 cl_platform_id,
34 cl_device_id,
35 cl_context,
36 cl_command_queue,
37 cl_mem,
38 cl_program,
39 cl_kernel,
40 cl_event,
41 cl_sampler;
42
43 alias 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.
44 alias cl_ulong cl_bitfield;
45 alias cl_bitfield cl_device_type;
46 alias cl_uint cl_platform_info;
47 alias cl_uint cl_device_info;
48 alias cl_bitfield cl_device_address_info;
49 alias cl_bitfield cl_device_fp_config;
50 alias cl_uint cl_device_mem_cache_type;
51 alias cl_uint cl_device_local_mem_type;
52 alias cl_bitfield cl_device_exec_capabilities;
53 alias cl_bitfield cl_command_queue_properties;
54
55 alias cl_bitfield cl_context_properties;
56 alias cl_uint cl_context_info;
57 alias cl_uint cl_command_queue_info;
58 alias cl_uint cl_channel_order;
59 alias cl_uint cl_channel_type;
60 alias cl_bitfield cl_mem_flags;
61 alias cl_uint cl_mem_object_type;
62 alias cl_uint cl_mem_info;
63 alias cl_uint cl_image_info;
64 alias cl_uint cl_addressing_mode;
65 alias cl_uint cl_filter_mode;
66 alias cl_uint cl_sampler_info;
67 alias cl_bitfield cl_map_flags;
68 alias cl_uint cl_program_info;
69 alias cl_uint cl_program_build_info;
70 alias cl_uint cl_build_status;
71 alias cl_uint cl_kernel_info;
72 alias cl_uint cl_kernel_work_group_info;
73 alias cl_uint cl_event_info;
74 alias cl_uint cl_command_type;
75 alias cl_uint cl_profiling_info;
76
77 struct cl_image_format
78 {
79 cl_channel_order image_channel_order;
80 cl_channel_type image_channel_data_type;
81 }
82
83 /******************************************************************************/
84
85 enum
86 {
87 // Error Codes
88 CL_SUCCESS = 0,
89 CL_DEVICE_NOT_FOUND = -1,
90 CL_DEVICE_NOT_AVAILABLE = -2,
91 CL_COMPILER_NOT_AVAILABLE = -3,
92 CL_MEM_OBJECT_ALLOCATION_FAILURE = -4,
93 CL_OUT_OF_RESOURCES = -5,
94 CL_OUT_OF_HOST_MEMORY = -6,
95 CL_PROFILING_INFO_NOT_AVAILABLE = -7,
96 CL_MEM_COPY_OVERLAP = -8,
97 CL_IMAGE_FORMAT_MISMATCH = -9,
98 CL_IMAGE_FORMAT_NOT_SUPPORTED = -10,
99 CL_BUILD_PROGRAM_FAILURE = -11,
100 CL_MAP_FAILURE = -12,
101
102 CL_INVALID_VALUE = -30,
103 CL_INVALID_DEVICE_TYPE = -31,
104 CL_INVALID_PLATFORM = -32,
105 CL_INVALID_DEVICE = -33,
106 CL_INVALID_CONTEXT = -34,
107 CL_INVALID_QUEUE_PROPERTIES = -35,
108 CL_INVALID_COMMAND_QUEUE = -36,
109 CL_INVALID_HOST_PTR = -37,
110 CL_INVALID_MEM_OBJECT = -38,
111 CL_INVALID_IMAGE_FORMAT_DESCRIPTOR = -39,
112 CL_INVALID_IMAGE_SIZE = -40,
113 CL_INVALID_SAMPLER = -41,
114 CL_INVALID_BINARY = -42,
115 CL_INVALID_BUILD_OPTIONS = -43,
116 CL_INVALID_PROGRAM = -44,
117 CL_INVALID_PROGRAM_EXECUTABLE = -45,
118 CL_INVALID_KERNEL_NAME = -46,
119 CL_INVALID_KERNEL_DEFINITION = -47,
120 CL_INVALID_KERNEL = -48,
121 CL_INVALID_ARG_INDEX = -49,
122 CL_INVALID_ARG_VALUE = -50,
123 CL_INVALID_ARG_SIZE = -51,
124 CL_INVALID_KERNEL_ARGS = -52,
125 CL_INVALID_WORK_DIMENSION = -53,
126 CL_INVALID_WORK_GROUP_SIZE = -54,
127 CL_INVALID_WORK_ITEM_SIZE = -55,
128 CL_INVALID_GLOBAL_OFFSET = -56,
129 CL_INVALID_EVENT_WAIT_LIST = -57,
130 CL_INVALID_EVENT = -58,
131 CL_INVALID_OPERATION = -59,
132 CL_INVALID_GL_OBJECT = -60,
133 CL_INVALID_BUFFER_SIZE = -61,
134 CL_INVALID_MIP_LEVEL = -62,
135 CL_INVALID_GLOBAL_WORK_SIZE = -63,
136
137 // OpenCL Version
138 CL_VERSION_1_0 = 1,
139
140 // cl_bool
141 CL_FALSE = 0,
142 CL_TRUE = 1,
143
144 // cl_platform_info
145 CL_PLATFORM_PROFILE = 0x0900,
146 CL_PLATFORM_VERSION = 0x0901,
147 CL_PLATFORM_NAME = 0x0902,
148 CL_PLATFORM_VENDOR = 0x0903,
149 CL_PLATFORM_EXTENSIONS = 0x0904,
150
151 // cl_device_type - bitfield
152 CL_DEVICE_TYPE_DEFAULT = (1 << 0),
153 CL_DEVICE_TYPE_CPU = (1 << 1),
154 CL_DEVICE_TYPE_GPU = (1 << 2),
155 CL_DEVICE_TYPE_ACCELERATOR = (1 << 3),
156 CL_DEVICE_TYPE_ALL = 0xFFFFFFFF,
157
158 // cl_device_info
159 CL_DEVICE_TYPE = 0x1000,
160 CL_DEVICE_VENDOR_ID = 0x1001,
161 CL_DEVICE_MAX_COMPUTE_UNITS = 0x1002,
162 CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS = 0x1003,
163 CL_DEVICE_MAX_WORK_GROUP_SIZE = 0x1004,
164 CL_DEVICE_MAX_WORK_ITEM_SIZES = 0x1005,
165 CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR = 0x1006,
166 CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT = 0x1007,
167 CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT = 0x1008,
168 CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG = 0x1009,
169 CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT = 0x100A,
170 CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE = 0x100B,
171 CL_DEVICE_MAX_CLOCK_FREQUENCY = 0x100C,
172 CL_DEVICE_ADDRESS_BITS = 0x100D,
173 CL_DEVICE_MAX_READ_IMAGE_ARGS = 0x100E,
174 CL_DEVICE_MAX_WRITE_IMAGE_ARGS = 0x100F,
175 CL_DEVICE_MAX_MEM_ALLOC_SIZE = 0x1010,
176 CL_DEVICE_IMAGE2D_MAX_WIDTH = 0x1011,
177 CL_DEVICE_IMAGE2D_MAX_HEIGHT = 0x1012,
178 CL_DEVICE_IMAGE3D_MAX_WIDTH = 0x1013,
179 CL_DEVICE_IMAGE3D_MAX_HEIGHT = 0x1014,
180 CL_DEVICE_IMAGE3D_MAX_DEPTH = 0x1015,
181 CL_DEVICE_IMAGE_SUPPORT = 0x1016,
182 CL_DEVICE_MAX_PARAMETER_SIZE = 0x1017,
183 CL_DEVICE_MAX_SAMPLERS = 0x1018,
184 CL_DEVICE_MEM_BASE_ADDR_ALIGN = 0x1019,
185 CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE = 0x101A,
186 CL_DEVICE_SINGLE_FP_CONFIG = 0x101B,
187 CL_DEVICE_GLOBAL_MEM_CACHE_TYPE = 0x101C,
188 CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE = 0x101D,
189 CL_DEVICE_GLOBAL_MEM_CACHE_SIZE = 0x101E,
190 CL_DEVICE_GLOBAL_MEM_SIZE = 0x101F,
191 CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE = 0x1020,
192 CL_DEVICE_MAX_CONSTANT_ARGS = 0x1021,
193 CL_DEVICE_LOCAL_MEM_TYPE = 0x1022,
194 CL_DEVICE_LOCAL_MEM_SIZE = 0x1023,
195 CL_DEVICE_ERROR_CORRECTION_SUPPORT = 0x1024,
196 CL_DEVICE_PROFILING_TIMER_RESOLUTION = 0x1025,
197 CL_DEVICE_ENDIAN_LITTLE = 0x1026,
198 CL_DEVICE_AVAILABLE = 0x1027,
199 CL_DEVICE_COMPILER_AVAILABLE = 0x1028,
200 CL_DEVICE_EXECUTION_CAPABILITIES = 0x1029,
201 CL_DEVICE_QUEUE_PROPERTIES = 0x102A,
202 CL_DEVICE_NAME = 0x102B,
203 CL_DEVICE_VENDOR = 0x102C,
204 CL_DRIVER_VERSION = 0x102D,
205 CL_DEVICE_PROFILE = 0x102E,
206 CL_DEVICE_VERSION = 0x102F,
207 CL_DEVICE_EXTENSIONS = 0x1030,
208 CL_DEVICE_PLATFORM = 0x1031,
209
210 // cl_device_fp_config - bitfield
211 CL_FP_DENORM = (1 << 0),
212 CL_FP_INF_NAN = (1 << 1),
213 CL_FP_ROUND_TO_NEAREST = (1 << 2),
214 CL_FP_ROUND_TO_ZERO = (1 << 3),
215 CL_FP_ROUND_TO_INF = (1 << 4),
216 CL_FP_FMA = (1 << 5),
217
218 // cl_device_mem_cache_type
219 CL_NONE = 0x0,
220 CL_READ_ONLY_CACHE = 0x1,
221 CL_READ_WRITE_CACHE = 0x2,
222
223 // cl_device_local_mem_type
224 CL_LOCAL = 0x1,
225 CL_GLOBAL = 0x2,
226
227 // cl_device_exec_capabilities - bitfield
228 CL_EXEC_KERNEL = (1 << 0),
229 CL_EXEC_NATIVE_KERNEL = (1 << 1),
230
231 // cl_command_queue_properties - bitfield
232 CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE = (1 << 0),
233 CL_QUEUE_PROFILING_ENABLE = (1 << 1),
234
235 // cl_context_info
236 CL_CONTEXT_REFERENCE_COUNT = 0x1080,
237 CL_CONTEXT_DEVICES = 0x1081,
238 CL_CONTEXT_PROPERTIES = 0x1082,
239
240 // cl_context_properties
241 CL_CONTEXT_PLATFORM = 0x1084,
242
243 // cl_command_queue_info
244 CL_QUEUE_CONTEXT = 0x1090,
245 CL_QUEUE_DEVICE = 0x1091,
246 CL_QUEUE_REFERENCE_COUNT = 0x1092,
247 CL_QUEUE_PROPERTIES = 0x1093,
248
249 // cl_mem_flags - bitfield
250 CL_MEM_READ_WRITE = (1 << 0),
251 CL_MEM_WRITE_ONLY = (1 << 1),
252 CL_MEM_READ_ONLY = (1 << 2),
253 CL_MEM_USE_HOST_PTR = (1 << 3),
254 CL_MEM_ALLOC_HOST_PTR = (1 << 4),
255 CL_MEM_COPY_HOST_PTR = (1 << 5),
256
257 // cl_channel_order
258 CL_R = 0x10B0,
259 CL_A = 0x10B1,
260 CL_RG = 0x10B2,
261 CL_RA = 0x10B3,
262 CL_RGB = 0x10B4,
263 CL_RGBA = 0x10B5,
264 CL_BGRA = 0x10B6,
265 CL_ARGB = 0x10B7,
266 CL_INTENSITY = 0x10B8,
267 CL_LUMINANCE = 0x10B9,
268
269 // cl_channel_type
270 CL_SNORM_INT8 = 0x10D0,
271 CL_SNORM_INT16 = 0x10D1,
272 CL_UNORM_INT8 = 0x10D2,
273 CL_UNORM_INT16 = 0x10D3,
274 CL_UNORM_SHORT_565 = 0x10D4,
275 CL_UNORM_SHORT_555 = 0x10D5,
276 CL_UNORM_INT_101010 = 0x10D6,
277 CL_SIGNED_INT8 = 0x10D7,
278 CL_SIGNED_INT16 = 0x10D8,
279 CL_SIGNED_INT32 = 0x10D9,
280 CL_UNSIGNED_INT8 = 0x10DA,
281 CL_UNSIGNED_INT16 = 0x10DB,
282 CL_UNSIGNED_INT32 = 0x10DC,
283 CL_HALF_FLOAT = 0x10DD,
284 CL_FLOAT = 0x10DE,
285
286 // cl_mem_object_type
287 CL_MEM_OBJECT_BUFFER = 0x10F0,
288 CL_MEM_OBJECT_IMAGE2D = 0x10F1,
289 CL_MEM_OBJECT_IMAGE3D = 0x10F2,
290
291 // cl_mem_info
292 CL_MEM_TYPE = 0x1100,
293 CL_MEM_FLAGS = 0x1101,
294 CL_MEM_SIZE = 0x1102,
295 CL_MEM_HOST_PTR = 0x1103,
296 CL_MEM_MAP_COUNT = 0x1104,
297 CL_MEM_REFERENCE_COUNT = 0x1105,
298 CL_MEM_CONTEXT = 0x1106,
299
300 // cl_image_info
301 CL_IMAGE_FORMAT = 0x1110,
302 CL_IMAGE_ELEMENT_SIZE = 0x1111,
303 CL_IMAGE_ROW_PITCH = 0x1112,
304 CL_IMAGE_SLICE_PITCH = 0x1113,
305 CL_IMAGE_WIDTH = 0x1114,
306 CL_IMAGE_HEIGHT = 0x1115,
307 CL_IMAGE_DEPTH = 0x1116,
308
309 // cl_addressing_mode
310 CL_ADDRESS_NONE = 0x1130,
311 CL_ADDRESS_CLAMP_TO_EDGE = 0x1131,
312 CL_ADDRESS_CLAMP = 0x1132,
313 CL_ADDRESS_REPEAT = 0x1133,
314
315 // cl_filter_mode
316 CL_FILTER_NEAREST = 0x1140,
317 CL_FILTER_LINEAR = 0x1141,
318
319 // cl_sampler_info
320 CL_SAMPLER_REFERENCE_COUNT = 0x1150,
321 CL_SAMPLER_CONTEXT = 0x1151,
322 CL_SAMPLER_NORMALIZED_COORDS = 0x1152,
323 CL_SAMPLER_ADDRESSING_MODE = 0x1153,
324 CL_SAMPLER_FILTER_MODE = 0x1154,
325
326 // cl_map_flags - bitfield
327 CL_MAP_READ = (1 << 0),
328 CL_MAP_WRITE = (1 << 1),
329
330 // cl_program_info
331 CL_PROGRAM_REFERENCE_COUNT = 0x1160,
332 CL_PROGRAM_CONTEXT = 0x1161,
333 CL_PROGRAM_NUM_DEVICES = 0x1162,
334 CL_PROGRAM_DEVICES = 0x1163,
335 CL_PROGRAM_SOURCE = 0x1164,
336 CL_PROGRAM_BINARY_SIZES = 0x1165,
337 CL_PROGRAM_BINARIES = 0x1166,
338
339 // cl_program_build_info
340 CL_PROGRAM_BUILD_STATUS = 0x1181,
341 CL_PROGRAM_BUILD_OPTIONS = 0x1182,
342 CL_PROGRAM_BUILD_LOG = 0x1183,
343
344 // cl_build_status
345 CL_BUILD_SUCCESS = 0,
346 CL_BUILD_NONE = -1,
347 CL_BUILD_ERROR = -2,
348 CL_BUILD_IN_PROGRESS = -3,
349
350 // cl_kernel_info
351 CL_KERNEL_FUNCTION_NAME = 0x1190,
352 CL_KERNEL_NUM_ARGS = 0x1191,
353 CL_KERNEL_REFERENCE_COUNT = 0x1192,
354 CL_KERNEL_CONTEXT = 0x1193,
355 CL_KERNEL_PROGRAM = 0x1194,
356
357 // cl_kernel_work_group_info
358 CL_KERNEL_WORK_GROUP_SIZE = 0x11B0,
359 CL_KERNEL_COMPILE_WORK_GROUP_SIZE = 0x11B1,
360 CL_KERNEL_LOCAL_MEM_SIZE = 0x11B2,
361
362 // cl_event_info
363 CL_EVENT_COMMAND_QUEUE = 0x11D0,
364 CL_EVENT_COMMAND_TYPE = 0x11D1,
365 CL_EVENT_REFERENCE_COUNT = 0x11D2,
366 CL_EVENT_COMMAND_EXECUTION_STATUS = 0x11D3,
367
368 // cl_command_type
369 CL_COMMAND_NDRANGE_KERNEL = 0x11F0,
370 CL_COMMAND_TASK = 0x11F1,
371 CL_COMMAND_NATIVE_KERNEL = 0x11F2,
372 CL_COMMAND_READ_BUFFER = 0x11F3,
373 CL_COMMAND_WRITE_BUFFER = 0x11F4,
374 CL_COMMAND_COPY_BUFFER = 0x11F5,
375 CL_COMMAND_READ_IMAGE = 0x11F6,
376 CL_COMMAND_WRITE_IMAGE = 0x11F7,
377 CL_COMMAND_COPY_IMAGE = 0x11F8,
378 CL_COMMAND_COPY_IMAGE_TO_BUFFER = 0x11F9,
379 CL_COMMAND_COPY_BUFFER_TO_IMAGE = 0x11FA,
380 CL_COMMAND_MAP_BUFFER = 0x11FB,
381 CL_COMMAND_MAP_IMAGE = 0x11FC,
382 CL_COMMAND_UNMAP_MEM_OBJECT = 0x11FD,
383 CL_COMMAND_MARKER = 0x11FE,
384 CL_COMMAND_ACQUIRE_GL_OBJECTS = 0x11FF,
385 CL_COMMAND_RELEASE_GL_OBJECTS = 0x1200,
386
387 // command execution status
388 CL_COMPLETE = 0x0,
389 CL_RUNNING = 0x1,
390 CL_SUBMITTED = 0x2,
391 CL_QUEUED = 0x3,
392
393 // cl_profiling_info
394 CL_PROFILING_COMMAND_QUEUED = 0x1280,
395 CL_PROFILING_COMMAND_SUBMIT = 0x1281,
396 CL_PROFILING_COMMAND_START = 0x1282,
397 CL_PROFILING_COMMAND_END = 0x1283
398 }
399
400 /********************************************************************************************************/
401
402 // Platform API
403 cl_int clGetPlatformIDs(
404 cl_uint num_entries,
405 cl_platform_id* platforms,
406 cl_uint* num_platforms
407 );
408
409 cl_int clGetPlatformInfo(
410 cl_platform_id platform,
411 cl_platform_info param_name,
412 size_t param_value_size,
413 void* param_value,
414 size_t* param_value_size_ret
415 );
416
417 // Device APIs
418 cl_int clGetDeviceIDs(
419 cl_platform_id platform,
420 cl_device_type device_type,
421 cl_uint num_entries,
422 cl_device_id* devices,
423 cl_uint* num_devices
424 );
425
426 cl_int clGetDeviceInfo(
427 cl_device_id device,
428 cl_device_info param_name,
429 size_t param_value_size,
430 void* param_value,
431 size_t* param_value_size_ret
432 );
433
434 // Context APIs
435
436 typedef void function(
437 const(char)*,
438 const(void)*,
439 size_t,
440 const(void)*
441 ) cl_logging_fn;
442
443 cl_context clCreateContext(
444 const(cl_context_properties)* properties,
445 cl_uint num_devices,
446 const(cl_device_id)* devices,
447 cl_logging_fn pfn_notify,
448 void* user_data,
449 cl_int* errcode_ret
450 );
451
452 cl_context clCreateContextFromType(
453 const(cl_context_properties)* properties,
454 cl_device_type device_type,
455 cl_logging_fn pfn_notify,
456 void* user_data,
457 cl_int* errcode_ret
458 );
459
460 cl_int clRetainContext(
461 cl_context context
462 );
463
464 cl_int clReleaseContext(
465 cl_context context
466 );
467
468 cl_int clGetContextInfo(
469 cl_context context,
470 cl_context_info param_name,
471 size_t param_value_size,
472 void* param_value,
473 size_t* param_value_size_ret
474 );
475
476 // Command Queue APIs
477 cl_command_queue clCreateCommandQueue(
478 cl_context context,
479 cl_device_id device,
480 cl_command_queue_properties properties,
481 cl_int* errcode_ret
482 );
483
484 cl_int clRetainCommandQueue(
485 cl_command_queue command_queue
486 );
487
488 cl_int clReleaseCommandQueue(
489 cl_command_queue command_queue
490 );
491
492 cl_int clGetCommandQueueInfo(
493 cl_command_queue command_queue,
494 cl_command_queue_info param_name,
495 size_t param_value_size,
496 void * param_value,
497 size_t * param_value_size_ret
498 );
499
500 cl_int clSetCommandQueueProperty(
501 cl_command_queue command_queue,
502 cl_command_queue_properties properties,
503 cl_bool enable,
504 cl_command_queue_properties* old_properties
505 );
506
507 // Memory Object APIs
508 cl_mem clCreateBuffer(
509 cl_context context,
510 cl_mem_flags flags,
511 size_t size,
512 void * host_ptr,
513 cl_int * errcode_ret
514 );
515
516 cl_mem clCreateImage2D(
517 cl_context context,
518 cl_mem_flags flags,
519 const(cl_image_format)* image_format,
520 size_t image_width,
521 size_t image_height,
522 size_t image_row_pitch,
523 void* host_ptr,
524 cl_int* errcode_ret
525 );
526
527 cl_mem clCreateImage3D(
528 cl_context context,
529 cl_mem_flags flags,
530 const(cl_image_format)* image_format,
531 size_t image_width,
532 size_t image_height,
533 size_t image_depth,
534 size_t image_row_pitch,
535 size_t image_slice_pitch,
536 void* host_ptr,
537 cl_int* errcode_ret
538 );
539
540 cl_int clRetainMemObject(
541 cl_mem memobj
542 );
543
544 cl_int clReleaseMemObject(
545 cl_mem memobj
546 );
547
548 cl_int clGetSupportedImageFormats(
549 cl_context context,
550 cl_mem_flags flags,
551 cl_mem_object_type image_type,
552 cl_uint num_entries,
553 cl_image_format* image_formats,
554 cl_uint* num_image_formats
555 );
556
557 cl_int clGetMemObjectInfo(
558 cl_mem memobj,
559 cl_mem_info param_name,
560 size_t param_value_size,
561 void* param_value,
562 size_t* param_value_size_ret
563 );
564
565 cl_int clGetImageInfo(
566 cl_mem image,
567 cl_image_info param_name,
568 size_t param_value_size,
569 void * param_value,
570 size_t * param_value_size_ret
571 );
572
573 // Sampler APIs
574 cl_sampler clCreateSampler(
575 cl_context context,
576 cl_bool normalized_coords,
577 cl_addressing_mode addressing_mode,
578 cl_filter_mode filter_mode,
579 cl_int* errcode_ret
580 );
581
582 cl_int clRetainSampler(
583 cl_sampler sampler
584 );
585
586 cl_int clReleaseSampler(
587 cl_sampler sampler
588 );
589
590 cl_int clGetSamplerInfo(
591 cl_sampler sampler,
592 cl_sampler_info param_name,
593 size_t param_value_size,
594 void* param_value,
595 size_t* param_value_size_ret
596 );
597
598 // Program Object APIs
599 cl_program clCreateProgramWithSource(
600 cl_context context,
601 cl_uint count,
602 const(char*)* strings,
603 const(size_t)* lengths,
604 cl_int* errcode_ret
605 );
606
607 cl_program clCreateProgramWithBinary(
608 cl_context context,
609 cl_uint num_devices,
610 const(cl_device_id)* device_list,
611 const(size_t)* lengths,
612 const(ubyte*)* binaries,
613 cl_int* binary_status,
614 cl_int* errcode_ret
615 );
616
617 cl_int clRetainProgram(
618 cl_program program
619 );
620
621 cl_int clReleaseProgram(
622 cl_program program
623 );
624
625 cl_int clBuildProgram(
626 cl_program program,
627 cl_uint num_devices,
628 const(cl_device_id)* device_list,
629 const(char)* options,
630 void function(
631 cl_program program,
632 void* user_data
633 ) pfn_notify,
634 void* user_data
635 );
636
637 cl_int clUnloadCompiler();
638
639 cl_int clGetProgramInfo(
640 cl_program program,
641 cl_program_info param_name,
642 size_t param_value_size,
643 void* param_value,
644 size_t* param_value_size_ret
645 );
646
647 cl_int clGetProgramBuildInfo(
648 cl_program program,
649 cl_device_id device,
650 cl_program_build_info param_name,
651 size_t param_value_size,
652 void* param_value,
653 size_t* param_value_size_ret
654 );
655
656 // Kernel Object APIs
657 cl_kernel clCreateKernel(
658 cl_program program,
659 const(char)* kernel_name,
660 cl_int* errcode_ret
661 );
662
663 cl_int clCreateKernelsInProgram(
664 cl_program program,
665 cl_uint num_kernels,
666 cl_kernel* kernels,
667 cl_uint* num_kernels_ret
668 );
669
670 cl_int clRetainKernel(
671 cl_kernel kernel
672 );
673
674 cl_int clReleaseKernel(
675 cl_kernel kernel
676 );
677
678 cl_int clSetKernelArg(
679 cl_kernel kernel,
680 cl_uint arg_indx,
681 size_t arg_size,
682 const(void)* arg_value
683 );
684
685 cl_int clGetKernelInfo(
686 cl_kernel kernel,
687 cl_kernel_info param_name,
688 size_t param_value_size,
689 void* param_value,
690 size_t* param_value_size_ret
691 );
692
693 cl_int clGetKernelWorkGroupInfo(
694 cl_kernel kernel,
695 cl_device_id device,
696 cl_kernel_work_group_info param_name,
697 size_t param_value_size,
698 void* param_value,
699 size_t* param_value_size_ret
700 );
701
702 // Event Object APIs
703 cl_int clWaitForEvents(
704 cl_uint num_events,
705 const(cl_event)* event_list
706 );
707
708 cl_int clGetEventInfo(
709 cl_event event,
710 cl_event_info param_name,
711 size_t param_value_size,
712 void* param_value,
713 size_t* param_value_size_ret
714 );
715
716 cl_int clRetainEvent(
717 cl_event event
718 );
719
720 cl_int clReleaseEvent(
721 cl_event event
722 );
723
724 // Profiling APIs
725 cl_int clGetEventProfilingInfo(
726 cl_event event,
727 cl_profiling_info param_name,
728 size_t param_value_size,
729 void* param_value,
730 size_t* param_value_size_ret
731 );
732
733 // Flush and Finish APIs
734 cl_int clFlush(
735 cl_command_queue command_queue
736 );
737
738 cl_int clFinish(
739 cl_command_queue command_queue
740 );
741
742 // Enqueued Commands APIs
743 cl_int clEnqueueReadBuffer(
744 cl_command_queue command_queue,
745 cl_mem buffer,
746 cl_bool blocking_read,
747 size_t offset,
748 size_t cb,
749 void * ptr,
750 cl_uint num_events_in_wait_list,
751 const(cl_event)* event_wait_list,
752 cl_event* event
753 );
754
755 cl_int clEnqueueWriteBuffer(
756 cl_command_queue command_queue,
757 cl_mem buffer,
758 cl_bool blocking_write,
759 size_t offset,
760 size_t cb,
761 const(void)* ptr,
762 cl_uint num_events_in_wait_list,
763 const(cl_event)* event_wait_list,
764 cl_event* event
765 );
766
767 cl_int clEnqueueCopyBuffer(
768 cl_command_queue command_queue,
769 cl_mem src_buffer,
770 cl_mem dst_buffer,
771 size_t src_offset,
772 size_t dst_offset,
773 size_t cb,
774 cl_uint num_events_in_wait_list,
775 const(cl_event)* event_wait_list,
776 cl_event* event
777 );
778
779 cl_int clEnqueueReadImage(
780 cl_command_queue command_queue,
781 cl_mem image,
782 cl_bool blocking_read,
783 const(size_t)* origin[3],
784 const(size_t)* region[3],
785 size_t row_pitch,
786 size_t slice_pitch,
787 void* ptr,
788 cl_uint num_events_in_wait_list,
789 const(cl_event)* event_wait_list,
790 cl_event* event
791 );
792
793 cl_int clEnqueueWriteImage(
794 cl_command_queue command_queue,
795 cl_mem image,
796 cl_bool blocking_write,
797 const(size_t)* origin[3],
798 const(size_t)* region[3],
799 size_t input_row_pitch,
800 size_t input_slice_pitch,
801 const(void)* ptr,
802 cl_uint num_events_in_wait_list,
803 const(cl_event)* event_wait_list,
804 cl_event* event
805 );
806
807 cl_int clEnqueueCopyImage(
808 cl_command_queue command_queue,
809 cl_mem src_image,
810 cl_mem dst_image,
811 const(size_t)* src_origin[3],
812 const(size_t)* dst_origin[3],
813 const(size_t)* region[3],
814 cl_uint num_events_in_wait_list,
815 const(cl_event)* event_wait_list,
816 cl_event* event
817 );
818
819 cl_int clEnqueueCopyImageToBuffer(
820 cl_command_queue command_queue,
821 cl_mem src_image,
822 cl_mem dst_buffer,
823 const(size_t)* src_origin[3],
824 const(size_t)* region[3],
825 size_t dst_offset,
826 cl_uint num_events_in_wait_list,
827 const(cl_event)* event_wait_list,
828 cl_event* event
829 );
830
831 cl_int clEnqueueCopyBufferToImage(
832 cl_command_queue command_queue,
833 cl_mem src_buffer,
834 cl_mem dst_image,
835 size_t src_offset,
836 const(size_t)* dst_origin[3],
837 const(size_t)* region[3],
838 cl_uint num_events_in_wait_list,
839 const(cl_event)* event_wait_list,
840 cl_event* event
841 );
842
843 void* clEnqueueMapBuffer(
844 cl_command_queue command_queue,
845 cl_mem buffer,
846 cl_bool blocking_map,
847 cl_map_flags map_flags,
848 size_t offset,
849 size_t cb,
850 cl_uint num_events_in_wait_list,
851 const(cl_event)* event_wait_list,
852 cl_event* event,
853 cl_int* errcode_ret
854 );
855
856 void* clEnqueueMapImage(
857 cl_command_queue command_queue,
858 cl_mem image,
859 cl_bool blocking_map,
860 cl_map_flags map_flags,
861 const(size_t)* origin[3],
862 const(size_t)* region[3],
863 size_t* image_row_pitch,
864 size_t* image_slice_pitch,
865 cl_uint num_events_in_wait_list,
866 const(cl_event)* event_wait_list,
867 cl_event* event,
868 cl_int* errcode_ret
869 );
870
871 cl_int clEnqueueUnmapMemObject(
872 cl_command_queue command_queue,
873 cl_mem memobj,
874 void* mapped_ptr,
875 cl_uint num_events_in_wait_list,
876 const(cl_event)* event_wait_list,
877 cl_event* event
878 );
879
880 cl_int clEnqueueNDRangeKernel(
881 cl_command_queue command_queue,
882 cl_kernel kernel,
883 cl_uint work_dim,
884 const(size_t)* global_work_offset,
885 const(size_t)* global_work_size,
886 const(size_t)* local_work_size,
887 cl_uint num_events_in_wait_list,
888 const(cl_event)* event_wait_list,
889 cl_event* event
890 );
891
892 cl_int clEnqueueTask(
893 cl_command_queue command_queue,
894 cl_kernel kernel,
895 cl_uint num_events_in_wait_list,
896 const(cl_event)* event_wait_list,
897 cl_event* event
898 );
899
900 cl_int clEnqueueNativeKernel(
901 cl_command_queue command_queue,
902 void function(
903 void*
904 ) user_func,
905 void* args,
906 size_t cb_args,
907 cl_uint num_mem_objects,
908 const(cl_mem)* mem_list,
909 const(void*)* args_mem_loc,
910 cl_uint num_events_in_wait_list,
911 const(cl_event)* event_wait_list,
912 cl_event* event
913 );
914
915 cl_int clEnqueueMarker(
916 cl_command_queue command_queue,
917 cl_event* event
918 );
919
920 cl_int clEnqueueWaitForEvents(
921 cl_command_queue command_queue,
922 cl_uint num_events,
923 const(cl_event)* event_list
924 );
925
926 cl_int clEnqueueBarrier(
927 cl_command_queue command_queue
928 );
929
930 //Extension function access
931 //
932 // Returns the extension function address for the given function name,
933 // or NULL if a valid function can not be found. The client must
934 // check to make sure the address is not NULL, before using or
935 // calling the returned function address.
936 //
937 void* clGetExtensionFunctionAddress(const(char)* func_name);