ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/OpenCL/OpenCL.xs
(Generate patch)

Comparing OpenCL/OpenCL.xs (file contents):
Revision 1.7 by root, Thu Nov 17 02:10:39 2011 UTC vs.
Revision 1.33 by root, Fri Apr 20 08:57:09 2012 UTC

1#include "EXTERN.h" 1#include "EXTERN.h"
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5#ifdef I_DLFCN
6 #include <dlfcn.h>
7#endif
8
9#ifdef __APPLE__
10 #include <OpenCL/opencl.h>
11#else
5#include <CL/opencl.h> 12 #include <CL/opencl.h>
13#endif
6 14
7typedef cl_platform_id OpenCL__Platform; 15typedef cl_platform_id OpenCL__Platform;
8typedef cl_device_id OpenCL__Device; 16typedef cl_device_id OpenCL__Device;
9typedef cl_context OpenCL__Context; 17typedef cl_context OpenCL__Context;
10typedef cl_command_queue OpenCL__Queue; 18typedef cl_command_queue OpenCL__Queue;
11typedef cl_mem OpenCL__Memory; 19typedef cl_mem OpenCL__Memory;
12typedef cl_mem OpenCL__Buffer; 20typedef cl_mem OpenCL__Buffer;
21typedef cl_mem OpenCL__BufferObj;
13typedef cl_mem OpenCL__Image; 22typedef cl_mem OpenCL__Image;
14typedef cl_mem OpenCL__Image2D; 23typedef cl_mem OpenCL__Image2D;
15typedef cl_mem OpenCL__Image3D; 24typedef cl_mem OpenCL__Image3D;
16typedef cl_mem OpenCL__Memory_ornull; 25typedef cl_mem OpenCL__Memory_ornull;
17typedef cl_mem OpenCL__Buffer_ornull; 26typedef cl_mem OpenCL__Buffer_ornull;
18typedef cl_mem OpenCL__Image_ornull; 27typedef cl_mem OpenCL__Image_ornull;
19typedef cl_mem OpenCL__Image2D_ornull; 28typedef cl_mem OpenCL__Image2D_ornull;
20typedef cl_mem OpenCL__Image3D_ornull; 29typedef cl_mem OpenCL__Image3D_ornull;
21typedef cl_sampler OpenCL__Sampler; 30typedef cl_sampler OpenCL__Sampler;
22typedef cl_program OpenCL__Program; 31typedef cl_program OpenCL__Program;
23typedef cl_kernel OpenCL__Kernel; 32typedef cl_kernel OpenCL__Kernel;
24typedef cl_event OpenCL__Event; 33typedef cl_event OpenCL__Event;
25typedef cl_event OpenCL__UserEvent; 34typedef cl_event OpenCL__UserEvent;
26 35
27typedef SV *FUTURE; 36typedef SV *FUTURE;
37
38/*****************************************************************************/
39
40// name must include a leading underscore
41// all of this horrors would be unneceesary if somebody wrote a proper OpenGL module
42// for perl. doh.
43static void *
44glsym (const char *name)
45{
46 void *fun = 0;
47
48 #if defined I_DLFCN && defined RTLD_DEFAULT
49 fun = dlsym (RTLD_DEFAULT, name + 1);
50 if (!fun) fun = dlsym (RTLD_DEFAULT, name);
51
52 if (!fun)
53 {
54 static void *libgl;
55 static const char *glso[] = {
56 "libGL.so.1",
57 "libGL.so.3",
58 "libGL.so.4.0",
59 "libGL.so",
60 "/usr/lib/libGL.so",
61 "/usr/X11R6/lib/libGL.1.dylib"
62 };
63 int i;
64
65 for (i = 0; !libgl && i < sizeof (glso) / sizeof (glso [0]); ++i)
66 {
67 libgl = dlopen (glso [i], RTLD_LAZY);
68 if (libgl)
69 break;
70 }
71
72 if (libgl)
73 {
74 fun = dlsym (libgl, name + 1);
75 if (!fun) fun = dlsym (libgl, name);
76 }
77 }
78 #endif
79
80 return fun;
81}
28 82
29/*****************************************************************************/ 83/*****************************************************************************/
30 84
31/* up to two temporary buffers */ 85/* up to two temporary buffers */
32static void * 86static void *
33tmpbuf (size_t size) 87tmpbuf (size_t size)
34{ 88{
89 enum { buffers = 3 };
35 static int idx; 90 static int idx;
36 static void *buf [2]; 91 static void *buf [buffers];
37 static size_t len [2]; 92 static size_t len [buffers];
38 93
39 idx ^= 1; 94 idx = ++idx % buffers;
40 95
41 if (len [idx] < size) 96 if (len [idx] < size)
42 { 97 {
43 free (buf [idx]); 98 free (buf [idx]);
44 len [idx] = ((size + 31) & ~4095) + 4096 - 32; 99 len [idx] = ((size + 31) & ~4095) + 4096 - 32;
… …
92 return iv2str (err, errstr, sizeof (errstr) / sizeof (errstr [0]), "ERROR(%d)"); 147 return iv2str (err, errstr, sizeof (errstr) / sizeof (errstr [0]), "ERROR(%d)");
93} 148}
94 149
95/*****************************************************************************/ 150/*****************************************************************************/
96 151
97static cl_int last_error; 152static cl_int res;
98 153
99#define FAIL(name,err) \ 154#define FAIL(name) \
100 croak ("cl" # name ": %s", err2str (last_error = err)); 155 croak ("cl" # name ": %s", err2str (res));
101 156
102#define NEED_SUCCESS(name,args) \ 157#define NEED_SUCCESS(name,args) \
103 do { \ 158 do { \
104 cl_int res = cl ## name args; \ 159 res = cl ## name args; \
105 \ 160 \
106 if (res) \ 161 if (res) \
107 FAIL (name, res); \ 162 FAIL (name); \
108 } while (0) 163 } while (0)
164
165#define NEED_SUCCESS_ARG(retdecl, name, args) \
166 retdecl = cl ## name args; \
167 if (res) \
168 FAIL (name);
109 169
110/*****************************************************************************/ 170/*****************************************************************************/
111 171
112#define NEW_MORTAL_OBJ(class,ptr) sv_setref_pv (sv_newmortal (), class, ptr) 172#define NEW_MORTAL_OBJ(class,ptr) sv_setref_pv (sv_newmortal (), class, ptr)
113#define XPUSH_NEW_OBJ(class,ptr) XPUSHs (NEW_MORTAL_OBJ (class, ptr)) 173#define XPUSH_NEW_OBJ(class,ptr) XPUSHs (NEW_MORTAL_OBJ (class, ptr))
… …
121 croak ("%s: %s is not of type %s", func, svname, pkg); 181 croak ("%s: %s is not of type %s", func, svname, pkg);
122} 182}
123 183
124/*****************************************************************************/ 184/*****************************************************************************/
125 185
186static cl_context_properties *
187SvCONTEXTPROPERTIES (const char *func, const char *svname, SV *sv, cl_context_properties *extra, int extracount)
188{
189 if (!sv || !SvOK (sv))
190 if (extra)
191 sv = sv_2mortal (newRV_noinc ((SV *)newAV ())); // slow, but rarely used hopefully
192 else
193 return 0;
194
195 if (SvROK (sv) && SvTYPE (SvRV (sv)) == SVt_PVAV)
196 {
197 AV *av = (AV *)SvRV (sv);
198 int i, len = av_len (av) + 1;
199 cl_context_properties *p = tmpbuf (sizeof (cl_context_properties) * (len + extracount + 1));
200 cl_context_properties *l = p;
201
202 if (len & 1)
203 croak ("%s: %s is not a property list (must be even number of elements)", func, svname);
204
205 while (extracount--)
206 *l++ = *extra++;
207
208 for (i = 0; i < len; i += 2)
209 {
210 cl_context_properties t = SvIV (*av_fetch (av, i , 0));
211 SV *p_sv = *av_fetch (av, i + 1, 0);
212 cl_context_properties v = SvIV (p_sv); // code below can override
213
214 switch (t)
215 {
216 case CL_GLX_DISPLAY_KHR:
217 if (!SvOK (p_sv))
218 {
219 void *func = glsym ("_glXGetCurrentDisplay");
220 if (func)
221 v = (cl_context_properties)((void *(*)(void))func)();
222 }
223 break;
224
225 case CL_GL_CONTEXT_KHR:
226 if (!SvOK (p_sv))
227 {
228 void *func = glsym ("_glXGetCurrentContext");
229 if (func)
230 v = (cl_context_properties)((void *(*)(void))func)();
231 }
232 break;
233
234 default:
235 /* unknown property, treat as int */
236 break;
237 }
238
239 *l++ = t;
240 *l++ = v;
241 }
242
243 *l = 0;
244
245 return p;
246 }
247
248 croak ("%s: %s is not a property list (either undef or [type => value, ...])", func, svname);
249}
250
251/*****************************************************************************/
252
253static size_t
254img_row_pitch (cl_mem img)
255{
256 size_t res;
257 clGetImageInfo (img, CL_IMAGE_ROW_PITCH, sizeof (res), &res, 0);
258 return res;
259}
260
126static cl_event * 261static cl_event *
127event_list (SV **items, int count) 262event_list (SV **items, int count)
128{ 263{
264 if (!count)
265 return 0;
266
129 cl_event *list = tmpbuf (sizeof (cl_event) * count); 267 cl_event *list = tmpbuf (sizeof (cl_event) * count);
130 268
131 while (count--) 269 while (count--)
132 list [count] = SvPTROBJ ("clEnqueue", "wait_events", items [count], "OpenCL::Event"); 270 list [count] = SvPTROBJ ("clEnqueue", "wait_events", items [count], "OpenCL::Event");
133 271
… …
138 cl_uint event_list_count = (count); \ 276 cl_uint event_list_count = (count); \
139 cl_event *event_list_ptr = event_list (&ST (items), event_list_count) 277 cl_event *event_list_ptr = event_list (&ST (items), event_list_count)
140 278
141#define INFO(class) \ 279#define INFO(class) \
142{ \ 280{ \
143 size_t size; \ 281 size_t size; \
144 SV *sv; \
145 \
146 NEED_SUCCESS (Get ## class ## Info, (this, name, 0, 0, &size)); \ 282 NEED_SUCCESS (Get ## class ## Info, (self, name, 0, 0, &size)); \
147 sv = sv_2mortal (newSV (size)); \ 283 SV *sv = sv_2mortal (newSV (size)); \
148 SvUPGRADE (sv, SVt_PV); \ 284 SvUPGRADE (sv, SVt_PV); \
149 SvPOK_only (sv); \ 285 SvPOK_only (sv); \
150 SvCUR_set (sv, size); \ 286 SvCUR_set (sv, size); \
151 NEED_SUCCESS (Get ## class ## Info, (this, name, size, SvPVX (sv), 0)); \ 287 NEED_SUCCESS (Get ## class ## Info, (self, name, size, SvPVX (sv), 0)); \
152 XPUSHs (sv); \ 288 XPUSHs (sv); \
153} 289}
154 290
155MODULE = OpenCL PACKAGE = OpenCL 291MODULE = OpenCL PACKAGE = OpenCL
156 292
157PROTOTYPES: ENABLE 293PROTOTYPES: ENABLE
158 294
159BOOT: 295BOOT:
160{ 296{
161 HV *stash = gv_stashpv ("OpenCL", 1); 297 HV *stash = gv_stashpv ("OpenCL", 1);
162 static const ivstr *civ, const_iv[] = { 298 static const ivstr *civ, const_iv[] = {
163 { sizeof (cl_char ), "SIZEOF_CHAR" }, 299 { sizeof (cl_char ), "SIZEOF_CHAR" },
164 { sizeof (cl_uchar ), "SIZEOF_UCHAR" }, 300 { sizeof (cl_uchar ), "SIZEOF_UCHAR" },
165 { sizeof (cl_short ), "SIZEOF_SHORT" }, 301 { sizeof (cl_short ), "SIZEOF_SHORT" },
166 { sizeof (cl_ushort), "SIZEOF_USHORT" }, 302 { sizeof (cl_ushort), "SIZEOF_USHORT" },
167 { sizeof (cl_int ), "SIZEOF_INT" }, 303 { sizeof (cl_int ), "SIZEOF_INT" },
168 { sizeof (cl_uint ), "SIZEOF_UINT" }, 304 { sizeof (cl_uint ), "SIZEOF_UINT" },
169 { sizeof (cl_long ), "SIZEOF_LONG" }, 305 { sizeof (cl_long ), "SIZEOF_LONG" },
170 { sizeof (cl_ulong ), "SIZEOF_ULONG" }, 306 { sizeof (cl_ulong ), "SIZEOF_ULONG" },
171 { sizeof (cl_half ), "SIZEOF_HALF" }, 307 { sizeof (cl_half ), "SIZEOF_HALF" },
172 { sizeof (cl_float ), "SIZEOF_FLOAT" }, 308 { sizeof (cl_float ), "SIZEOF_FLOAT" },
173 { sizeof (cl_double), "SIZEOF_DOUBLE" }, 309 { sizeof (cl_double), "SIZEOF_DOUBLE" },
174#include "constiv.h" 310#include "constiv.h"
175 }; 311 };
176 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--) 312 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
177 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv)); 313 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
178} 314}
179 315
180cl_int 316cl_int
181errno () 317errno ()
182 CODE: 318 CODE:
183 errno = last_error; 319 errno = res;
184 320
185const char * 321const char *
186err2str (cl_int err) 322err2str (cl_int err)
187 323
188const char * 324const char *
189enum2str (cl_uint value) 325enum2str (cl_uint value)
190 326
191void 327void
192platforms () 328platforms ()
193 PPCODE: 329 PPCODE:
194{
195 cl_platform_id *list; 330 cl_platform_id *list;
196 cl_uint count; 331 cl_uint count;
197 int i; 332 int i;
198 333
199 NEED_SUCCESS (GetPlatformIDs, (0, 0, &count)); 334 NEED_SUCCESS (GetPlatformIDs, (0, 0, &count));
… …
201 NEED_SUCCESS (GetPlatformIDs, (count, list, 0)); 336 NEED_SUCCESS (GetPlatformIDs, (count, list, 0));
202 337
203 EXTEND (SP, count); 338 EXTEND (SP, count);
204 for (i = 0; i < count; ++i) 339 for (i = 0; i < count; ++i)
205 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Platform", list [i])); 340 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Platform", list [i]));
206}
207 341
208void 342void
209context_from_type (FUTURE properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, FUTURE notify = 0) 343context_from_type (cl_context_properties *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, FUTURE notify = 0)
210 PPCODE: 344 PPCODE:
211{ 345 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (properties, type, 0, 0, &res));
212 cl_int res;
213 cl_context ctx = clCreateContextFromType (0, type, 0, 0, &res);
214
215 if (res)
216 FAIL (CreateContextFromType, res);
217
218 XPUSH_NEW_OBJ ("OpenCL::Context", ctx); 346 XPUSH_NEW_OBJ ("OpenCL::Context", ctx);
219} 347
348void
349context (cl_context_properties *properties = 0, FUTURE devices, FUTURE notify = 0)
350 PPCODE:
351 /* der Gipfel der Kunst */
220 352
221void 353void
222wait_for_events (...) 354wait_for_events (...)
223 CODE: 355 CODE:
224{
225 EVENT_LIST (0, items); 356 EVENT_LIST (0, items);
226 NEED_SUCCESS (WaitForEvents, (event_list_count, event_list_ptr)); 357 NEED_SUCCESS (WaitForEvents, (event_list_count, event_list_ptr));
227}
228 358
229PROTOTYPES: DISABLE 359PROTOTYPES: DISABLE
230 360
231MODULE = OpenCL PACKAGE = OpenCL::Platform 361MODULE = OpenCL PACKAGE = OpenCL::Platform
232 362
233void 363void
234info (OpenCL::Platform this, cl_platform_info name) 364info (OpenCL::Platform self, cl_platform_info name)
235 PPCODE: 365 PPCODE:
236 INFO (Platform) 366 INFO (Platform)
237 367
368#BEGIN:platform
369
238void 370void
371profile (OpenCL::Platform self)
372 ALIAS:
373 profile = CL_PLATFORM_PROFILE
374 version = CL_PLATFORM_VERSION
375 name = CL_PLATFORM_NAME
376 vendor = CL_PLATFORM_VENDOR
377 extensions = CL_PLATFORM_EXTENSIONS
378 PPCODE:
379 size_t size;
380 NEED_SUCCESS (GetPlatformInfo, (self, ix, 0, 0, &size));
381 char *value = tmpbuf (size);
382 NEED_SUCCESS (GetPlatformInfo, (self, ix, size, value, 0));
383 EXTEND (SP, 1);
384 const int i = 0;
385 PUSHs (sv_2mortal (newSVpv (value, 0)));
386
387#END:platform
388
389void
239devices (OpenCL::Platform this, cl_device_type type = CL_DEVICE_TYPE_ALL) 390devices (OpenCL::Platform self, cl_device_type type = CL_DEVICE_TYPE_ALL)
240 PPCODE: 391 PPCODE:
241{
242 cl_device_id *list; 392 cl_device_id *list;
243 cl_uint count; 393 cl_uint count;
244 int i; 394 int i;
245 395
246 NEED_SUCCESS (GetDeviceIDs, (this, type, 0, 0, &count)); 396 NEED_SUCCESS (GetDeviceIDs, (self, type, 0, 0, &count));
247 list = tmpbuf (sizeof (*list) * count); 397 list = tmpbuf (sizeof (*list) * count);
248 NEED_SUCCESS (GetDeviceIDs, (this, type, count, list, 0)); 398 NEED_SUCCESS (GetDeviceIDs, (self, type, count, list, 0));
249 399
250 EXTEND (SP, count); 400 EXTEND (SP, count);
251 for (i = 0; i < count; ++i) 401 for (i = 0; i < count; ++i)
252 PUSHs (sv_setref_pv (sv_newmortal (), "OpenCL::Device", list [i])); 402 PUSHs (sv_setref_pv (sv_newmortal (), "OpenCL::Device", list [i]));
253}
254 403
255void 404void
256context_from_type (OpenCL::Platform this, FUTURE properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, FUTURE notify = 0) 405context (OpenCL::Platform self, cl_context_properties *properties = 0, SV *devices, FUTURE notify = 0)
257 PPCODE: 406 PPCODE:
258{ 407 if (!SvROK (devices) || SvTYPE (SvRV (devices)) != SVt_PVAV)
259 cl_int res; 408 croak ("OpenCL::Platform::context argument 'device' must be an arrayref with device objects, in call");
260 cl_context_properties props[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)this, 0 };
261 cl_context ctx = clCreateContextFromType (props, type, 0, 0, &res);
262 409
263 if (res) 410 AV *av = (AV *)SvRV (devices);
264 FAIL (CreateContextFromType, res); 411 cl_uint num_devices = av_len (av) + 1;
412 cl_device_id *device_list = tmpbuf (sizeof (cl_device_id) * num_devices);
413 int i;
265 414
415 for (i = num_devices; i--; )
416 device_list [i] = SvPTROBJ ("clCreateContext", "devices", *av_fetch (av, i, 0), "OpenCL::Device");
417
418 NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (properties, num_devices, device_list, 0, 0, &res));
266 XPUSH_NEW_OBJ ("OpenCL::Context", ctx); 419 XPUSH_NEW_OBJ ("OpenCL::Context", ctx);
267} 420
421void
422context_from_type (OpenCL::Platform self, SV *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, FUTURE notify = 0)
423 PPCODE:
424 cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self };
425 cl_context_properties *props = SvCONTEXTPROPERTIES ("OpenCL::Platform::context_from_type", "properties", properties, extra, 2);
426 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (props, type, 0, 0, &res));
427 XPUSH_NEW_OBJ ("OpenCL::Context", ctx);
268 428
269MODULE = OpenCL PACKAGE = OpenCL::Device 429MODULE = OpenCL PACKAGE = OpenCL::Device
270 430
271void 431void
272info (OpenCL::Device this, cl_device_info name) 432info (OpenCL::Device self, cl_device_info name)
273 PPCODE: 433 PPCODE:
274 INFO (Device) 434 INFO (Device)
275 435
436#BEGIN:device
437
276void 438void
277context (OpenCL::Device this, FUTURE properties = 0, FUTURE notify = 0) 439type (OpenCL::Device self)
278 PPCODE: 440 PPCODE:
279{ 441 cl_device_type value [1];
280 cl_int res; 442 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_TYPE, sizeof (value), value, 0));
281 cl_context ctx = clCreateContext (0, 1, &this, 0, 0, &res); 443 EXTEND (SP, 1);
444 const int i = 0;
445 PUSHs (sv_2mortal (newSViv (value [i])));
282 446
283 if (res) 447void
284 FAIL (CreateContext, res); 448vendor_id (OpenCL::Device self)
449 ALIAS:
450 vendor_id = CL_DEVICE_VENDOR_ID
451 max_compute_units = CL_DEVICE_MAX_COMPUTE_UNITS
452 max_work_item_dimensions = CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS
453 preferred_vector_width_char = CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR
454 preferred_vector_width_short = CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT
455 preferred_vector_width_int = CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT
456 preferred_vector_width_long = CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG
457 preferred_vector_width_float = CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT
458 preferred_vector_width_double = CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE
459 max_clock_frequency = CL_DEVICE_MAX_CLOCK_FREQUENCY
460 max_read_image_args = CL_DEVICE_MAX_READ_IMAGE_ARGS
461 max_write_image_args = CL_DEVICE_MAX_WRITE_IMAGE_ARGS
462 image_support = CL_DEVICE_IMAGE_SUPPORT
463 max_samplers = CL_DEVICE_MAX_SAMPLERS
464 mem_base_addr_align = CL_DEVICE_MEM_BASE_ADDR_ALIGN
465 min_data_type_align_size = CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE
466 global_mem_cacheline_size = CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE
467 max_constant_args = CL_DEVICE_MAX_CONSTANT_ARGS
468 preferred_vector_width_half = CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF
469 native_vector_width_char = CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR
470 native_vector_width_short = CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT
471 native_vector_width_int = CL_DEVICE_NATIVE_VECTOR_WIDTH_INT
472 native_vector_width_long = CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG
473 native_vector_width_float = CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT
474 native_vector_width_double = CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE
475 native_vector_width_half = CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF
476 reference_count_ext = CL_DEVICE_REFERENCE_COUNT_EXT
477 PPCODE:
478 cl_uint value [1];
479 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
480 EXTEND (SP, 1);
481 const int i = 0;
482 PUSHs (sv_2mortal (newSVuv (value [i])));
285 483
286 XPUSH_NEW_OBJ ("OpenCL::Context", ctx); 484void
287} 485max_work_group_size (OpenCL::Device self)
486 ALIAS:
487 max_work_group_size = CL_DEVICE_MAX_WORK_GROUP_SIZE
488 image2d_max_width = CL_DEVICE_IMAGE2D_MAX_WIDTH
489 image2d_max_height = CL_DEVICE_IMAGE2D_MAX_HEIGHT
490 image3d_max_width = CL_DEVICE_IMAGE3D_MAX_WIDTH
491 image3d_max_height = CL_DEVICE_IMAGE3D_MAX_HEIGHT
492 image3d_max_depth = CL_DEVICE_IMAGE3D_MAX_DEPTH
493 max_parameter_size = CL_DEVICE_MAX_PARAMETER_SIZE
494 profiling_timer_resolution = CL_DEVICE_PROFILING_TIMER_RESOLUTION
495 PPCODE:
496 size_t value [1];
497 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
498 EXTEND (SP, 1);
499 const int i = 0;
500 PUSHs (sv_2mortal (newSVuv (value [i])));
501
502void
503max_work_item_sizes (OpenCL::Device self)
504 PPCODE:
505 size_t size;
506 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_MAX_WORK_ITEM_SIZES, 0, 0, &size));
507 size_t *value = tmpbuf (size);
508 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_MAX_WORK_ITEM_SIZES, size, value, 0));
509 int i, n = size / sizeof (*value);
510 EXTEND (SP, n);
511 for (i = 0; i < n; ++i)
512 PUSHs (sv_2mortal (newSVuv (value [i])));
513
514void
515address_bits (OpenCL::Device self)
516 PPCODE:
517 cl_bitfield value [1];
518 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_ADDRESS_BITS, sizeof (value), value, 0));
519 EXTEND (SP, 1);
520 const int i = 0;
521 PUSHs (sv_2mortal (newSVuv (value [i])));
522
523void
524max_mem_alloc_size (OpenCL::Device self)
525 ALIAS:
526 max_mem_alloc_size = CL_DEVICE_MAX_MEM_ALLOC_SIZE
527 global_mem_cache_size = CL_DEVICE_GLOBAL_MEM_CACHE_SIZE
528 global_mem_size = CL_DEVICE_GLOBAL_MEM_SIZE
529 max_constant_buffer_size = CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE
530 local_mem_size = CL_DEVICE_LOCAL_MEM_SIZE
531 PPCODE:
532 cl_ulong value [1];
533 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
534 EXTEND (SP, 1);
535 const int i = 0;
536 PUSHs (sv_2mortal (newSVuv (value [i])));
537
538void
539single_fp_config (OpenCL::Device self)
540 ALIAS:
541 single_fp_config = CL_DEVICE_SINGLE_FP_CONFIG
542 double_fp_config = CL_DEVICE_DOUBLE_FP_CONFIG
543 half_fp_config = CL_DEVICE_HALF_FP_CONFIG
544 PPCODE:
545 cl_device_fp_config value [1];
546 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
547 EXTEND (SP, 1);
548 const int i = 0;
549 PUSHs (sv_2mortal (newSVuv (value [i])));
550
551void
552global_mem_cache_type (OpenCL::Device self)
553 PPCODE:
554 cl_device_mem_cache_type value [1];
555 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof (value), value, 0));
556 EXTEND (SP, 1);
557 const int i = 0;
558 PUSHs (sv_2mortal (newSVuv (value [i])));
559
560void
561local_mem_type (OpenCL::Device self)
562 PPCODE:
563 cl_device_local_mem_type value [1];
564 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_LOCAL_MEM_TYPE, sizeof (value), value, 0));
565 EXTEND (SP, 1);
566 const int i = 0;
567 PUSHs (sv_2mortal (newSVuv (value [i])));
568
569void
570error_correction_support (OpenCL::Device self)
571 ALIAS:
572 error_correction_support = CL_DEVICE_ERROR_CORRECTION_SUPPORT
573 endian_little = CL_DEVICE_ENDIAN_LITTLE
574 available = CL_DEVICE_AVAILABLE
575 compiler_available = CL_DEVICE_COMPILER_AVAILABLE
576 host_unified_memory = CL_DEVICE_HOST_UNIFIED_MEMORY
577 PPCODE:
578 cl_bool value [1];
579 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
580 EXTEND (SP, 1);
581 const int i = 0;
582 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
583
584void
585execution_capabilities (OpenCL::Device self)
586 PPCODE:
587 cl_device_exec_capabilities value [1];
588 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (value), value, 0));
589 EXTEND (SP, 1);
590 const int i = 0;
591 PUSHs (sv_2mortal (newSVuv (value [i])));
592
593void
594properties (OpenCL::Device self)
595 PPCODE:
596 cl_command_queue_properties value [1];
597 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_QUEUE_PROPERTIES, sizeof (value), value, 0));
598 EXTEND (SP, 1);
599 const int i = 0;
600 PUSHs (sv_2mortal (newSViv (value [i])));
601
602void
603platform (OpenCL::Device self)
604 PPCODE:
605 cl_platform_id value [1];
606 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PLATFORM, sizeof (value), value, 0));
607 EXTEND (SP, 1);
608 const int i = 0;
609 {
610 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Platform", value [i]));
611 }
612
613void
614name (OpenCL::Device self)
615 ALIAS:
616 name = CL_DEVICE_NAME
617 vendor = CL_DEVICE_VENDOR
618 driver_version = CL_DRIVER_VERSION
619 profile = CL_DEVICE_PROFILE
620 version = CL_DEVICE_VERSION
621 extensions = CL_DEVICE_EXTENSIONS
622 PPCODE:
623 size_t size;
624 NEED_SUCCESS (GetDeviceInfo, (self, ix, 0, 0, &size));
625 char *value = tmpbuf (size);
626 NEED_SUCCESS (GetDeviceInfo, (self, ix, size, value, 0));
627 EXTEND (SP, 1);
628 const int i = 0;
629 PUSHs (sv_2mortal (newSVpv (value, 0)));
630
631void
632parent_device_ext (OpenCL::Device self)
633 PPCODE:
634 cl_device_id value [1];
635 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PARENT_DEVICE_EXT, sizeof (value), value, 0));
636 EXTEND (SP, 1);
637 const int i = 0;
638 {
639 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Device", value [i]));
640 }
641
642void
643partition_types_ext (OpenCL::Device self)
644 ALIAS:
645 partition_types_ext = CL_DEVICE_PARTITION_TYPES_EXT
646 affinity_domains_ext = CL_DEVICE_AFFINITY_DOMAINS_EXT
647 partition_style_ext = CL_DEVICE_PARTITION_STYLE_EXT
648 PPCODE:
649 size_t size;
650 NEED_SUCCESS (GetDeviceInfo, (self, ix, 0, 0, &size));
651 cl_device_partition_property_ext *value = tmpbuf (size);
652 NEED_SUCCESS (GetDeviceInfo, (self, ix, size, value, 0));
653 int i, n = size / sizeof (*value);
654 EXTEND (SP, n);
655 for (i = 0; i < n; ++i)
656 PUSHs (sv_2mortal (newSVuv (value [i])));
657
658#END:device
288 659
289MODULE = OpenCL PACKAGE = OpenCL::Context 660MODULE = OpenCL PACKAGE = OpenCL::Context
290 661
291void 662void
292DESTROY (OpenCL::Context context) 663DESTROY (OpenCL::Context context)
293 CODE: 664 CODE:
294 clReleaseContext (context); 665 clReleaseContext (context);
295 666
296void 667void
297info (OpenCL::Context this, cl_context_info name) 668info (OpenCL::Context self, cl_context_info name)
298 PPCODE: 669 PPCODE:
299 INFO (Context) 670 INFO (Context)
300 671
301void 672void
302queue (OpenCL::Context this, OpenCL::Device device, cl_command_queue_properties properties = 0) 673queue (OpenCL::Context self, OpenCL::Device device, cl_command_queue_properties properties = 0)
303 PPCODE: 674 PPCODE:
304{
305 cl_int res;
306 cl_command_queue queue = clCreateCommandQueue (this, device, properties, &res); 675 NEED_SUCCESS_ARG (cl_command_queue queue, CreateCommandQueue, (self, device, properties, &res));
307
308 if (res)
309 FAIL (CreateCommandQueue, res);
310
311 XPUSH_NEW_OBJ ("OpenCL::Queue", queue); 676 XPUSH_NEW_OBJ ("OpenCL::Queue", queue);
312}
313 677
314void 678void
315user_event (OpenCL::Context this) 679user_event (OpenCL::Context self)
316 PPCODE: 680 PPCODE:
317{ 681 NEED_SUCCESS_ARG (cl_event ev, CreateUserEvent, (self, &res));
318 cl_int res;
319 cl_event ev = clCreateUserEvent (this, &res);
320
321 if (res)
322 FAIL (CreateUserevent, res);
323
324 XPUSH_NEW_OBJ ("OpenCL::UserEvent", ev); 682 XPUSH_NEW_OBJ ("OpenCL::UserEvent", ev);
325}
326 683
327void 684void
328buffer (OpenCL::Context this, cl_mem_flags flags, size_t len) 685buffer (OpenCL::Context self, cl_mem_flags flags, size_t len)
329 PPCODE: 686 PPCODE:
330{
331 cl_int res;
332 cl_mem mem;
333
334 if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)) 687 if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))
335 croak ("clCreateBuffer: cannot use/copy host ptr when no data is given, use $context->buffer_sv instead?"); 688 croak ("OpenCL::Context::buffer: cannot use/copy host ptr when no data is given, use $context->buffer_sv instead?");
336 689
337 mem = clCreateBuffer (this, flags, len, 0, &res); 690 NEED_SUCCESS_ARG (cl_mem mem, CreateBuffer, (self, flags, len, 0, &res));
338
339 if (res)
340 FAIL (CreateBuffer, res);
341
342 XPUSH_NEW_OBJ ("OpenCL::Buffer", mem); 691 XPUSH_NEW_OBJ ("OpenCL::BufferObj", mem);
343}
344 692
345void 693void
346buffer_sv (OpenCL::Context this, cl_mem_flags flags, SV *data) 694buffer_sv (OpenCL::Context self, cl_mem_flags flags, SV *data)
347 PPCODE: 695 PPCODE:
348{
349 STRLEN len; 696 STRLEN len;
350 char *ptr = SvPVbyte (data, len); 697 char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
351 cl_int res;
352 cl_mem mem;
353
354 if (!(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))) 698 if (!(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
355 croak ("clCreateBuffer: have to specify use or copy host ptr when buffer data is given, use $context->buffer instead?"); 699 croak ("OpenCL::Context::buffer_sv: you have to specify use or copy host ptr when buffer data is given, use $context->buffer instead?");
356 700 NEED_SUCCESS_ARG (cl_mem mem, CreateBuffer, (self, flags, len, ptr, &res));
357 mem = clCreateBuffer (this, flags, len, ptr, &res);
358
359 if (res)
360 FAIL (CreateBuffer, res);
361
362 XPUSH_NEW_OBJ ("OpenCL::Buffer", mem); 701 XPUSH_NEW_OBJ ("OpenCL::BufferObj", mem);
363}
364 702
365void 703void
366image2d (OpenCL::Context this, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, SV *data) 704image2d (OpenCL::Context self, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, size_t row_pitch = 0, SV *data = &PL_sv_undef)
367 PPCODE: 705 PPCODE:
368{
369 STRLEN len; 706 STRLEN len;
370 char *ptr = SvPVbyte (data, len); 707 char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
371 const cl_image_format format = { channel_order, channel_type }; 708 const cl_image_format format = { channel_order, channel_type };
372 cl_int res; 709 NEED_SUCCESS_ARG (cl_mem mem, CreateImage2D, (self, flags, &format, width, height, row_pitch, ptr, &res));
373 cl_mem mem = clCreateImage2D (this, flags, &format, width, height, len / height, ptr, &res);
374
375 if (res)
376 FAIL (CreateImage2D, res);
377
378 XPUSH_NEW_OBJ ("OpenCL::Image2D", mem); 710 XPUSH_NEW_OBJ ("OpenCL::Image2D", mem);
379}
380 711
381void 712void
382image3d (OpenCL::Context this, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, size_t depth, size_t slice_pitch, SV *data) 713image3d (OpenCL::Context self, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, size_t depth, size_t row_pitch = 0, size_t slice_pitch = 0, SV *data = &PL_sv_undef)
383 PPCODE: 714 PPCODE:
384{
385 STRLEN len; 715 STRLEN len;
386 char *ptr = SvPVbyte (data, len); 716 char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
387 const cl_image_format format = { channel_order, channel_type }; 717 const cl_image_format format = { channel_order, channel_type };
388 cl_int res; 718 NEED_SUCCESS_ARG (cl_mem mem, CreateImage3D, (self, flags, &format, width, height, depth, row_pitch, slice_pitch, ptr, &res));
389 cl_mem mem = clCreateImage3D (this, flags, &format, width, height,
390 depth, len / (height * slice_pitch), slice_pitch, ptr, &res);
391
392 if (res)
393 FAIL (CreateImage3D, res);
394
395 XPUSH_NEW_OBJ ("OpenCL::Image3D", mem); 719 XPUSH_NEW_OBJ ("OpenCL::Image3D", mem);
396}
397 720
721#if cl_apple_gl_sharing || cl_khr_gl_sharing
722
398void 723void
724gl_buffer (OpenCL::Context self, cl_mem_flags flags, cl_GLuint bufobj)
725 PPCODE:
726 NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLBuffer, (self, flags, bufobj, &res));
727 XPUSH_NEW_OBJ ("OpenCL::BufferObj", mem);
728
729void
730gl_texture2d (OpenCL::Context self, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture)
731 PPCODE:
732 NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture2D, (self, flags, target, miplevel, texture, &res));
733 XPUSH_NEW_OBJ ("OpenCL::Image2D", mem);
734
735void
736gl_texture3d (OpenCL::Context self, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture)
737 PPCODE:
738 NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture3D, (self, flags, target, miplevel, texture, &res));
739 XPUSH_NEW_OBJ ("OpenCL::Image3D", mem);
740
741void
742gl_renderbuffer (OpenCL::Context self, cl_mem_flags flags, cl_GLuint renderbuffer)
743 PPCODE:
744 NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLRenderbuffer, (self, flags, renderbuffer, &res));
745 XPUSH_NEW_OBJ ("OpenCL::Image2D", mem);
746
747#endif
748
749void
399supported_image_formats (OpenCL::Context this, cl_mem_flags flags, cl_mem_object_type image_type) 750supported_image_formats (OpenCL::Context self, cl_mem_flags flags, cl_mem_object_type image_type)
400 PPCODE: 751 PPCODE:
401{ 752{
402 cl_uint count; 753 cl_uint count;
403 cl_image_format *list; 754 cl_image_format *list;
404 int i; 755 int i;
405 756
406 NEED_SUCCESS (GetSupportedImageFormats, (this, flags, image_type, 0, 0, &count)); 757 NEED_SUCCESS (GetSupportedImageFormats, (self, flags, image_type, 0, 0, &count));
407 Newx (list, count, cl_image_format); 758 Newx (list, count, cl_image_format);
408 NEED_SUCCESS (GetSupportedImageFormats, (this, flags, image_type, count, list, 0)); 759 NEED_SUCCESS (GetSupportedImageFormats, (self, flags, image_type, count, list, 0));
409 760
410 EXTEND (SP, count); 761 EXTEND (SP, count);
411 for (i = 0; i < count; ++i) 762 for (i = 0; i < count; ++i)
412 { 763 {
413 AV *av = newAV (); 764 AV *av = newAV ();
… …
416 PUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 767 PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
417 } 768 }
418} 769}
419 770
420void 771void
421sampler (OpenCL::Context this, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode) 772sampler (OpenCL::Context self, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode)
422 PPCODE: 773 PPCODE:
423{
424 cl_int res;
425 cl_sampler sampler = clCreateSampler (this, normalized_coords, addressing_mode, filter_mode, &res); 774 NEED_SUCCESS_ARG (cl_sampler sampler, CreateSampler, (self, normalized_coords, addressing_mode, filter_mode, &res));
426
427 if (res)
428 FAIL (CreateSampler, res);
429
430 XPUSH_NEW_OBJ ("OpenCL::Sampler", sampler); 775 XPUSH_NEW_OBJ ("OpenCL::Sampler", sampler);
431}
432 776
433void 777void
434program_with_source (OpenCL::Context this, SV *program) 778program_with_source (OpenCL::Context self, SV *program)
435 PPCODE: 779 PPCODE:
436{
437 STRLEN len; 780 STRLEN len;
438 size_t len2; 781 size_t len2;
439 const char *ptr = SvPVbyte (program, len); 782 const char *ptr = SvPVbyte (program, len);
440 cl_int res;
441 cl_program prog;
442 783
443 len2 = len; 784 len2 = len;
444 prog = clCreateProgramWithSource (this, 1, &ptr, &len2, &res); 785 NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithSource, (self, 1, &ptr, &len2, &res));
445
446 if (res)
447 FAIL (CreateProgramWithSource, res);
448
449 XPUSH_NEW_OBJ ("OpenCL::Program", prog); 786 XPUSH_NEW_OBJ ("OpenCL::Program", prog);
450} 787
788#BEGIN:context
789
790void
791reference_count (OpenCL::Context self)
792 ALIAS:
793 reference_count = CL_CONTEXT_REFERENCE_COUNT
794 num_devices = CL_CONTEXT_NUM_DEVICES
795 PPCODE:
796 cl_uint value [1];
797 NEED_SUCCESS (GetContextInfo, (self, ix, sizeof (value), value, 0));
798 EXTEND (SP, 1);
799 const int i = 0;
800 PUSHs (sv_2mortal (newSVuv (value [i])));
801
802void
803devices (OpenCL::Context self)
804 PPCODE:
805 size_t size;
806 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, 0, 0, &size));
807 cl_device_id *value = tmpbuf (size);
808 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, size, value, 0));
809 int i, n = size / sizeof (*value);
810 EXTEND (SP, n);
811 for (i = 0; i < n; ++i)
812 {
813 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Device", value [i]));
814 }
815
816void
817properties (OpenCL::Context self)
818 PPCODE:
819 size_t size;
820 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_PROPERTIES, 0, 0, &size));
821 cl_context_properties *value = tmpbuf (size);
822 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_PROPERTIES, size, value, 0));
823 int i, n = size / sizeof (*value);
824 EXTEND (SP, n);
825 for (i = 0; i < n; ++i)
826 PUSHs (sv_2mortal (newSVuv ((UV)value [i])));
827
828#END:context
451 829
452MODULE = OpenCL PACKAGE = OpenCL::Queue 830MODULE = OpenCL PACKAGE = OpenCL::Queue
453 831
454void 832void
455DESTROY (OpenCL::Queue this) 833DESTROY (OpenCL::Queue self)
456 CODE: 834 CODE:
457 clReleaseCommandQueue (this); 835 clReleaseCommandQueue (self);
458 836
459void 837void
460info (OpenCL::Queue this, cl_command_queue_info name)
461 PPCODE:
462 INFO (CommandQueue)
463
464void
465enqueue_read_buffer (OpenCL::Queue this, OpenCL::Buffer mem, cl_bool blocking, size_t offset, size_t len, SV *data, ...) 838enqueue_read_buffer (OpenCL::Queue self, OpenCL::Buffer mem, cl_bool blocking, size_t offset, size_t len, SV *data, ...)
466 PPCODE: 839 PPCODE:
467{
468 cl_event ev = 0; 840 cl_event ev = 0;
469 EVENT_LIST (6, items - 6); 841 EVENT_LIST (6, items - 6);
470 842
471 SvUPGRADE (data, SVt_PV); 843 SvUPGRADE (data, SVt_PV);
472 SvGROW (data, len); 844 SvGROW (data, len);
473 SvPOK_only (data); 845 SvPOK_only (data);
474 SvCUR_set (data, len); 846 SvCUR_set (data, len);
475 NEED_SUCCESS (EnqueueReadBuffer, (this, mem, blocking, offset, len, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 847 NEED_SUCCESS (EnqueueReadBuffer, (self, mem, blocking, offset, len, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
476 848
477 if (ev) 849 if (ev)
478 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 850 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
479}
480 851
481void 852void
482enqueue_write_buffer (OpenCL::Queue this, OpenCL::Buffer mem, cl_bool blocking, size_t offset, SV *data, ...) 853enqueue_write_buffer (OpenCL::Queue self, OpenCL::Buffer mem, cl_bool blocking, size_t offset, SV *data, ...)
483 PPCODE: 854 PPCODE:
484{
485 cl_event ev = 0; 855 cl_event ev = 0;
486 STRLEN len; 856 STRLEN len;
487 char *ptr = SvPVbyte (data, len); 857 char *ptr = SvPVbyte (data, len);
488 EVENT_LIST (5, items - 5); 858 EVENT_LIST (5, items - 5);
489 859
490 NEED_SUCCESS (EnqueueReadBuffer, (this, mem, blocking, offset, len, ptr, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 860 NEED_SUCCESS (EnqueueReadBuffer, (self, mem, blocking, offset, len, ptr, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
491 861
492 if (ev) 862 if (ev)
493 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 863 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
494}
495 864
496void 865void
497enqueue_copy_buffer (OpenCL::Queue this, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_offset, size_t dst_offset, size_t len, ...) 866enqueue_copy_buffer (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_offset, size_t dst_offset, size_t len, ...)
498 PPCODE: 867 PPCODE:
499{
500 cl_event ev = 0; 868 cl_event ev = 0;
501 EVENT_LIST (6, items - 6); 869 EVENT_LIST (6, items - 6);
502 870
503 NEED_SUCCESS (EnqueueCopyBuffer, (this, src, dst, src_offset, dst_offset, len, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 871 NEED_SUCCESS (EnqueueCopyBuffer, (self, src, dst, src_offset, dst_offset, len, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
504 872
505 if (ev) 873 if (ev)
506 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 874 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
507}
508 875
509 /*TODO http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueReadBufferRect.html */
510 /*TODO http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueWriteBufferRect.html */
511
512void 876void
513enqueue_read_image (OpenCL::Queue this, OpenCL::Image src, cl_bool blocking, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t row_pitch, size_t slice_pitch, SV *data, ...) 877enqueue_read_buffer_rect (OpenCL::Queue self, OpenCL::Memory buf, cl_bool blocking, size_t buf_x, size_t buf_y, size_t buf_z, size_t host_x, size_t host_y, size_t host_z, size_t width, size_t height, size_t depth, size_t buf_row_pitch, size_t buf_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, SV *data, ...)
514 PPCODE: 878 PPCODE:
515{
516 cl_event ev = 0; 879 cl_event ev = 0;
880 const size_t buf_origin [3] = { buf_x , buf_y , buf_z };
517 const size_t src_origin[3] = { src_x, src_y, src_z }; 881 const size_t host_origin[3] = { host_x, host_y, host_z };
518 const size_t region[3] = { width, height, depth }; 882 const size_t region[3] = { width, height, depth };
519 size_t len = row_pitch * slice_pitch * depth;
520 EVENT_LIST (11, items - 11); 883 EVENT_LIST (17, items - 17);
884
885 if (!buf_row_pitch)
886 buf_row_pitch = region [0];
887
888 if (!buf_slice_pitch)
889 buf_slice_pitch = region [1] * buf_row_pitch;
890
891 if (!host_row_pitch)
892 host_row_pitch = region [0];
893
894 if (!host_slice_pitch)
895 host_slice_pitch = region [1] * host_row_pitch;
896
897 size_t len = host_row_pitch * host_slice_pitch * region [2];
521 898
522 SvUPGRADE (data, SVt_PV); 899 SvUPGRADE (data, SVt_PV);
523 SvGROW (data, len); 900 SvGROW (data, len);
524 SvPOK_only (data); 901 SvPOK_only (data);
525 SvCUR_set (data, len); 902 SvCUR_set (data, len);
526 NEED_SUCCESS (EnqueueReadImage, (this, src, blocking, src_origin, region, row_pitch, slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 903 NEED_SUCCESS (EnqueueReadBufferRect, (self, buf, blocking, buf_origin, host_origin, region, buf_row_pitch, buf_slice_pitch, host_row_pitch, host_slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
527 904
528 if (ev) 905 if (ev)
529 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 906 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
530}
531 907
532void 908void
909enqueue_write_buffer_rect (OpenCL::Queue self, OpenCL::Memory buf, cl_bool blocking, size_t buf_x, size_t buf_y, size_t buf_z, size_t host_x, size_t host_y, size_t host_z, size_t width, size_t height, size_t depth, size_t buf_row_pitch, size_t buf_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, SV *data, ...)
910 PPCODE:
911 cl_event ev = 0;
912 const size_t buf_origin [3] = { buf_x , buf_y , buf_z };
913 const size_t host_origin[3] = { host_x, host_y, host_z };
914 const size_t region[3] = { width, height, depth };
915 STRLEN len;
916 char *ptr = SvPVbyte (data, len);
917 EVENT_LIST (17, items - 17);
918
919 if (!buf_row_pitch)
920 buf_row_pitch = region [0];
921
922 if (!buf_slice_pitch)
923 buf_slice_pitch = region [1] * buf_row_pitch;
924
925 if (!host_row_pitch)
926 host_row_pitch = region [0];
927
928 if (!host_slice_pitch)
929 host_slice_pitch = region [1] * host_row_pitch;
930
931 size_t min_len = host_row_pitch * host_slice_pitch * region [2];
932
933 if (len < min_len)
934 croak ("clEnqueueWriteImage: data string is shorter than what would be transferred");
935
936 NEED_SUCCESS (EnqueueWriteBufferRect, (self, buf, blocking, buf_origin, host_origin, region, buf_row_pitch, buf_slice_pitch, host_row_pitch, host_slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
937
938 if (ev)
939 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
940
941void
942enqueue_copy_buffer_rect (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t src_row_pitch, size_t src_slice_pitch, size_t dst_row_pitch, size_t dst_slice_pitch, ...)
943 PPCODE:
944 cl_event ev = 0;
945 const size_t src_origin[3] = { src_x, src_y, src_z };
946 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
947 const size_t region[3] = { width, height, depth };
948 EVENT_LIST (16, items - 16);
949
950 NEED_SUCCESS (EnqueueCopyBufferRect, (self, src, dst, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
951
952 if (ev)
953 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
954
955void
956enqueue_read_image (OpenCL::Queue self, OpenCL::Image src, cl_bool blocking, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t row_pitch, size_t slice_pitch, SV *data, ...)
957 PPCODE:
958 cl_event ev = 0;
959 const size_t src_origin[3] = { src_x, src_y, src_z };
960 const size_t region[3] = { width, height, depth };
961 EVENT_LIST (12, items - 12);
962
963 if (!row_pitch)
964 row_pitch = img_row_pitch (src);
965
966 if (depth > 1 && !slice_pitch)
967 slice_pitch = row_pitch * height;
968
969 size_t len = slice_pitch ? slice_pitch * depth : row_pitch * height;
970
971 SvUPGRADE (data, SVt_PV);
972 SvGROW (data, len);
973 SvPOK_only (data);
974 SvCUR_set (data, len);
975 NEED_SUCCESS (EnqueueReadImage, (self, src, blocking, src_origin, region, row_pitch, slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
976
977 if (ev)
978 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
979
980void
533enqueue_write_image (OpenCL::Queue this, OpenCL::Image dst, cl_bool blocking, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t row_pitch, SV *data, ...) 981enqueue_write_image (OpenCL::Queue self, OpenCL::Image dst, cl_bool blocking, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t row_pitch, size_t slice_pitch, SV *data, ...)
534 PPCODE: 982 PPCODE:
535{
536 cl_event ev = 0; 983 cl_event ev = 0;
537 const size_t dst_origin[3] = { dst_x, dst_y, dst_z }; 984 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
538 const size_t region[3] = { width, height, depth }; 985 const size_t region[3] = { width, height, depth };
539 STRLEN len; 986 STRLEN len;
540 char *ptr = SvPVbyte (data, len); 987 char *ptr = SvPVbyte (data, len);
541 size_t slice_pitch = len / (row_pitch * height);
542 EVENT_LIST (11, items - 11); 988 EVENT_LIST (12, items - 12);
543 989
990 if (!row_pitch)
991 row_pitch = img_row_pitch (dst);
992
993 if (depth > 1 && !slice_pitch)
994 slice_pitch = row_pitch * height;
995
996 size_t min_len = slice_pitch ? slice_pitch * depth : row_pitch * height;
997
998 if (len < min_len)
999 croak ("clEnqueueWriteImage: data string is shorter than what would be transferred");
1000
544 NEED_SUCCESS (EnqueueWriteImage, (this, dst, blocking, dst_origin, region, row_pitch, slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 1001 NEED_SUCCESS (EnqueueWriteImage, (self, dst, blocking, dst_origin, region, row_pitch, slice_pitch, SvPVX (data), event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
545 1002
546 if (ev) 1003 if (ev)
547 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1004 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
548}
549 1005
550void 1006void
551enqueue_copy_buffer_rect (OpenCL::Queue this, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t src_row_pitch, size_t src_slice_pitch, size_t dst_row_pitch, size_t dst_slice_pitch, ...)
552 PPCODE:
553{
554 cl_event ev = 0;
555 const size_t src_origin[3] = { src_x, src_y, src_z };
556 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
557 const size_t region[3] = { width, height, depth };
558 EVENT_LIST (16, items - 16);
559
560 NEED_SUCCESS (EnqueueCopyBufferRect, (this, src, dst, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
561
562 if (ev)
563 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
564}
565
566void
567enqueue_copy_buffer_to_image (OpenCL::Queue this, OpenCL::Buffer src, OpenCL::Image dst, size_t src_offset, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...)
568 PPCODE:
569{
570 cl_event ev = 0;
571 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
572 const size_t region[3] = { width, height, depth };
573 EVENT_LIST (10, items - 10);
574
575 NEED_SUCCESS (EnqueueCopyBufferToImage, (this, src, dst, src_offset, dst_origin, region, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
576
577 if (ev)
578 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
579}
580
581void
582enqueue_copy_image (OpenCL::Queue this, OpenCL::Image src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...) 1007enqueue_copy_image (OpenCL::Queue self, OpenCL::Image src, OpenCL::Image dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...)
583 PPCODE: 1008 PPCODE:
584{
585 cl_event ev = 0; 1009 cl_event ev = 0;
586 const size_t src_origin[3] = { src_x, src_y, src_z }; 1010 const size_t src_origin[3] = { src_x, src_y, src_z };
587 const size_t dst_origin[3] = { dst_x, dst_y, dst_z }; 1011 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
588 const size_t region[3] = { width, height, depth }; 1012 const size_t region[3] = { width, height, depth };
589 EVENT_LIST (12, items - 12); 1013 EVENT_LIST (12, items - 12);
590 1014
591 NEED_SUCCESS (EnqueueCopyImage, (this, src, dst, src_origin, dst_origin, region, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 1015 NEED_SUCCESS (EnqueueCopyImage, (self, src, dst, src_origin, dst_origin, region, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
592 1016
593 if (ev) 1017 if (ev)
594 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1018 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
595}
596 1019
597void 1020void
598enqueue_copy_image_to_buffer (OpenCL::Queue this, OpenCL::Image src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t dst_offset, ...) 1021enqueue_copy_image_to_buffer (OpenCL::Queue self, OpenCL::Image src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t dst_offset, ...)
599 PPCODE: 1022 PPCODE:
600{
601 cl_event ev = 0; 1023 cl_event ev = 0;
602 const size_t src_origin[3] = { src_x, src_y, src_z }; 1024 const size_t src_origin[3] = { src_x, src_y, src_z };
603 const size_t region[3] = { width, height, depth }; 1025 const size_t region[3] = { width, height, depth };
604 EVENT_LIST (10, items - 10); 1026 EVENT_LIST (10, items - 10);
605 1027
606 NEED_SUCCESS (EnqueueCopyImageToBuffer, (this, src, dst, src_origin, region, dst_offset, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 1028 NEED_SUCCESS (EnqueueCopyImageToBuffer, (self, src, dst, src_origin, region, dst_offset, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
607 1029
608 if (ev) 1030 if (ev)
609 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1031 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
610}
611 1032
612void 1033void
1034enqueue_copy_buffer_to_image (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Image dst, size_t src_offset, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...)
1035 PPCODE:
1036 cl_event ev = 0;
1037 const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
1038 const size_t region[3] = { width, height, depth };
1039 EVENT_LIST (10, items - 10);
1040
1041 NEED_SUCCESS (EnqueueCopyBufferToImage, (self, src, dst, src_offset, dst_origin, region, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
1042
1043 if (ev)
1044 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
1045
1046void
613enqueue_task (OpenCL::Queue this, OpenCL::Kernel kernel, ...) 1047enqueue_task (OpenCL::Queue self, OpenCL::Kernel kernel, ...)
614 PPCODE: 1048 PPCODE:
615{
616 cl_event ev = 0; 1049 cl_event ev = 0;
617 EVENT_LIST (2, items - 2); 1050 EVENT_LIST (2, items - 2);
618 1051
619 NEED_SUCCESS (EnqueueTask, (this, kernel, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 1052 NEED_SUCCESS (EnqueueTask, (self, kernel, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
620 1053
621 if (ev) 1054 if (ev)
622 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1055 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
623}
624 1056
625void 1057void
626enqueue_nd_range_kernel (OpenCL::Queue this, OpenCL::Kernel kernel, SV *global_work_offset, SV *global_work_size, SV *local_work_size = &PL_sv_undef, ...) 1058enqueue_nd_range_kernel (OpenCL::Queue self, OpenCL::Kernel kernel, SV *global_work_offset, SV *global_work_size, SV *local_work_size = &PL_sv_undef, ...)
627 PPCODE: 1059 PPCODE:
628{
629 cl_event ev = 0; 1060 cl_event ev = 0;
630 size_t *gwo = 0, *gws, *lws = 0; 1061 size_t *gwo = 0, *gws, *lws = 0;
631 int gws_len; 1062 int gws_len;
632 size_t *lists; 1063 size_t *lists;
633 int i; 1064 int i;
… …
668 lws = lists + gws_len * 2; 1099 lws = lists + gws_len * 2;
669 for (i = 0; i < gws_len; ++i) 1100 for (i = 0; i < gws_len; ++i)
670 lws [i] = SvIV (AvARRAY (SvRV (local_work_size))[i]); 1101 lws [i] = SvIV (AvARRAY (SvRV (local_work_size))[i]);
671 } 1102 }
672 1103
673 NEED_SUCCESS (EnqueueNDRangeKernel, (this, kernel, gws_len, gwo, gws, lws, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0)); 1104 NEED_SUCCESS (EnqueueNDRangeKernel, (self, kernel, gws_len, gwo, gws, lws, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
674 1105
675 if (ev) 1106 if (ev)
676 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1107 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
677}
678 1108
1109#if cl_apple_gl_sharing || cl_khr_gl_sharing
1110
679void 1111void
1112enqueue_acquire_gl_objects (OpenCL::Queue self, SV *objects, ...)
1113 ALIAS:
1114 enqueue_release_gl_objects = 1
1115 CODE:
1116 if (!SvROK (objects) || SvTYPE (SvRV (objects)) != SVt_PVAV)
1117 croak ("OpenCL::Queue::enqueue_acquire/release_gl_objects argument 'objects' must be an arrayref with memory objects, in call");
1118
1119 cl_event ev = 0;
1120 EVENT_LIST (2, items - 2);
1121 AV *av = (AV *)SvRV (objects);
1122 cl_uint num_objects = av_len (av) + 1;
1123 cl_mem *object_list = tmpbuf (sizeof (cl_mem) * num_objects);
1124 int i;
1125
1126 for (i = num_objects; i--; )
1127 object_list [i] = SvPTROBJ ("OpenCL::Queue::enqueue_acquire/release_gl_objects", "objects", *av_fetch (av, i, 0), "OpenCL::Memory");
1128
1129 if (ix)
1130 NEED_SUCCESS (EnqueueReleaseGLObjects, (self, num_objects, object_list, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
1131 else
1132 NEED_SUCCESS (EnqueueAcquireGLObjects, (self, num_objects, object_list, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
1133
1134 if (ev)
1135 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
1136
1137#endif
1138
1139void
680enqueue_marker (OpenCL::Queue this) 1140enqueue_marker (OpenCL::Queue self)
681 PPCODE: 1141 PPCODE:
682{
683 cl_event ev; 1142 cl_event ev;
684 NEED_SUCCESS (EnqueueMarker, (this, &ev)); 1143 NEED_SUCCESS (EnqueueMarker, (self, &ev));
685 XPUSH_NEW_OBJ ("OpenCL::Event", ev); 1144 XPUSH_NEW_OBJ ("OpenCL::Event", ev);
686}
687 1145
688void 1146void
689enqueue_wait_for_events (OpenCL::Queue this, ...) 1147enqueue_wait_for_events (OpenCL::Queue self, ...)
690 CODE: 1148 CODE:
691{
692 EVENT_LIST (1, items - 1); 1149 EVENT_LIST (1, items - 1);
693 NEED_SUCCESS (EnqueueWaitForEvents, (this, event_list_count, event_list_ptr)); 1150 NEED_SUCCESS (EnqueueWaitForEvents, (self, event_list_count, event_list_ptr));
694}
695 1151
696void 1152void
697enqueue_barrier (OpenCL::Queue this) 1153enqueue_barrier (OpenCL::Queue self)
698 CODE: 1154 CODE:
699 NEED_SUCCESS (EnqueueBarrier, (this)); 1155 NEED_SUCCESS (EnqueueBarrier, (self));
700 1156
701void 1157void
702flush (OpenCL::Queue this) 1158flush (OpenCL::Queue self)
703 CODE: 1159 CODE:
704 NEED_SUCCESS (Flush, (this)); 1160 NEED_SUCCESS (Flush, (self));
705 1161
706void 1162void
707finish (OpenCL::Queue this) 1163finish (OpenCL::Queue self)
708 CODE: 1164 CODE:
709 NEED_SUCCESS (Finish, (this)); 1165 NEED_SUCCESS (Finish, (self));
1166
1167void
1168info (OpenCL::Queue self, cl_command_queue_info name)
1169 PPCODE:
1170 INFO (CommandQueue)
1171
1172#BEGIN:command_queue
1173
1174void
1175context (OpenCL::Queue self)
1176 PPCODE:
1177 cl_context value [1];
1178 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_CONTEXT, sizeof (value), value, 0));
1179 EXTEND (SP, 1);
1180 const int i = 0;
1181 {
1182 NEED_SUCCESS (RetainContext, (value [i]));
1183 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1184 }
1185
1186void
1187device (OpenCL::Queue self)
1188 PPCODE:
1189 cl_device_id value [1];
1190 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_DEVICE, sizeof (value), value, 0));
1191 EXTEND (SP, 1);
1192 const int i = 0;
1193 {
1194 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Device", value [i]));
1195 }
1196
1197void
1198reference_count (OpenCL::Queue self)
1199 PPCODE:
1200 cl_uint value [1];
1201 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_REFERENCE_COUNT, sizeof (value), value, 0));
1202 EXTEND (SP, 1);
1203 const int i = 0;
1204 PUSHs (sv_2mortal (newSVuv (value [i])));
1205
1206void
1207properties (OpenCL::Queue self)
1208 PPCODE:
1209 cl_command_queue_properties value [1];
1210 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_PROPERTIES, sizeof (value), value, 0));
1211 EXTEND (SP, 1);
1212 const int i = 0;
1213 PUSHs (sv_2mortal (newSViv (value [i])));
1214
1215#END:command_queue
710 1216
711MODULE = OpenCL PACKAGE = OpenCL::Memory 1217MODULE = OpenCL PACKAGE = OpenCL::Memory
712 1218
713void 1219void
714DESTROY (OpenCL::Memory this) 1220DESTROY (OpenCL::Memory self)
715 CODE: 1221 CODE:
716 clReleaseMemObject (this); 1222 clReleaseMemObject (self);
717 1223
718void 1224void
719info (OpenCL::Memory this, cl_mem_info name) 1225info (OpenCL::Memory self, cl_mem_info name)
720 PPCODE: 1226 PPCODE:
721 INFO (MemObject) 1227 INFO (MemObject)
722 1228
1229#BEGIN:mem
1230
1231void
1232type (OpenCL::Memory self)
1233 PPCODE:
1234 cl_mem_object_type value [1];
1235 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_TYPE, sizeof (value), value, 0));
1236 EXTEND (SP, 1);
1237 const int i = 0;
1238 PUSHs (sv_2mortal (newSViv (value [i])));
1239
1240void
1241flags (OpenCL::Memory self)
1242 PPCODE:
1243 cl_mem_flags value [1];
1244 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_FLAGS, sizeof (value), value, 0));
1245 EXTEND (SP, 1);
1246 const int i = 0;
1247 PUSHs (sv_2mortal (newSViv (value [i])));
1248
1249void
1250size (OpenCL::Memory self)
1251 ALIAS:
1252 size = CL_MEM_SIZE
1253 offset = CL_MEM_OFFSET
1254 PPCODE:
1255 size_t value [1];
1256 NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
1257 EXTEND (SP, 1);
1258 const int i = 0;
1259 PUSHs (sv_2mortal (newSVuv (value [i])));
1260
1261void
1262host_ptr (OpenCL::Memory self)
1263 PPCODE:
1264 void * value [1];
1265 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_HOST_PTR, sizeof (value), value, 0));
1266 EXTEND (SP, 1);
1267 const int i = 0;
1268 PUSHs (sv_2mortal (newSVuv ((IV)(intptr_t)value [i])));
1269
1270void
1271map_count (OpenCL::Memory self)
1272 ALIAS:
1273 map_count = CL_MEM_MAP_COUNT
1274 reference_count = CL_MEM_REFERENCE_COUNT
1275 PPCODE:
1276 cl_uint value [1];
1277 NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
1278 EXTEND (SP, 1);
1279 const int i = 0;
1280 PUSHs (sv_2mortal (newSVuv (value [i])));
1281
1282void
1283context (OpenCL::Memory self)
1284 PPCODE:
1285 cl_context value [1];
1286 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_CONTEXT, sizeof (value), value, 0));
1287 EXTEND (SP, 1);
1288 const int i = 0;
1289 {
1290 NEED_SUCCESS (RetainContext, (value [i]));
1291 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1292 }
1293
1294void
1295associated_memobject (OpenCL::Memory self)
1296 PPCODE:
1297 cl_mem value [1];
1298 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_ASSOCIATED_MEMOBJECT, sizeof (value), value, 0));
1299 EXTEND (SP, 1);
1300 const int i = 0;
1301 {
1302 NEED_SUCCESS (RetainMemObject, (value [i]));
1303 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Memory", value [i]));
1304 }
1305
1306#END:mem
1307
1308#if cl_apple_gl_sharing || cl_khr_gl_sharing
1309
1310void
1311gl_object_info (OpenCL::Memory self)
1312 PPCODE:
1313 cl_gl_object_type type;
1314 cl_GLuint name;
1315 NEED_SUCCESS (GetGLObjectInfo, (self, &type, &name));
1316 EXTEND (SP, 2);
1317 PUSHs (sv_2mortal (newSVuv (type)));
1318 PUSHs (sv_2mortal (newSVuv (name)));
1319
1320#endif
1321
1322MODULE = OpenCL PACKAGE = OpenCL::BufferObj
1323
1324void
1325sub_buffer_region (OpenCL::BufferObj self, cl_mem_flags flags, size_t origin, size_t size)
1326 PPCODE:
1327 if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR))
1328 croak ("clCreateSubBuffer: cannot use/copy/alloc host ptr, doesn't make sense, check your flags!");
1329
1330 cl_buffer_region crdata = { origin, size };
1331
1332 NEED_SUCCESS_ARG (cl_mem mem, CreateSubBuffer, (self, flags, CL_BUFFER_CREATE_TYPE_REGION, &crdata, &res));
1333 XPUSH_NEW_OBJ ("OpenCL::Buffer", mem);
1334
1335MODULE = OpenCL PACKAGE = OpenCL::Image
1336
1337void
1338image_info (OpenCL::Image self, cl_image_info name)
1339 PPCODE:
1340 INFO (Image)
1341
1342#BEGIN:image
1343
1344void
1345element_size (OpenCL::Image self)
1346 ALIAS:
1347 element_size = CL_IMAGE_ELEMENT_SIZE
1348 row_pitch = CL_IMAGE_ROW_PITCH
1349 slice_pitch = CL_IMAGE_SLICE_PITCH
1350 width = CL_IMAGE_WIDTH
1351 height = CL_IMAGE_HEIGHT
1352 depth = CL_IMAGE_DEPTH
1353 PPCODE:
1354 size_t value [1];
1355 NEED_SUCCESS (GetImageInfo, (self, ix, sizeof (value), value, 0));
1356 EXTEND (SP, 1);
1357 const int i = 0;
1358 PUSHs (sv_2mortal (newSVuv (value [i])));
1359
1360#END:image
1361
1362#if cl_apple_gl_sharing || cl_khr_gl_sharing
1363
1364#BEGIN:gl_texture
1365
1366void
1367target (OpenCL::Image self)
1368 PPCODE:
1369 cl_GLenum value [1];
1370 NEED_SUCCESS (GetGLTextureInfo, (self, CL_GL_TEXTURE_TARGET, sizeof (value), value, 0));
1371 EXTEND (SP, 1);
1372 const int i = 0;
1373 PUSHs (sv_2mortal (newSVuv (value [i])));
1374
1375void
1376gl_mipmap_level (OpenCL::Image self)
1377 PPCODE:
1378 cl_GLint value [1];
1379 NEED_SUCCESS (GetGLTextureInfo, (self, CL_GL_MIPMAP_LEVEL, sizeof (value), value, 0));
1380 EXTEND (SP, 1);
1381 const int i = 0;
1382 PUSHs (sv_2mortal (newSViv (value [i])));
1383
1384#END:gl_texture
1385
1386#endif
1387
723MODULE = OpenCL PACKAGE = OpenCL::Sampler 1388MODULE = OpenCL PACKAGE = OpenCL::Sampler
724 1389
725void 1390void
726DESTROY (OpenCL::Sampler this) 1391DESTROY (OpenCL::Sampler self)
727 CODE: 1392 CODE:
728 clReleaseSampler (this); 1393 clReleaseSampler (self);
729 1394
730void 1395void
731info (OpenCL::Sampler this, cl_sampler_info name) 1396info (OpenCL::Sampler self, cl_sampler_info name)
732 PPCODE: 1397 PPCODE:
733 INFO (Sampler) 1398 INFO (Sampler)
734 1399
1400#BEGIN:sampler
1401
1402void
1403reference_count (OpenCL::Sampler self)
1404 PPCODE:
1405 cl_uint value [1];
1406 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_REFERENCE_COUNT, sizeof (value), value, 0));
1407 EXTEND (SP, 1);
1408 const int i = 0;
1409 PUSHs (sv_2mortal (newSVuv (value [i])));
1410
1411void
1412context (OpenCL::Sampler self)
1413 PPCODE:
1414 cl_context value [1];
1415 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_CONTEXT, sizeof (value), value, 0));
1416 EXTEND (SP, 1);
1417 const int i = 0;
1418 {
1419 NEED_SUCCESS (RetainContext, (value [i]));
1420 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1421 }
1422
1423void
1424normalized_coords (OpenCL::Sampler self)
1425 PPCODE:
1426 cl_addressing_mode value [1];
1427 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_NORMALIZED_COORDS, sizeof (value), value, 0));
1428 EXTEND (SP, 1);
1429 const int i = 0;
1430 PUSHs (sv_2mortal (newSViv (value [i])));
1431
1432void
1433addressing_mode (OpenCL::Sampler self)
1434 PPCODE:
1435 cl_filter_mode value [1];
1436 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_ADDRESSING_MODE, sizeof (value), value, 0));
1437 EXTEND (SP, 1);
1438 const int i = 0;
1439 PUSHs (sv_2mortal (newSViv (value [i])));
1440
1441void
1442filter_mode (OpenCL::Sampler self)
1443 PPCODE:
1444 cl_bool value [1];
1445 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_FILTER_MODE, sizeof (value), value, 0));
1446 EXTEND (SP, 1);
1447 const int i = 0;
1448 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
1449
1450#END:sampler
1451
735MODULE = OpenCL PACKAGE = OpenCL::Program 1452MODULE = OpenCL PACKAGE = OpenCL::Program
736 1453
737void 1454void
738DESTROY (OpenCL::Program this) 1455DESTROY (OpenCL::Program self)
739 CODE: 1456 CODE:
740 clReleaseProgram (this); 1457 clReleaseProgram (self);
741 1458
742void 1459void
743info (OpenCL::Program this, cl_program_info name)
744 PPCODE:
745 INFO (Program)
746
747void
748build (OpenCL::Program this, OpenCL::Device device, SV *options = &PL_sv_undef) 1460build (OpenCL::Program self, OpenCL::Device device, SV *options = &PL_sv_undef)
749 CODE: 1461 CODE:
750 NEED_SUCCESS (BuildProgram, (this, 1, &device, SvPVbyte_nolen (options), 0, 0)); 1462 NEED_SUCCESS (BuildProgram, (self, 1, &device, SvPVbyte_nolen (options), 0, 0));
751 1463
752void 1464void
753build_info (OpenCL::Program this, OpenCL::Device device, cl_program_build_info name) 1465build_info (OpenCL::Program self, OpenCL::Device device, cl_program_build_info name)
754 PPCODE: 1466 PPCODE:
755{
756 size_t size; 1467 size_t size;
757 SV *sv;
758
759 NEED_SUCCESS (GetProgramBuildInfo, (this, device, name, 0, 0, &size)); 1468 NEED_SUCCESS (GetProgramBuildInfo, (self, device, name, 0, 0, &size));
760 sv = sv_2mortal (newSV (size)); 1469 SV *sv = sv_2mortal (newSV (size));
761 SvUPGRADE (sv, SVt_PV); 1470 SvUPGRADE (sv, SVt_PV);
762 SvPOK_only (sv); 1471 SvPOK_only (sv);
763 SvCUR_set (sv, size); 1472 SvCUR_set (sv, size);
764 NEED_SUCCESS (GetProgramBuildInfo, (this, device, name, size, SvPVX (sv), 0)); 1473 NEED_SUCCESS (GetProgramBuildInfo, (self, device, name, size, SvPVX (sv), 0));
765 XPUSHs (sv); 1474 XPUSHs (sv);
766} 1475
1476#BEGIN:program_build
1477
1478void
1479build_status (OpenCL::Program self, OpenCL::Device device)
1480 PPCODE:
1481 cl_build_status value [1];
1482 NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BUILD_STATUS, sizeof (value), value, 0));
1483 EXTEND (SP, 1);
1484 const int i = 0;
1485 PUSHs (sv_2mortal (newSViv (value [i])));
1486
1487void
1488build_options (OpenCL::Program self, OpenCL::Device device)
1489 ALIAS:
1490 build_options = CL_PROGRAM_BUILD_OPTIONS
1491 build_log = CL_PROGRAM_BUILD_LOG
1492 PPCODE:
1493 size_t size;
1494 NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, 0, 0, &size));
1495 char *value = tmpbuf (size);
1496 NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, size, value, 0));
1497 EXTEND (SP, 1);
1498 const int i = 0;
1499 PUSHs (sv_2mortal (newSVpv (value, 0)));
1500
1501#END:program_build
767 1502
768void 1503void
769kernel (OpenCL::Program program, SV *function) 1504kernel (OpenCL::Program program, SV *function)
770 PPCODE: 1505 PPCODE:
771{
772 cl_int res;
773 cl_kernel kernel = clCreateKernel (program, SvPVbyte_nolen (function), &res); 1506 NEED_SUCCESS_ARG (cl_kernel kernel, CreateKernel, (program, SvPVbyte_nolen (function), &res));
774
775 if (res)
776 FAIL (CreateKernel, res);
777
778 XPUSH_NEW_OBJ ("OpenCL::Kernel", kernel); 1507 XPUSH_NEW_OBJ ("OpenCL::Kernel", kernel);
779} 1508
1509void
1510info (OpenCL::Program self, cl_program_info name)
1511 PPCODE:
1512 INFO (Program)
1513
1514void
1515binaries (OpenCL::Program self)
1516 PPCODE:
1517 cl_uint n, i;
1518 size_t size;
1519
1520 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_NUM_DEVICES , sizeof (n) , &n , 0));
1521 if (!n) XSRETURN_EMPTY;
1522
1523 size_t *sizes = tmpbuf (sizeof (*sizes) * n);
1524 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARY_SIZES, sizeof (*sizes) * n, sizes, &size));
1525 if (size != sizeof (*sizes) * n) XSRETURN_EMPTY;
1526 unsigned char **ptrs = tmpbuf (sizeof (*ptrs) * n);
1527
1528 EXTEND (SP, n);
1529 for (i = 0; i < n; ++i)
1530 {
1531 SV *sv = sv_2mortal (newSV (sizes [i]));
1532 SvUPGRADE (sv, SVt_PV);
1533 SvPOK_only (sv);
1534 SvCUR_set (sv, sizes [i]);
1535 ptrs [i] = SvPVX (sv);
1536 PUSHs (sv);
1537 }
1538
1539 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARIES , sizeof (*ptrs ) * n, ptrs , &size));
1540 if (size != sizeof (*ptrs) * n) XSRETURN_EMPTY;
1541
1542#BEGIN:program
1543
1544void
1545reference_count (OpenCL::Program self)
1546 ALIAS:
1547 reference_count = CL_PROGRAM_REFERENCE_COUNT
1548 num_devices = CL_PROGRAM_NUM_DEVICES
1549 PPCODE:
1550 cl_uint value [1];
1551 NEED_SUCCESS (GetProgramInfo, (self, ix, sizeof (value), value, 0));
1552 EXTEND (SP, 1);
1553 const int i = 0;
1554 PUSHs (sv_2mortal (newSVuv (value [i])));
1555
1556void
1557context (OpenCL::Program self)
1558 PPCODE:
1559 cl_context value [1];
1560 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_CONTEXT, sizeof (value), value, 0));
1561 EXTEND (SP, 1);
1562 const int i = 0;
1563 {
1564 NEED_SUCCESS (RetainContext, (value [i]));
1565 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1566 }
1567
1568void
1569devices (OpenCL::Program self)
1570 PPCODE:
1571 size_t size;
1572 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, 0, 0, &size));
1573 cl_device_id *value = tmpbuf (size);
1574 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, size, value, 0));
1575 int i, n = size / sizeof (*value);
1576 EXTEND (SP, n);
1577 for (i = 0; i < n; ++i)
1578 {
1579 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Device", value [i]));
1580 }
1581
1582void
1583source (OpenCL::Program self)
1584 PPCODE:
1585 size_t size;
1586 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_SOURCE, 0, 0, &size));
1587 char *value = tmpbuf (size);
1588 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_SOURCE, size, value, 0));
1589 EXTEND (SP, 1);
1590 const int i = 0;
1591 PUSHs (sv_2mortal (newSVpv (value, 0)));
1592
1593void
1594binary_sizes (OpenCL::Program self)
1595 PPCODE:
1596 size_t size;
1597 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARY_SIZES, 0, 0, &size));
1598 size_t *value = tmpbuf (size);
1599 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARY_SIZES, size, value, 0));
1600 int i, n = size / sizeof (*value);
1601 EXTEND (SP, n);
1602 for (i = 0; i < n; ++i)
1603 PUSHs (sv_2mortal (newSVuv (value [i])));
1604
1605#END:program
780 1606
781MODULE = OpenCL PACKAGE = OpenCL::Kernel 1607MODULE = OpenCL PACKAGE = OpenCL::Kernel
782 1608
783void 1609void
784DESTROY (OpenCL::Kernel this) 1610DESTROY (OpenCL::Kernel self)
785 CODE: 1611 CODE:
786 clReleaseKernel (this); 1612 clReleaseKernel (self);
787 1613
788void 1614void
1615set_char (OpenCL::Kernel self, cl_uint idx, cl_char value)
1616 CODE:
1617 clSetKernelArg (self, idx, sizeof (value), &value);
1618
1619void
1620set_uchar (OpenCL::Kernel self, cl_uint idx, cl_uchar value)
1621 CODE:
1622 clSetKernelArg (self, idx, sizeof (value), &value);
1623
1624void
1625set_short (OpenCL::Kernel self, cl_uint idx, cl_short value)
1626 CODE:
1627 clSetKernelArg (self, idx, sizeof (value), &value);
1628
1629void
1630set_ushort (OpenCL::Kernel self, cl_uint idx, cl_ushort value)
1631 CODE:
1632 clSetKernelArg (self, idx, sizeof (value), &value);
1633
1634void
1635set_int (OpenCL::Kernel self, cl_uint idx, cl_int value)
1636 CODE:
1637 clSetKernelArg (self, idx, sizeof (value), &value);
1638
1639void
1640set_uint (OpenCL::Kernel self, cl_uint idx, cl_uint value)
1641 CODE:
1642 clSetKernelArg (self, idx, sizeof (value), &value);
1643
1644void
1645set_long (OpenCL::Kernel self, cl_uint idx, cl_long value)
1646 CODE:
1647 clSetKernelArg (self, idx, sizeof (value), &value);
1648
1649void
1650set_ulong (OpenCL::Kernel self, cl_uint idx, cl_ulong value)
1651 CODE:
1652 clSetKernelArg (self, idx, sizeof (value), &value);
1653
1654void
1655set_half (OpenCL::Kernel self, cl_uint idx, cl_half value)
1656 CODE:
1657 clSetKernelArg (self, idx, sizeof (value), &value);
1658
1659void
1660set_float (OpenCL::Kernel self, cl_uint idx, cl_float value)
1661 CODE:
1662 clSetKernelArg (self, idx, sizeof (value), &value);
1663
1664void
1665set_double (OpenCL::Kernel self, cl_uint idx, cl_double value)
1666 CODE:
1667 clSetKernelArg (self, idx, sizeof (value), &value);
1668
1669void
1670set_memory (OpenCL::Kernel self, cl_uint idx, OpenCL::Memory_ornull value)
1671 CODE:
1672 clSetKernelArg (self, idx, sizeof (value), &value);
1673
1674void
1675set_buffer (OpenCL::Kernel self, cl_uint idx, OpenCL::Buffer_ornull value)
1676 CODE:
1677 clSetKernelArg (self, idx, sizeof (value), &value);
1678
1679void
1680set_image2d (OpenCL::Kernel self, cl_uint idx, OpenCL::Image2D_ornull value)
1681 CODE:
1682 clSetKernelArg (self, idx, sizeof (value), &value);
1683
1684void
1685set_image3d (OpenCL::Kernel self, cl_uint idx, OpenCL::Image3D_ornull value)
1686 CODE:
1687 clSetKernelArg (self, idx, sizeof (value), &value);
1688
1689void
1690set_sampler (OpenCL::Kernel self, cl_uint idx, OpenCL::Sampler value)
1691 CODE:
1692 clSetKernelArg (self, idx, sizeof (value), &value);
1693
1694void
1695set_local (OpenCL::Kernel self, cl_uint idx, size_t size)
1696 CODE:
1697 clSetKernelArg (self, idx, size, 0);
1698
1699void
1700set_event (OpenCL::Kernel self, cl_uint idx, OpenCL::Event value)
1701 CODE:
1702 clSetKernelArg (self, idx, sizeof (value), &value);
1703
1704void
789info (OpenCL::Kernel this, cl_kernel_info name) 1705info (OpenCL::Kernel self, cl_kernel_info name)
790 PPCODE: 1706 PPCODE:
791 INFO (Kernel) 1707 INFO (Kernel)
792 1708
1709#BEGIN:kernel
1710
793void 1711void
794set_char (OpenCL::Kernel this, cl_uint idx, cl_char value) 1712function_name (OpenCL::Kernel self)
1713 PPCODE:
1714 size_t size;
1715 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_FUNCTION_NAME, 0, 0, &size));
1716 char *value = tmpbuf (size);
1717 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_FUNCTION_NAME, size, value, 0));
1718 EXTEND (SP, 1);
1719 const int i = 0;
1720 PUSHs (sv_2mortal (newSVpv (value, 0)));
1721
1722void
1723num_args (OpenCL::Kernel self)
1724 ALIAS:
1725 num_args = CL_KERNEL_NUM_ARGS
1726 reference_count = CL_KERNEL_REFERENCE_COUNT
1727 PPCODE:
1728 cl_uint value [1];
1729 NEED_SUCCESS (GetKernelInfo, (self, ix, sizeof (value), value, 0));
1730 EXTEND (SP, 1);
1731 const int i = 0;
1732 PUSHs (sv_2mortal (newSVuv (value [i])));
1733
1734void
1735context (OpenCL::Kernel self)
1736 PPCODE:
1737 cl_context value [1];
1738 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_CONTEXT, sizeof (value), value, 0));
1739 EXTEND (SP, 1);
1740 const int i = 0;
1741 {
1742 NEED_SUCCESS (RetainContext, (value [i]));
1743 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1744 }
1745
1746void
1747program (OpenCL::Kernel self)
1748 PPCODE:
1749 cl_program value [1];
1750 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_PROGRAM, sizeof (value), value, 0));
1751 EXTEND (SP, 1);
1752 const int i = 0;
1753 {
1754 NEED_SUCCESS (RetainProgram, (value [i]));
1755 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Program", value [i]));
1756 }
1757
1758#END:kernel
1759
1760void
1761work_group_info (OpenCL::Kernel self, OpenCL::Device device, cl_kernel_work_group_info name)
795 CODE: 1762 PPCODE:
796 clSetKernelArg (this, idx, sizeof (value), &value); 1763 size_t size;
1764 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, name, 0, 0, &size));
1765 SV *sv = sv_2mortal (newSV (size));
1766 SvUPGRADE (sv, SVt_PV);
1767 SvPOK_only (sv);
1768 SvCUR_set (sv, size);
1769 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, name, size, SvPVX (sv), 0));
1770 XPUSHs (sv);
797 1771
798void 1772#BEGIN:kernel_work_group
799set_uchar (OpenCL::Kernel this, cl_uint idx, cl_uchar value)
800 CODE:
801 clSetKernelArg (this, idx, sizeof (value), &value);
802 1773
803void 1774void
804set_short (OpenCL::Kernel this, cl_uint idx, cl_short value) 1775work_group_size (OpenCL::Kernel self, OpenCL::Device device)
805 CODE: 1776 ALIAS:
806 clSetKernelArg (this, idx, sizeof (value), &value); 1777 work_group_size = CL_KERNEL_WORK_GROUP_SIZE
1778 preferred_work_group_size_multiple = CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
1779 PPCODE:
1780 size_t value [1];
1781 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, ix, sizeof (value), value, 0));
1782 EXTEND (SP, 1);
1783 const int i = 0;
1784 PUSHs (sv_2mortal (newSVuv (value [i])));
807 1785
808void 1786void
809set_ushort (OpenCL::Kernel this, cl_uint idx, cl_ushort value) 1787compile_work_group_size (OpenCL::Kernel self, OpenCL::Device device)
810 CODE: 1788 PPCODE:
811 clSetKernelArg (this, idx, sizeof (value), &value); 1789 size_t size;
1790 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, 0, 0, &size));
1791 size_t *value = tmpbuf (size);
1792 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, size, value, 0));
1793 int i, n = size / sizeof (*value);
1794 EXTEND (SP, n);
1795 for (i = 0; i < n; ++i)
1796 PUSHs (sv_2mortal (newSVuv (value [i])));
812 1797
813void 1798void
814set_int (OpenCL::Kernel this, cl_uint idx, cl_int value) 1799local_mem_size (OpenCL::Kernel self, OpenCL::Device device)
815 CODE: 1800 ALIAS:
816 clSetKernelArg (this, idx, sizeof (value), &value); 1801 local_mem_size = CL_KERNEL_LOCAL_MEM_SIZE
1802 private_mem_size = CL_KERNEL_PRIVATE_MEM_SIZE
1803 PPCODE:
1804 cl_ulong value [1];
1805 NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, ix, sizeof (value), value, 0));
1806 EXTEND (SP, 1);
1807 const int i = 0;
1808 PUSHs (sv_2mortal (newSVuv (value [i])));
817 1809
818void 1810#END:kernel_work_group
819set_uint (OpenCL::Kernel this, cl_uint idx, cl_uint value)
820 CODE:
821 clSetKernelArg (this, idx, sizeof (value), &value);
822
823void
824set_long (OpenCL::Kernel this, cl_uint idx, cl_long value)
825 CODE:
826 clSetKernelArg (this, idx, sizeof (value), &value);
827
828void
829set_ulong (OpenCL::Kernel this, cl_uint idx, cl_ulong value)
830 CODE:
831 clSetKernelArg (this, idx, sizeof (value), &value);
832
833void
834set_half (OpenCL::Kernel this, cl_uint idx, cl_half value)
835 CODE:
836 clSetKernelArg (this, idx, sizeof (value), &value);
837
838void
839set_float (OpenCL::Kernel this, cl_uint idx, cl_float value)
840 CODE:
841 clSetKernelArg (this, idx, sizeof (value), &value);
842
843void
844set_double (OpenCL::Kernel this, cl_uint idx, cl_double value)
845 CODE:
846 clSetKernelArg (this, idx, sizeof (value), &value);
847
848void
849set_memory (OpenCL::Kernel this, cl_uint idx, OpenCL::Memory_ornull value)
850 CODE:
851 clSetKernelArg (this, idx, sizeof (value), &value);
852
853void
854set_buffer (OpenCL::Kernel this, cl_uint idx, OpenCL::Buffer_ornull value)
855 CODE:
856 clSetKernelArg (this, idx, sizeof (value), &value);
857
858void
859set_image2d (OpenCL::Kernel this, cl_uint idx, OpenCL::Image2D_ornull value)
860 CODE:
861 clSetKernelArg (this, idx, sizeof (value), &value);
862
863void
864set_image3d (OpenCL::Kernel this, cl_uint idx, OpenCL::Image3D_ornull value)
865 CODE:
866 clSetKernelArg (this, idx, sizeof (value), &value);
867
868void
869set_sampler (OpenCL::Kernel this, cl_uint idx, OpenCL::Sampler value)
870 CODE:
871 clSetKernelArg (this, idx, sizeof (value), &value);
872
873void
874set_event (OpenCL::Kernel this, cl_uint idx, OpenCL::Event value)
875 CODE:
876 clSetKernelArg (this, idx, sizeof (value), &value);
877 1811
878MODULE = OpenCL PACKAGE = OpenCL::Event 1812MODULE = OpenCL PACKAGE = OpenCL::Event
879 1813
880void 1814void
881DESTROY (OpenCL::Event this) 1815DESTROY (OpenCL::Event self)
882 CODE: 1816 CODE:
883 clReleaseEvent (this); 1817 clReleaseEvent (self);
884 1818
885void 1819void
1820wait (OpenCL::Event self)
1821 CODE:
1822 clWaitForEvents (1, &self);
1823
1824void
886info (OpenCL::Event this, cl_event_info name) 1825info (OpenCL::Event self, cl_event_info name)
887 PPCODE: 1826 PPCODE:
888 INFO (Event) 1827 INFO (Event)
889 1828
1829#BEGIN:event
1830
890void 1831void
891wait (OpenCL::Event this) 1832command_queue (OpenCL::Event self)
1833 PPCODE:
1834 cl_command_queue value [1];
1835 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_QUEUE, sizeof (value), value, 0));
1836 EXTEND (SP, 1);
1837 const int i = 0;
1838 {
1839 NEED_SUCCESS (RetainCommandQueue, (value [i]));
1840 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Queue", value [i]));
1841 }
1842
1843void
1844command_type (OpenCL::Event self)
1845 PPCODE:
1846 cl_command_type value [1];
1847 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_TYPE, sizeof (value), value, 0));
1848 EXTEND (SP, 1);
1849 const int i = 0;
1850 PUSHs (sv_2mortal (newSVuv (value [i])));
1851
1852void
1853reference_count (OpenCL::Event self)
1854 ALIAS:
1855 reference_count = CL_EVENT_REFERENCE_COUNT
1856 command_execution_status = CL_EVENT_COMMAND_EXECUTION_STATUS
1857 PPCODE:
1858 cl_uint value [1];
1859 NEED_SUCCESS (GetEventInfo, (self, ix, sizeof (value), value, 0));
1860 EXTEND (SP, 1);
1861 const int i = 0;
1862 PUSHs (sv_2mortal (newSVuv (value [i])));
1863
1864void
1865context (OpenCL::Event self)
1866 PPCODE:
1867 cl_context value [1];
1868 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_CONTEXT, sizeof (value), value, 0));
1869 EXTEND (SP, 1);
1870 const int i = 0;
1871 {
1872 NEED_SUCCESS (RetainContext, (value [i]));
1873 PUSHs (NEW_MORTAL_OBJ ("OpenCL::Context", value [i]));
1874 }
1875
1876#END:event
1877
1878void
1879profiling_info (OpenCL::Event self, cl_profiling_info name)
892 CODE: 1880 PPCODE:
893 clWaitForEvents (1, &this); 1881 INFO (EventProfiling)
1882
1883#BEGIN:profiling
1884
1885void
1886profiling_command_queued (OpenCL::Event self)
1887 ALIAS:
1888 profiling_command_queued = CL_PROFILING_COMMAND_QUEUED
1889 profiling_command_submit = CL_PROFILING_COMMAND_SUBMIT
1890 profiling_command_start = CL_PROFILING_COMMAND_START
1891 profiling_command_end = CL_PROFILING_COMMAND_END
1892 PPCODE:
1893 cl_ulong value [1];
1894 NEED_SUCCESS (GetEventProfilingInfo, (self, ix, sizeof (value), value, 0));
1895 EXTEND (SP, 1);
1896 const int i = 0;
1897 PUSHs (sv_2mortal (newSVuv (value [i])));
1898
1899#END:profiling
894 1900
895MODULE = OpenCL PACKAGE = OpenCL::UserEvent 1901MODULE = OpenCL PACKAGE = OpenCL::UserEvent
896 1902
897void 1903void
898set_status (OpenCL::UserEvent this, cl_int execution_status) 1904set_status (OpenCL::UserEvent self, cl_int execution_status)
899 CODE: 1905 CODE:
900 clSetUserEventStatus (this, execution_status); 1906 clSetUserEventStatus (self, execution_status);
901 1907

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines