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

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

Diff Legend

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