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

Comparing OpenCL/OpenCL.xs (file contents):
Revision 1.69 by root, Sat May 5 02:30:27 2012 UTC vs.
Revision 1.80 by root, Sat May 5 16:44:02 2012 UTC

1#include <stddef.h>
2
1#include "EXTERN.h" 3#include "EXTERN.h"
2#include "perl.h" 4#include "perl.h"
3#include "XSUB.h" 5#include "XSUB.h"
4 6
5#include "ecb.h"//D 7#include "ecb.h"//D
… …
28#if PREFER_1_1 30#if PREFER_1_1
29 #define CL_USE_DEPRECATED_OPENCL_1_1_APIS 31 #define CL_USE_DEPRECATED_OPENCL_1_1_APIS
30#endif 32#endif
31 33
32#ifdef __APPLE__ 34#ifdef __APPLE__
33 #include <OpenCL/opencl.h> 35 #define CLHDR(name) <OpenCL/name>
34#else 36#else
37 #define CLHDR(name) <CL/name>
38#endif
39
35 #include <CL/opencl.h> 40#include CLHDR(opencl.h)
41
42#ifndef CL_VERSION_1_2
43 #include CLHDR(cl_d3d9.h)
44#endif
45
46#if _WIN32
47 #include CLHDR(cl_d3d10.h)
48 #if CL_VERSION_1_2
49 #include CLHDR<cl_d3d11.h>
50 #endif
51 #include CLHDR<cl_dx9_media_sharing.h.h>
36#endif 52#endif
37 53
38#ifndef CL_VERSION_1_2 54#ifndef CL_VERSION_1_2
39 #undef PREFER_1_1 55 #undef PREFER_1_1
40 #define PREFER_1_1 1 56 #define PREFER_1_1 1
41#endif 57#endif
58
59// make sure all constants we might use are actually defined
60#include "default.h"
42 61
43typedef cl_platform_id OpenCL__Platform; 62typedef cl_platform_id OpenCL__Platform;
44typedef cl_device_id OpenCL__Device; 63typedef cl_device_id OpenCL__Device;
45typedef cl_device_id OpenCL__SubDevice; 64typedef cl_device_id OpenCL__SubDevice;
46typedef cl_context OpenCL__Context; 65typedef cl_context OpenCL__Context;
… …
57typedef cl_kernel OpenCL__Kernel; 76typedef cl_kernel OpenCL__Kernel;
58typedef cl_event OpenCL__Event; 77typedef cl_event OpenCL__Event;
59typedef cl_event OpenCL__UserEvent; 78typedef cl_event OpenCL__UserEvent;
60 79
61typedef struct mapped * OpenCL__Mapped; 80typedef struct mapped * OpenCL__Mapped;
62
63typedef SV *FUTURE;
64 81
65static HV 82static HV
66 *stash_platform, 83 *stash_platform,
67 *stash_device, 84 *stash_device,
68 *stash_subdevice, 85 *stash_subdevice,
… …
177 IV iv; 194 IV iv;
178 const char *name; 195 const char *name;
179 #define const_iv(name) { (IV)CL_ ## name, # name }, 196 #define const_iv(name) { (IV)CL_ ## name, # name },
180} ivstr; 197} ivstr;
181 198
199typedef struct
200{
201 NV nv;
202 const char *name;
203 #define const_nv(name) { (NV)CL_ ## name, # name },
204} nvstr;
205
182static const char * 206static const char *
183iv2str (IV value, const ivstr *base, int count, const char *fallback) 207iv2str (IV value, const ivstr *base, int count, const char *fallback)
184{ 208{
185 int i; 209 int i;
186 static char strbuf [32]; 210 static char strbuf [32];
… …
246#define XPUSH_CLOBJ(stash,id) XPUSHs (new_clobj ((stash), (IV)(id))) 270#define XPUSH_CLOBJ(stash,id) XPUSHs (new_clobj ((stash), (IV)(id)))
247 271
248/* cl objects are either \$iv, or [$iv, ...] */ 272/* cl objects are either \$iv, or [$iv, ...] */
249/* they can be upgraded at runtime to the array form */ 273/* they can be upgraded at runtime to the array form */
250static void * ecb_noinline 274static void * ecb_noinline
251SvCLOBJ (const char *func, const char *svname, SV *sv, const char *pkg) 275SvCLOBJ (CV *cv, const char *svname, SV *sv, const char *pkg)
252{ 276{
253 // sv_derived_from is quite slow :( 277 // sv_derived_from is quite slow :(
254 if (SvROK (sv) && sv_derived_from (sv, pkg)) 278 if (SvROK (sv) && sv_derived_from (sv, pkg))
255 return (void *)SvIV (SvRV (sv)); 279 return (void *)SvIV (SvRV (sv));
256 280
257 croak ("%s: %s is not of type %s", func, svname, pkg); 281 croak ("%s: %s is not of type %s", cv_get_name (cv), svname, pkg);
258} 282}
259 283
260// the "no-inherit" version of the above 284// the "no-inherit" version of the above
261static void * ecb_noinline 285static void * ecb_noinline
262SvCLOBJ_ni (const char *func, const char *svname, SV *sv, HV *stash) 286SvCLOBJ_ni (CV *cv, const char *svname, SV *sv, HV *stash)
263{ 287{
264 if (SvROK (sv) && SvSTASH (SvRV (sv)) == stash) 288 if (SvROK (sv) && SvSTASH (SvRV (sv)) == stash)
265 return (void *)SvIV (SvRV (sv)); 289 return (void *)SvIV (SvRV (sv));
266 290
267 croak ("%s: %s is not of type %s", func, svname, HvNAME (stash)); 291 croak ("%s: %s is not of type %s", cv_get_name (cv), svname, HvNAME (stash));
268} 292}
269 293
270/*****************************************************************************/ 294/*****************************************************************************/
271 295
272static cl_context_properties * ecb_noinline 296static cl_context_properties * ecb_noinline
273SvCONTEXTPROPERTIES (const char *func, const char *svname, SV *sv, cl_context_properties *extra, int extracount) 297SvCONTEXTPROPERTIES (CV *cv, const char *svname, SV *sv, cl_context_properties *extra, int extracount)
274{ 298{
275 if (!sv || !SvOK (sv)) 299 if (!sv || !SvOK (sv))
276 if (extra) 300 if (extra)
277 sv = sv_2mortal (newRV_noinc ((SV *)newAV ())); // slow, but rarely used hopefully 301 sv = sv_2mortal (newRV_noinc ((SV *)newAV ())); // slow, but rarely used hopefully
278 else 302 else
… …
284 int i, len = av_len (av) + 1; 308 int i, len = av_len (av) + 1;
285 cl_context_properties *p = tmpbuf (sizeof (cl_context_properties) * (len + extracount + 1)); 309 cl_context_properties *p = tmpbuf (sizeof (cl_context_properties) * (len + extracount + 1));
286 cl_context_properties *l = p; 310 cl_context_properties *l = p;
287 311
288 if (len & 1) 312 if (len & 1)
289 croak ("%s: %s is not a property list (must contain an even number of elements)", func, svname); 313 croak ("%s: %s is not a property list (must contain an even number of elements)", cv_get_name (cv), svname);
290 314
291 while (extracount--) 315 while (extracount--)
292 *l++ = *extra++; 316 *l++ = *extra++;
293 317
294 for (i = 0; i < len; i += 2) 318 for (i = 0; i < len; i += 2)
… …
299 323
300 switch (t) 324 switch (t)
301 { 325 {
302 case CL_CONTEXT_PLATFORM: 326 case CL_CONTEXT_PLATFORM:
303 if (SvROK (p_sv)) 327 if (SvROK (p_sv))
304 v = (cl_context_properties)SvCLOBJ (func, svname, p_sv, "OpenCL::Platform"); 328 v = (cl_context_properties)SvCLOBJ (cv, svname, p_sv, "OpenCL::Platform");
305 break; 329 break;
306 330
307 case CL_GLX_DISPLAY_KHR: 331 case CL_GLX_DISPLAY_KHR:
308 if (!SvOK (p_sv)) 332 if (!SvOK (p_sv))
309 { 333 {
… …
334 *l = 0; 358 *l = 0;
335 359
336 return p; 360 return p;
337 } 361 }
338 362
339 croak ("%s: %s is not a property list (either undef or [type => value, ...])", func, svname); 363 croak ("%s: %s is not a property list (either undef or [type => value, ...])", cv_get_name (cv), svname);
340} 364}
341 365
366// parse an array of CLOBJ into a void ** array in C - works only for CLOBJs whose representation
367// is a pointer (and only on well-behaved systems).
342static void * ecb_noinline 368static void * ecb_noinline
343object_list (CV *cv, int or_undef, const char *argname, SV *arg, const char *klass, cl_uint *rcount) 369object_list (CV *cv, int or_undef, const char *argname, SV *arg, const char *klass, cl_uint *rcount)
344{ 370{
345 const char *funcname = cv_get_name (cv);
346
347 if (!SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV) 371 if (!SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV)
348 croak ("%s: '%s' parameter must be %sa reference to an array of %s objects", 372 croak ("%s: '%s' parameter must be %sa reference to an array of %s objects",
349 funcname, argname, or_undef ? "undef or " : "", klass); 373 cv_get_name (cv), argname, or_undef ? "undef or " : "", klass);
350 374
351 AV *av = (AV *)SvRV (arg); 375 AV *av = (AV *)SvRV (arg);
352 void **list = 0; 376 void **list = 0;
353 cl_uint count = av_len (av) + 1; 377 cl_uint count = av_len (av) + 1;
354 378
355 if (count) 379 if (count)
356 { 380 {
357 list = tmpbuf (sizeof (*list) * count); 381 list = tmpbuf (sizeof (*list) * count);
358 int i; 382 int i;
359 for (i = 0; i < count; ++i) 383 for (i = 0; i < count; ++i)
360 list [i] = SvCLOBJ (funcname, argname, *av_fetch (av, i, 1), klass); 384 list [i] = SvCLOBJ (cv, argname, *av_fetch (av, i, 1), klass);
361 } 385 }
362 386
363 if (!count && !or_undef) 387 if (!count && !or_undef)
364 croak ("%s: '%s' must contain at least one %s object", 388 croak ("%s: '%s' must contain at least one %s object",
365 funcname, argname, klass); 389 cv_get_name (cv), argname, klass);
366 390
367 *rcount = count; 391 *rcount = count;
368 return (void *)list; 392 return (void *)list;
369} 393}
370 394
… …
596 xthread_t id; 620 xthread_t id;
597 thread_create (&id, build_program_thread, arg); 621 thread_create (&id, build_program_thread, arg);
598} 622}
599 623
600/*****************************************************************************/ 624/*****************************************************************************/
625/* mem object destructor notify */
626
627static void ecb_noinline
628eq_destructor_push (void *data1, void *data2, void *data3)
629{
630}
631
632static eq_vtbl eq_destructor_vtbl = { 0, eq_destructor_push };
633
634static void CL_CALLBACK
635eq_destructor_notify (cl_mem memobj, void *user_data)
636{
637 eq_enq (&eq_destructor_vtbl, (SV *)user_data, (void *)memobj, 0, 0);
638}
639
640/*****************************************************************************/
601/* event objects */ 641/* event objects */
602 642
603static void 643static void
604eq_event_push (void *data1, void *data2, void *data3) 644eq_event_push (void *data1, void *data2, void *data3)
605{ 645{
… …
628 clGetImageInfo (img, CL_IMAGE_ROW_PITCH, sizeof (res), &res, 0); 668 clGetImageInfo (img, CL_IMAGE_ROW_PITCH, sizeof (res), &res, 0);
629 return res; 669 return res;
630} 670}
631 671
632static cl_event * ecb_noinline 672static cl_event * ecb_noinline
633event_list (SV **items, cl_uint *rcount, cl_event extra) 673event_list (CV *cv, SV **items, cl_uint *rcount, cl_event extra)
634{ 674{
635 cl_uint count = *rcount; 675 cl_uint count = *rcount;
636 676
637 if (count > 0x7fffffffU) // yeah, it's a hack - the caller might have underflowed 677 if (count > 0x7fffffffU) // yeah, it's a hack - the caller might have underflowed
638 *rcount = count = 0; 678 *rcount = count = 0;
… …
643 cl_event *list = tmpbuf (sizeof (cl_event) * (count + 1)); 683 cl_event *list = tmpbuf (sizeof (cl_event) * (count + 1));
644 int i = 0; 684 int i = 0;
645 685
646 while (count--) 686 while (count--)
647 if (SvOK (items [count])) 687 if (SvOK (items [count]))
648 list [i++] = SvCLOBJ ("clEnqueue", "wait_events", items [count], "OpenCL::Event"); 688 list [i++] = SvCLOBJ (cv, "wait_events", items [count], "OpenCL::Event");
649 689
650 if (extra) 690 if (extra)
651 list [i++] = extra; 691 list [i++] = extra;
652 692
653 *rcount = i; 693 *rcount = i;
… …
655 return i ? list : 0; 695 return i ? list : 0;
656} 696}
657 697
658#define EVENT_LIST(skip) \ 698#define EVENT_LIST(skip) \
659 cl_uint event_list_count = items - (skip); \ 699 cl_uint event_list_count = items - (skip); \
660 cl_event *event_list_ptr = event_list (&ST (skip), &event_list_count, 0) 700 cl_event *event_list_ptr = event_list (cv, &ST (skip), &event_list_count, 0)
661 701
662#define INFO(class) \ 702#define INFO(class) \
663{ \ 703{ \
664 size_t size; \ 704 size_t size; \
665 NEED_SUCCESS (Get ## class ## Info, (self, name, 0, 0, &size)); \ 705 NEED_SUCCESS (Get ## class ## Info, (self, name, 0, 0, &size)); \
… …
688 void *ptr; 728 void *ptr;
689 size_t cb; 729 size_t cb;
690 cl_event event; 730 cl_event event;
691 size_t row_pitch; 731 size_t row_pitch;
692 size_t slice_pitch; 732 size_t slice_pitch;
733
734 size_t element_size;
735 size_t width, height, depth;
693}; 736};
694 737
695static SV * 738static SV *
696mapped_new (HV *stash, cl_command_queue queue, cl_mem memobj, cl_map_flags flags, void *ptr, size_t cb, cl_event ev, size_t row_pitch, size_t slice_pitch) 739mapped_new (
740 HV *stash, cl_command_queue queue, cl_mem memobj, cl_map_flags flags,
741 void *ptr, size_t cb, cl_event ev,
742 size_t row_pitch, size_t slice_pitch, size_t element_size,
743 size_t width, size_t height, size_t depth
744)
697{ 745{
698 SV *data = newSV (0); 746 SV *data = newSV (0);
699 SvUPGRADE (data, SVt_PVMG); 747 SvUPGRADE (data, SVt_PVMG);
700 748
701 OpenCL__Mapped mapped; 749 OpenCL__Mapped mapped;
702 New (0, mapped, 1, struct mapped); 750 New (0, mapped, 1, struct mapped);
703 751
704 clRetainCommandQueue (queue); 752 clRetainCommandQueue (queue);
705 753
706 mapped->queue = queue; 754 mapped->queue = queue;
707 mapped->memobj = memobj; 755 mapped->memobj = memobj;
708 mapped->ptr = ptr; 756 mapped->ptr = ptr;
709 mapped->cb = cb; 757 mapped->cb = cb;
710 mapped->event = ev; 758 mapped->event = ev;
711 mapped->row_pitch = row_pitch; 759 mapped->row_pitch = row_pitch;
712 mapped->slice_pitch = slice_pitch; 760 mapped->slice_pitch = slice_pitch;
761
762 mapped->element_size = element_size;
763 mapped->width = width;
764 mapped->height = height;
765 mapped->depth = depth;
713 766
714 sv_magicext (data, 0, PERL_MAGIC_ext, 0, (char *)mapped, 0); 767 sv_magicext (data, 0, PERL_MAGIC_ext, 0, (char *)mapped, 0);
715 768
716 if (SvLEN (data)) 769 if (SvLEN (data))
717 Safefree (data); 770 Safefree (data);
… …
747 800
748 mapped->ptr = 0; 801 mapped->ptr = 0;
749} 802}
750 803
751static void 804static void
752mapped_unmap (SV *self, OpenCL__Mapped mapped, cl_command_queue queue, SV **wait_list, cl_uint event_list_count) 805mapped_unmap (CV *cv, SV *self, OpenCL__Mapped mapped, cl_command_queue queue, SV **wait_list, cl_uint event_list_count)
753{ 806{
754 cl_event *event_list_ptr = event_list (wait_list, &event_list_count, mapped->event); 807 cl_event *event_list_ptr = event_list (cv, wait_list, &event_list_count, mapped->event);
755 cl_event ev; 808 cl_event ev;
756 809
757 NEED_SUCCESS (EnqueueUnmapMemObject, (queue, mapped->memobj, mapped->ptr, event_list_count, event_list_ptr, &ev)); 810 NEED_SUCCESS (EnqueueUnmapMemObject, (queue, mapped->memobj, mapped->ptr, event_list_count, event_list_ptr, &ev));
758 811
759 clReleaseEvent (mapped->event); 812 clReleaseEvent (mapped->event);
760 mapped->event = ev; 813 mapped->event = ev;
761 814
762 mapped_detach (self, mapped); 815 mapped_detach (self, mapped);
763} 816}
764 817
818static size_t
819mapped_element_size (OpenCL__Mapped self)
820{
821 if (!self->element_size)
822 clGetImageInfo (self->memobj, CL_IMAGE_ELEMENT_SIZE, sizeof (self->element_size), &self->element_size, 0);
823
824 return self->element_size;
825}
826
765/*****************************************************************************/ 827/*****************************************************************************/
766 828
767MODULE = OpenCL PACKAGE = OpenCL 829MODULE = OpenCL PACKAGE = OpenCL
768 830
769PROTOTYPES: ENABLE 831PROTOTYPES: ENABLE
… …
780 eq_signal_arg = (void*)arg; 842 eq_signal_arg = (void*)arg;
781 843
782BOOT: 844BOOT:
783{ 845{
784 HV *stash = gv_stashpv ("OpenCL", 1); 846 HV *stash = gv_stashpv ("OpenCL", 1);
847
785 static const ivstr *civ, const_iv[] = { 848 static const ivstr *civ, const_iv[] = {
786 { sizeof (cl_char ), "SIZEOF_CHAR" }, 849 { sizeof (cl_char ), "SIZEOF_CHAR" },
787 { sizeof (cl_uchar ), "SIZEOF_UCHAR" }, 850 { sizeof (cl_uchar ), "SIZEOF_UCHAR" },
788 { sizeof (cl_short ), "SIZEOF_SHORT" }, 851 { sizeof (cl_short ), "SIZEOF_SHORT" },
789 { sizeof (cl_ushort), "SIZEOF_USHORT" }, 852 { sizeof (cl_ushort), "SIZEOF_USHORT" },
… …
792 { sizeof (cl_long ), "SIZEOF_LONG" }, 855 { sizeof (cl_long ), "SIZEOF_LONG" },
793 { sizeof (cl_ulong ), "SIZEOF_ULONG" }, 856 { sizeof (cl_ulong ), "SIZEOF_ULONG" },
794 { sizeof (cl_half ), "SIZEOF_HALF" }, 857 { sizeof (cl_half ), "SIZEOF_HALF" },
795 { sizeof (cl_float ), "SIZEOF_FLOAT" }, 858 { sizeof (cl_float ), "SIZEOF_FLOAT" },
796 { sizeof (cl_double), "SIZEOF_DOUBLE" }, 859 { sizeof (cl_double), "SIZEOF_DOUBLE" },
860 { PREFER_1_1 , "PREFER_1_1" },
797#include "constiv.h" 861#include "constiv.h"
798 }; 862 };
799 863
800 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--) 864 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
801 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv)); 865 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
866
867 static const nvstr *cnv, const_nv[] = {
868#include "constnv.h"
869 };
870
871 for (cnv = const_nv + sizeof (const_nv) / sizeof (const_nv [0]); cnv > const_nv; cnv--)
872 newCONSTSUB (stash, (char *)cnv[-1].name, newSVnv (cnv[-1].nv));
873
874 newCONSTSUB (stash, "NAN", newSVnv (CL_NAN)); // CL_NAN might be a function call
802 875
803 stash_platform = gv_stashpv ("OpenCL::Platform", GV_ADD); 876 stash_platform = gv_stashpv ("OpenCL::Platform", GV_ADD);
804 stash_device = gv_stashpv ("OpenCL::Device", GV_ADD); 877 stash_device = gv_stashpv ("OpenCL::Device", GV_ADD);
805 stash_subdevice = gv_stashpv ("OpenCL::SubDevice", GV_ADD); 878 stash_subdevice = gv_stashpv ("OpenCL::SubDevice", GV_ADD);
806 stash_context = gv_stashpv ("OpenCL::Context", GV_ADD); 879 stash_context = gv_stashpv ("OpenCL::Context", GV_ADD);
… …
861 CONTEXT_NOTIFY_CALLBACK; 934 CONTEXT_NOTIFY_CALLBACK;
862 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (properties, type, pfn_notify, user_data, &res)); 935 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (properties, type, pfn_notify, user_data, &res));
863 XPUSH_CLOBJ_CONTEXT; 936 XPUSH_CLOBJ_CONTEXT;
864 937
865void 938void
866context (FUTURE properties, FUTURE devices, FUTURE notify) 939context (cl_context_properties *properties, SV *devices, SV *notify = &PL_sv_undef)
867 PPCODE: 940 PPCODE:
868 /* der Gipfel der Kunst */ 941 cl_uint device_count;
942 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
943
944 CONTEXT_NOTIFY_CALLBACK;
945 NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (properties, device_count, device_list, pfn_notify, user_data, &res));
946 XPUSH_CLOBJ_CONTEXT;
869 947
870void 948void
871wait_for_events (...) 949wait_for_events (...)
872 CODE: 950 CODE:
873 EVENT_LIST (0); 951 EVENT_LIST (0);
… …
924 EXTEND (SP, count); 1002 EXTEND (SP, count);
925 for (i = 0; i < count; ++i) 1003 for (i = 0; i < count; ++i)
926 PUSH_CLOBJ (stash_device, list [i]); 1004 PUSH_CLOBJ (stash_device, list [i]);
927 1005
928void 1006void
929context (OpenCL::Platform self, SV *properties = 0, SV *devices, SV *notify = &PL_sv_undef) 1007context (OpenCL::Platform self, SV *properties, SV *devices, SV *notify = &PL_sv_undef)
930 PPCODE: 1008 PPCODE:
931 cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self }; 1009 cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self };
932 cl_context_properties *props = SvCONTEXTPROPERTIES ("OpenCL::Platform::context", "properties", properties, extra, 2); 1010 cl_context_properties *props = SvCONTEXTPROPERTIES (cv, "properties", properties, extra, 2);
933 1011
934 cl_uint device_count = 0; 1012 cl_uint device_count;
935 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count); 1013 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
936 1014
937 CONTEXT_NOTIFY_CALLBACK; 1015 CONTEXT_NOTIFY_CALLBACK;
938 NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (props, device_count, device_list, pfn_notify, user_data, &res)); 1016 NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (props, device_count, device_list, pfn_notify, user_data, &res));
939 XPUSH_CLOBJ_CONTEXT; 1017 XPUSH_CLOBJ_CONTEXT;
940 1018
941void 1019void
942context_from_type (OpenCL::Platform self, SV *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, SV *notify = &PL_sv_undef) 1020context_from_type (OpenCL::Platform self, SV *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, SV *notify = &PL_sv_undef)
943 PPCODE: 1021 PPCODE:
944 cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self }; 1022 cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self };
945 cl_context_properties *props = SvCONTEXTPROPERTIES ("OpenCL::Platform::context_from_type", "properties", properties, extra, 2); 1023 cl_context_properties *props = SvCONTEXTPROPERTIES (cv, "properties", properties, extra, 2);
946 1024
947 CONTEXT_NOTIFY_CALLBACK; 1025 CONTEXT_NOTIFY_CALLBACK;
948 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (props, type, pfn_notify, user_data, &res)); 1026 NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (props, type, pfn_notify, user_data, &res));
949 XPUSH_CLOBJ_CONTEXT; 1027 XPUSH_CLOBJ_CONTEXT;
950 1028
… …
987 1065
988#BEGIN:device 1066#BEGIN:device
989 1067
990void 1068void
991type (OpenCL::Device self) 1069type (OpenCL::Device self)
1070 ALIAS:
1071 type = CL_DEVICE_TYPE
1072 address_bits = CL_DEVICE_ADDRESS_BITS
1073 max_mem_alloc_size = CL_DEVICE_MAX_MEM_ALLOC_SIZE
1074 single_fp_config = CL_DEVICE_SINGLE_FP_CONFIG
1075 global_mem_cache_size = CL_DEVICE_GLOBAL_MEM_CACHE_SIZE
1076 global_mem_size = CL_DEVICE_GLOBAL_MEM_SIZE
1077 max_constant_buffer_size = CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE
1078 local_mem_size = CL_DEVICE_LOCAL_MEM_SIZE
1079 execution_capabilities = CL_DEVICE_EXECUTION_CAPABILITIES
1080 properties = CL_DEVICE_QUEUE_PROPERTIES
1081 double_fp_config = CL_DEVICE_DOUBLE_FP_CONFIG
1082 half_fp_config = CL_DEVICE_HALF_FP_CONFIG
992 PPCODE: 1083 PPCODE:
993 cl_device_type value [1]; 1084 cl_ulong value [1];
994 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_TYPE, sizeof (value), value, 0)); 1085 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
995 EXTEND (SP, 1); 1086 EXTEND (SP, 1);
996 const int i = 0; 1087 const int i = 0;
997 PUSHs (sv_2mortal (newSVuv (value [i]))); 1088 PUSHs (sv_2mortal (newSVuv (value [i])));
998 1089
999void 1090void
… …
1013 max_write_image_args = CL_DEVICE_MAX_WRITE_IMAGE_ARGS 1104 max_write_image_args = CL_DEVICE_MAX_WRITE_IMAGE_ARGS
1014 image_support = CL_DEVICE_IMAGE_SUPPORT 1105 image_support = CL_DEVICE_IMAGE_SUPPORT
1015 max_samplers = CL_DEVICE_MAX_SAMPLERS 1106 max_samplers = CL_DEVICE_MAX_SAMPLERS
1016 mem_base_addr_align = CL_DEVICE_MEM_BASE_ADDR_ALIGN 1107 mem_base_addr_align = CL_DEVICE_MEM_BASE_ADDR_ALIGN
1017 min_data_type_align_size = CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 1108 min_data_type_align_size = CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE
1109 global_mem_cache_type = CL_DEVICE_GLOBAL_MEM_CACHE_TYPE
1018 global_mem_cacheline_size = CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 1110 global_mem_cacheline_size = CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE
1019 max_constant_args = CL_DEVICE_MAX_CONSTANT_ARGS 1111 max_constant_args = CL_DEVICE_MAX_CONSTANT_ARGS
1112 local_mem_type = CL_DEVICE_LOCAL_MEM_TYPE
1020 preferred_vector_width_half = CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 1113 preferred_vector_width_half = CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF
1021 native_vector_width_char = CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 1114 native_vector_width_char = CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR
1022 native_vector_width_short = CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 1115 native_vector_width_short = CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT
1023 native_vector_width_int = CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 1116 native_vector_width_int = CL_DEVICE_NATIVE_VECTOR_WIDTH_INT
1024 native_vector_width_long = CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 1117 native_vector_width_long = CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG
… …
1062 EXTEND (SP, n); 1155 EXTEND (SP, n);
1063 for (i = 0; i < n; ++i) 1156 for (i = 0; i < n; ++i)
1064 PUSHs (sv_2mortal (newSVuv (value [i]))); 1157 PUSHs (sv_2mortal (newSVuv (value [i])));
1065 1158
1066void 1159void
1067address_bits (OpenCL::Device self)
1068 PPCODE:
1069 cl_bitfield value [1];
1070 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_ADDRESS_BITS, sizeof (value), value, 0));
1071 EXTEND (SP, 1);
1072 const int i = 0;
1073 PUSHs (sv_2mortal (newSVuv (value [i])));
1074
1075void
1076max_mem_alloc_size (OpenCL::Device self)
1077 ALIAS:
1078 max_mem_alloc_size = CL_DEVICE_MAX_MEM_ALLOC_SIZE
1079 global_mem_cache_size = CL_DEVICE_GLOBAL_MEM_CACHE_SIZE
1080 global_mem_size = CL_DEVICE_GLOBAL_MEM_SIZE
1081 max_constant_buffer_size = CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE
1082 local_mem_size = CL_DEVICE_LOCAL_MEM_SIZE
1083 PPCODE:
1084 cl_ulong value [1];
1085 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
1086 EXTEND (SP, 1);
1087 const int i = 0;
1088 PUSHs (sv_2mortal (newSVuv (value [i])));
1089
1090void
1091single_fp_config (OpenCL::Device self)
1092 ALIAS:
1093 single_fp_config = CL_DEVICE_SINGLE_FP_CONFIG
1094 double_fp_config = CL_DEVICE_DOUBLE_FP_CONFIG
1095 half_fp_config = CL_DEVICE_HALF_FP_CONFIG
1096 PPCODE:
1097 cl_device_fp_config value [1];
1098 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
1099 EXTEND (SP, 1);
1100 const int i = 0;
1101 PUSHs (sv_2mortal (newSVuv (value [i])));
1102
1103void
1104global_mem_cache_type (OpenCL::Device self)
1105 PPCODE:
1106 cl_device_mem_cache_type value [1];
1107 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof (value), value, 0));
1108 EXTEND (SP, 1);
1109 const int i = 0;
1110 PUSHs (sv_2mortal (newSVuv (value [i])));
1111
1112void
1113local_mem_type (OpenCL::Device self)
1114 PPCODE:
1115 cl_device_local_mem_type value [1];
1116 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_LOCAL_MEM_TYPE, sizeof (value), value, 0));
1117 EXTEND (SP, 1);
1118 const int i = 0;
1119 PUSHs (sv_2mortal (newSVuv (value [i])));
1120
1121void
1122error_correction_support (OpenCL::Device self) 1160error_correction_support (OpenCL::Device self)
1123 ALIAS: 1161 ALIAS:
1124 error_correction_support = CL_DEVICE_ERROR_CORRECTION_SUPPORT 1162 error_correction_support = CL_DEVICE_ERROR_CORRECTION_SUPPORT
1125 endian_little = CL_DEVICE_ENDIAN_LITTLE 1163 endian_little = CL_DEVICE_ENDIAN_LITTLE
1126 available = CL_DEVICE_AVAILABLE 1164 available = CL_DEVICE_AVAILABLE
1127 compiler_available = CL_DEVICE_COMPILER_AVAILABLE 1165 compiler_available = CL_DEVICE_COMPILER_AVAILABLE
1128 host_unified_memory = CL_DEVICE_HOST_UNIFIED_MEMORY 1166 host_unified_memory = CL_DEVICE_HOST_UNIFIED_MEMORY
1129 PPCODE: 1167 PPCODE:
1130 cl_bool value [1]; 1168 cl_uint value [1];
1131 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0)); 1169 NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
1132 EXTEND (SP, 1); 1170 EXTEND (SP, 1);
1133 const int i = 0; 1171 const int i = 0;
1134 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no)); 1172 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
1135
1136void
1137execution_capabilities (OpenCL::Device self)
1138 PPCODE:
1139 cl_device_exec_capabilities value [1];
1140 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (value), value, 0));
1141 EXTEND (SP, 1);
1142 const int i = 0;
1143 PUSHs (sv_2mortal (newSVuv (value [i])));
1144
1145void
1146properties (OpenCL::Device self)
1147 PPCODE:
1148 cl_command_queue_properties value [1];
1149 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_QUEUE_PROPERTIES, sizeof (value), value, 0));
1150 EXTEND (SP, 1);
1151 const int i = 0;
1152 PUSHs (sv_2mortal (newSVuv (value [i])));
1153 1173
1154void 1174void
1155platform (OpenCL::Device self) 1175platform (OpenCL::Device self)
1156 PPCODE: 1176 PPCODE:
1157 cl_platform_id value [1]; 1177 cl_platform_id value [1];
1158 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PLATFORM, sizeof (value), value, 0)); 1178 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PLATFORM, sizeof (value), value, 0));
1159 EXTEND (SP, 1); 1179 EXTEND (SP, 1);
1160 const int i = 0; 1180 const int i = 0;
1161 {
1162 PUSH_CLOBJ (stash_platform, value [i]); 1181 PUSH_CLOBJ (stash_platform, value [i]);
1163 }
1164 1182
1165void 1183void
1166name (OpenCL::Device self) 1184name (OpenCL::Device self)
1167 ALIAS: 1185 ALIAS:
1168 name = CL_DEVICE_NAME 1186 name = CL_DEVICE_NAME
… …
1185 PPCODE: 1203 PPCODE:
1186 cl_device_id value [1]; 1204 cl_device_id value [1];
1187 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PARENT_DEVICE_EXT, sizeof (value), value, 0)); 1205 NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PARENT_DEVICE_EXT, sizeof (value), value, 0));
1188 EXTEND (SP, 1); 1206 EXTEND (SP, 1);
1189 const int i = 0; 1207 const int i = 0;
1190 {
1191 PUSH_CLOBJ (stash_device, value [i]); 1208 PUSH_CLOBJ (stash_device, value [i]);
1192 }
1193 1209
1194void 1210void
1195partition_types_ext (OpenCL::Device self) 1211partition_types_ext (OpenCL::Device self)
1196 ALIAS: 1212 ALIAS:
1197 partition_types_ext = CL_DEVICE_PARTITION_TYPES_EXT 1213 partition_types_ext = CL_DEVICE_PARTITION_TYPES_EXT
… …
1274 const cl_image_desc desc = { 1290 const cl_image_desc desc = {
1275 type, 1291 type,
1276 width, height, depth, 1292 width, height, depth,
1277 array_size, row_pitch, slice_pitch, 1293 array_size, row_pitch, slice_pitch,
1278 num_mip_level, num_samples, 1294 num_mip_level, num_samples,
1279 type == CL_MEM_OBJECT_IMAGE1D_BUFFER ? (cl_mem)SvCLOBJ ("OpenCL::Context::Image", "data", data, "OpenCL::Buffer") : 0 1295 type == CL_MEM_OBJECT_IMAGE1D_BUFFER ? (cl_mem)SvCLOBJ (cv, "data", data, "OpenCL::Buffer") : 0
1280 }; 1296 };
1281 NEED_SUCCESS_ARG (cl_mem mem, CreateImage, (self, flags, &format, &desc, ptr, &res)); 1297 NEED_SUCCESS_ARG (cl_mem mem, CreateImage, (self, flags, &format, &desc, ptr, &res));
1282 HV *stash = stash_image; 1298 HV *stash = stash_image;
1283 switch (type) 1299 switch (type)
1284 { 1300 {
… …
1420 XPUSH_CLOBJ (stash_program, prog); 1436 XPUSH_CLOBJ (stash_program, prog);
1421 1437
1422void 1438void
1423program_with_binary (OpenCL::Context self, SV *devices, SV *binaries) 1439program_with_binary (OpenCL::Context self, SV *devices, SV *binaries)
1424 PPCODE: 1440 PPCODE:
1425 if (!SvROK (devices) || SvTYPE (SvRV (devices)) != SVt_PVAV) 1441 cl_uint device_count;
1426 croak ("OpenCL::Context::program_with_binary: devices must be specified as reference to an array of device objects"); 1442 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
1427
1428 devices = SvRV (devices);
1429 1443
1430 if (!SvROK (binaries) || SvTYPE (SvRV (binaries)) != SVt_PVAV) 1444 if (!SvROK (binaries) || SvTYPE (SvRV (binaries)) != SVt_PVAV)
1431 croak ("OpenCL::Context::program_with_binary: binaries must be specified as reference to an array of strings"); 1445 croak ("OpenCL::Context::program_with_binary: binaries must be specified as reference to an array of strings");
1432 1446
1433 binaries = SvRV (binaries); 1447 binaries = SvRV (binaries);
1434 1448
1435 if (av_len ((AV *)devices) != av_len ((AV *)binaries)) 1449 if (device_count != av_len ((AV *)binaries) + 1)
1436 croak ("OpenCL::Context::program_with_binary: differing numbers of devices and binaries are not allowed"); 1450 croak ("OpenCL::Context::program_with_binary: differing numbers of devices and binaries are not allowed");
1437 1451
1438 int count = av_len ((AV *)devices) + 1;
1439 cl_device_id *device_list = tmpbuf (sizeof (*device_list) * count);
1440 size_t *length_list = tmpbuf (sizeof (*length_list) * count); 1452 size_t *length_list = tmpbuf (sizeof (*length_list) * device_count);
1441 const unsigned char **binary_list = tmpbuf (sizeof (*binary_list) * count); 1453 const unsigned char **binary_list = tmpbuf (sizeof (*binary_list) * device_count);
1442 cl_int *status_list = tmpbuf (sizeof (*status_list) * count); 1454 cl_int *status_list = tmpbuf (sizeof (*status_list) * device_count);
1443 1455
1444 int i; 1456 int i;
1445 for (i = 0; i < count; ++i) 1457 for (i = 0; i < device_count; ++i)
1446 { 1458 {
1447 device_list [i] = SvCLOBJ ("OpenCL::Context::program_with_binary", "devices", *av_fetch ((AV *)devices, i, 0), "OpenCL::Device");
1448 STRLEN len; 1459 STRLEN len;
1449 binary_list [i] = (const unsigned char *)SvPVbyte (*av_fetch ((AV *)binaries, i, 0), len); 1460 binary_list [i] = (const unsigned char *)SvPVbyte (*av_fetch ((AV *)binaries, i, 0), len);
1450 length_list [i] = len; 1461 length_list [i] = len;
1451 } 1462 }
1452 1463
1453 NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithBinary, (self, count, device_list, length_list, binary_list, GIMME_V == G_ARRAY ? status_list : 0, &res)); 1464 NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithBinary, (self, device_count, device_list,
1465 length_list, binary_list,
1466 GIMME_V == G_ARRAY ? status_list : 0, &res));
1454 1467
1455 EXTEND (SP, 2); 1468 EXTEND (SP, 2);
1456 PUSH_CLOBJ (stash_program, prog); 1469 PUSH_CLOBJ (stash_program, prog);
1457 1470
1458 if (GIMME_V == G_ARRAY) 1471 if (GIMME_V == G_ARRAY)
1459 { 1472 {
1460 AV *av = newAV (); 1473 AV *av = newAV ();
1461 PUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 1474 PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
1462 1475
1463 for (i = count; i--; ) 1476 for (i = device_count; i--; )
1464 av_store (av, i, newSViv (status_list [i])); 1477 av_store (av, i, newSViv (status_list [i]));
1465 } 1478 }
1466 1479
1467#if CL_VERSION_1_2 1480#if CL_VERSION_1_2
1468 1481
1469void 1482void
1470program_with_built_in_kernels (OpenCL::Context self, SV *devices, SV *kernel_names) 1483program_with_built_in_kernels (OpenCL::Context self, SV *devices, SV *kernel_names)
1471 PPCODE: 1484 PPCODE:
1472 cl_uint device_count = 0; 1485 cl_uint device_count;
1473 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count); 1486 cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
1474 1487
1475 NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithBuiltInKernels, (self, device_count, device_list, SvPVbyte_nolen (kernel_names), &res)); 1488 NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithBuiltInKernels, (self, device_count, device_list, SvPVbyte_nolen (kernel_names), &res));
1476 1489
1477 XPUSH_CLOBJ (stash_program, prog); 1490 XPUSH_CLOBJ (stash_program, prog);
1478 1491
… …
1520 cl_device_id *value = tmpbuf (size); 1533 cl_device_id *value = tmpbuf (size);
1521 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, size, value, 0)); 1534 NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, size, value, 0));
1522 int i, n = size / sizeof (*value); 1535 int i, n = size / sizeof (*value);
1523 EXTEND (SP, n); 1536 EXTEND (SP, n);
1524 for (i = 0; i < n; ++i) 1537 for (i = 0; i < n; ++i)
1525 {
1526 PUSH_CLOBJ (stash_device, value [i]); 1538 PUSH_CLOBJ (stash_device, value [i]);
1527 }
1528 1539
1529void 1540void
1530properties (OpenCL::Context self) 1541properties (OpenCL::Context self)
1531 PPCODE: 1542 PPCODE:
1532 size_t size; 1543 size_t size;
… …
1853 cb -= offset; 1864 cb -= offset;
1854 } 1865 }
1855 1866
1856 cl_event ev; 1867 cl_event ev;
1857 NEED_SUCCESS_ARG (void *ptr, EnqueueMapBuffer, (self, buf, blocking, map_flags, offset, cb, event_list_count, event_list_ptr, &ev, &res)); 1868 NEED_SUCCESS_ARG (void *ptr, EnqueueMapBuffer, (self, buf, blocking, map_flags, offset, cb, event_list_count, event_list_ptr, &ev, &res));
1858 XPUSHs (mapped_new (stash_mappedbuffer, self, buf, map_flags, ptr, cb, ev, 0, 0)); 1869 XPUSHs (mapped_new (stash_mappedbuffer, self, buf, map_flags, ptr, cb, ev, 0, 0, 1, cb, 1, 1));
1859 1870
1860void 1871void
1861map_image (OpenCL::Queue self, OpenCL::Image img, cl_bool blocking = 1, cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, size_t x = 0, size_t y = 0, size_t z = 0, SV *width_ = &PL_sv_undef, SV *height_ = &PL_sv_undef, SV *depth_ = &PL_sv_undef, ...) 1872map_image (OpenCL::Queue self, OpenCL::Image img, cl_bool blocking = 1, cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, size_t x = 0, size_t y = 0, size_t z = 0, SV *width_ = &PL_sv_undef, SV *height_ = &PL_sv_undef, SV *depth_ = &PL_sv_undef, ...)
1862 ALIAS: 1873 ALIAS:
1863 enqueue_map_image = 0 1874 enqueue_map_image = 0
… …
1872 size_t height = SvIV (width_); 1883 size_t height = SvIV (width_);
1873 if (!SvOK (height_)) 1884 if (!SvOK (height_))
1874 { 1885 {
1875 NEED_SUCCESS (GetImageInfo, (img, CL_IMAGE_HEIGHT, sizeof (height), &height, 0)); 1886 NEED_SUCCESS (GetImageInfo, (img, CL_IMAGE_HEIGHT, sizeof (height), &height, 0));
1876 height -= y; 1887 height -= y;
1888
1889 // stupid opencl returns 0 for depth, but requires 1 for 2d images
1890 if (!height)
1891 height = 1;
1877 } 1892 }
1878 1893
1879 size_t depth = SvIV (width_); 1894 size_t depth = SvIV (width_);
1880 if (!SvOK (depth_)) 1895 if (!SvOK (depth_))
1881 { 1896 {
… …
1897 1912
1898 size_t cb = slice_pitch ? slice_pitch * region [2] 1913 size_t cb = slice_pitch ? slice_pitch * region [2]
1899 : row_pitch ? row_pitch * region [1] 1914 : row_pitch ? row_pitch * region [1]
1900 : region [0]; 1915 : region [0];
1901 1916
1902 XPUSHs (mapped_new (stash_mappedimage, self, img, map_flags, ptr, cb, ev, row_pitch, slice_pitch)); 1917 XPUSHs (mapped_new (stash_mappedimage, self, img, map_flags, ptr, cb, ev, row_pitch, slice_pitch, 0, width, height, depth));
1903 1918
1904void 1919void
1905unmap (OpenCL::Queue self, OpenCL::Mapped mapped, ...) 1920unmap (OpenCL::Queue self, OpenCL::Mapped mapped, ...)
1906 PPCODE: 1921 PPCODE:
1907 mapped_unmap (ST (1), mapped, self, &ST (2), items - 2); 1922 mapped_unmap (cv, ST (1), mapped, self, &ST (2), items - 2);
1908 if (GIMME_V != G_VOID) 1923 if (GIMME_V != G_VOID)
1909 { 1924 {
1910 clRetainEvent (mapped->event); 1925 clRetainEvent (mapped->event);
1911 XPUSH_CLOBJ (stash_event, mapped->event); 1926 XPUSH_CLOBJ (stash_event, mapped->event);
1912 } 1927 }
… …
2122 PPCODE: 2137 PPCODE:
2123 cl_context value [1]; 2138 cl_context value [1];
2124 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_CONTEXT, sizeof (value), value, 0)); 2139 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_CONTEXT, sizeof (value), value, 0));
2125 EXTEND (SP, 1); 2140 EXTEND (SP, 1);
2126 const int i = 0; 2141 const int i = 0;
2127 {
2128 NEED_SUCCESS (RetainContext, (value [i])); 2142 NEED_SUCCESS (RetainContext, (value [i]));
2129 PUSH_CLOBJ (stash_context, value [i]); 2143 PUSH_CLOBJ (stash_context, value [i]);
2130 }
2131 2144
2132void 2145void
2133device (OpenCL::Queue self) 2146device (OpenCL::Queue self)
2134 PPCODE: 2147 PPCODE:
2135 cl_device_id value [1]; 2148 cl_device_id value [1];
2136 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_DEVICE, sizeof (value), value, 0)); 2149 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_DEVICE, sizeof (value), value, 0));
2137 EXTEND (SP, 1); 2150 EXTEND (SP, 1);
2138 const int i = 0; 2151 const int i = 0;
2139 {
2140 PUSH_CLOBJ (stash_device, value [i]); 2152 PUSH_CLOBJ (stash_device, value [i]);
2141 }
2142 2153
2143void 2154void
2144reference_count (OpenCL::Queue self) 2155reference_count (OpenCL::Queue self)
2145 PPCODE: 2156 PPCODE:
2146 cl_uint value [1]; 2157 cl_uint value [1];
… …
2150 PUSHs (sv_2mortal (newSVuv (value [i]))); 2161 PUSHs (sv_2mortal (newSVuv (value [i])));
2151 2162
2152void 2163void
2153properties (OpenCL::Queue self) 2164properties (OpenCL::Queue self)
2154 PPCODE: 2165 PPCODE:
2155 cl_command_queue_properties value [1]; 2166 cl_ulong value [1];
2156 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_PROPERTIES, sizeof (value), value, 0)); 2167 NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_PROPERTIES, sizeof (value), value, 0));
2157 EXTEND (SP, 1); 2168 EXTEND (SP, 1);
2158 const int i = 0; 2169 const int i = 0;
2159 PUSHs (sv_2mortal (newSVuv (value [i]))); 2170 PUSHs (sv_2mortal (newSVuv (value [i])));
2160 2171
… …
2170void 2181void
2171info (OpenCL::Memory self, cl_mem_info name) 2182info (OpenCL::Memory self, cl_mem_info name)
2172 PPCODE: 2183 PPCODE:
2173 INFO (MemObject) 2184 INFO (MemObject)
2174 2185
2186void
2187destructor_callback (OpenCL::Memory self, SV *notify)
2188 PPCODE:
2189 clSetMemObjectDestructorCallback (self, eq_destructor_notify, SvREFCNT_inc (s_get_cv (notify)));
2190
2175#BEGIN:mem 2191#BEGIN:mem
2176 2192
2177void 2193void
2178type (OpenCL::Memory self) 2194type (OpenCL::Memory self)
2195 ALIAS:
2196 type = CL_MEM_TYPE
2197 map_count = CL_MEM_MAP_COUNT
2198 reference_count = CL_MEM_REFERENCE_COUNT
2179 PPCODE: 2199 PPCODE:
2180 cl_mem_object_type value [1]; 2200 cl_uint value [1];
2181 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_TYPE, sizeof (value), value, 0)); 2201 NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
2182 EXTEND (SP, 1); 2202 EXTEND (SP, 1);
2183 const int i = 0; 2203 const int i = 0;
2184 PUSHs (sv_2mortal (newSVuv (value [i]))); 2204 PUSHs (sv_2mortal (newSVuv (value [i])));
2185 2205
2186void 2206void
2187flags (OpenCL::Memory self) 2207flags (OpenCL::Memory self)
2188 PPCODE: 2208 PPCODE:
2189 cl_mem_flags value [1]; 2209 cl_ulong value [1];
2190 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_FLAGS, sizeof (value), value, 0)); 2210 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_FLAGS, sizeof (value), value, 0));
2191 EXTEND (SP, 1); 2211 EXTEND (SP, 1);
2192 const int i = 0; 2212 const int i = 0;
2193 PUSHs (sv_2mortal (newSVuv (value [i]))); 2213 PUSHs (sv_2mortal (newSVuv (value [i])));
2194 2214
… …
2212 EXTEND (SP, 1); 2232 EXTEND (SP, 1);
2213 const int i = 0; 2233 const int i = 0;
2214 PUSHs (sv_2mortal (newSVuv ((IV)(intptr_t)value [i]))); 2234 PUSHs (sv_2mortal (newSVuv ((IV)(intptr_t)value [i])));
2215 2235
2216void 2236void
2217map_count (OpenCL::Memory self)
2218 ALIAS:
2219 map_count = CL_MEM_MAP_COUNT
2220 reference_count = CL_MEM_REFERENCE_COUNT
2221 PPCODE:
2222 cl_uint value [1];
2223 NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
2224 EXTEND (SP, 1);
2225 const int i = 0;
2226 PUSHs (sv_2mortal (newSVuv (value [i])));
2227
2228void
2229context (OpenCL::Memory self) 2237context (OpenCL::Memory self)
2230 PPCODE: 2238 PPCODE:
2231 cl_context value [1]; 2239 cl_context value [1];
2232 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_CONTEXT, sizeof (value), value, 0)); 2240 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_CONTEXT, sizeof (value), value, 0));
2233 EXTEND (SP, 1); 2241 EXTEND (SP, 1);
2234 const int i = 0; 2242 const int i = 0;
2235 {
2236 NEED_SUCCESS (RetainContext, (value [i])); 2243 NEED_SUCCESS (RetainContext, (value [i]));
2237 PUSH_CLOBJ (stash_context, value [i]); 2244 PUSH_CLOBJ (stash_context, value [i]);
2238 }
2239 2245
2240void 2246void
2241associated_memobject (OpenCL::Memory self) 2247associated_memobject (OpenCL::Memory self)
2242 PPCODE: 2248 PPCODE:
2243 cl_mem value [1]; 2249 cl_mem value [1];
2244 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_ASSOCIATED_MEMOBJECT, sizeof (value), value, 0)); 2250 NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_ASSOCIATED_MEMOBJECT, sizeof (value), value, 0));
2245 EXTEND (SP, 1); 2251 EXTEND (SP, 1);
2246 const int i = 0; 2252 const int i = 0;
2247 {
2248 NEED_SUCCESS (RetainMemObject, (value [i])); 2253 NEED_SUCCESS (RetainMemObject, (value [i]));
2249 PUSH_CLOBJ (stash_memory, value [i]); 2254 PUSH_CLOBJ (stash_memory, value [i]);
2250 }
2251 2255
2252#END:mem 2256#END:mem
2253 2257
2254#if cl_apple_gl_sharing || cl_khr_gl_sharing 2258#if cl_apple_gl_sharing || cl_khr_gl_sharing
2255 2259
… …
2354 2358
2355#BEGIN:sampler 2359#BEGIN:sampler
2356 2360
2357void 2361void
2358reference_count (OpenCL::Sampler self) 2362reference_count (OpenCL::Sampler self)
2363 ALIAS:
2364 reference_count = CL_SAMPLER_REFERENCE_COUNT
2365 normalized_coords = CL_SAMPLER_NORMALIZED_COORDS
2366 addressing_mode = CL_SAMPLER_ADDRESSING_MODE
2359 PPCODE: 2367 PPCODE:
2360 cl_uint value [1]; 2368 cl_uint value [1];
2361 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_REFERENCE_COUNT, sizeof (value), value, 0)); 2369 NEED_SUCCESS (GetSamplerInfo, (self, ix, sizeof (value), value, 0));
2362 EXTEND (SP, 1); 2370 EXTEND (SP, 1);
2363 const int i = 0; 2371 const int i = 0;
2364 PUSHs (sv_2mortal (newSVuv (value [i]))); 2372 PUSHs (sv_2mortal (newSVuv (value [i])));
2365 2373
2366void 2374void
… …
2368 PPCODE: 2376 PPCODE:
2369 cl_context value [1]; 2377 cl_context value [1];
2370 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_CONTEXT, sizeof (value), value, 0)); 2378 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_CONTEXT, sizeof (value), value, 0));
2371 EXTEND (SP, 1); 2379 EXTEND (SP, 1);
2372 const int i = 0; 2380 const int i = 0;
2373 {
2374 NEED_SUCCESS (RetainContext, (value [i])); 2381 NEED_SUCCESS (RetainContext, (value [i]));
2375 PUSH_CLOBJ (stash_context, value [i]); 2382 PUSH_CLOBJ (stash_context, value [i]);
2376 }
2377
2378void
2379normalized_coords (OpenCL::Sampler self)
2380 PPCODE:
2381 cl_addressing_mode value [1];
2382 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_NORMALIZED_COORDS, sizeof (value), value, 0));
2383 EXTEND (SP, 1);
2384 const int i = 0;
2385 PUSHs (sv_2mortal (newSVuv (value [i])));
2386
2387void
2388addressing_mode (OpenCL::Sampler self)
2389 PPCODE:
2390 cl_filter_mode value [1];
2391 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_ADDRESSING_MODE, sizeof (value), value, 0));
2392 EXTEND (SP, 1);
2393 const int i = 0;
2394 PUSHs (sv_2mortal (newSVuv (value [i])));
2395 2383
2396void 2384void
2397filter_mode (OpenCL::Sampler self) 2385filter_mode (OpenCL::Sampler self)
2398 PPCODE: 2386 PPCODE:
2399 cl_bool value [1]; 2387 cl_uint value [1];
2400 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_FILTER_MODE, sizeof (value), value, 0)); 2388 NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_FILTER_MODE, sizeof (value), value, 0));
2401 EXTEND (SP, 1); 2389 EXTEND (SP, 1);
2402 const int i = 0; 2390 const int i = 0;
2403 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no)); 2391 PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
2404 2392
… …
2459 HE *he; 2447 HE *he;
2460 int i = 0; 2448 int i = 0;
2461 while (he = hv_iternext (hv)) 2449 while (he = hv_iternext (hv))
2462 { 2450 {
2463 header_name [i] = SvPVbyte_nolen (HeSVKEY_force (he)); 2451 header_name [i] = SvPVbyte_nolen (HeSVKEY_force (he));
2464 header_list [i] = SvCLOBJ ("clCompileProgram", "headers", HeVAL (he), "OpenCL::Program"); 2452 header_list [i] = SvCLOBJ (cv, "headers", HeVAL (he), "OpenCL::Program");
2465 ++i; 2453 ++i;
2466 } 2454 }
2467 } 2455 }
2468 2456
2469 void *user_data; 2457 void *user_data;
… …
2489#BEGIN:program_build 2477#BEGIN:program_build
2490 2478
2491void 2479void
2492build_status (OpenCL::Program self, OpenCL::Device device) 2480build_status (OpenCL::Program self, OpenCL::Device device)
2493 PPCODE: 2481 PPCODE:
2494 cl_build_status value [1]; 2482 cl_int value [1];
2495 NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BUILD_STATUS, sizeof (value), value, 0)); 2483 NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BUILD_STATUS, sizeof (value), value, 0));
2496 EXTEND (SP, 1); 2484 EXTEND (SP, 1);
2497 const int i = 0; 2485 const int i = 0;
2498 PUSHs (sv_2mortal (newSViv (value [i]))); 2486 PUSHs (sv_2mortal (newSViv (value [i])));
2499 2487
… …
2508 char *value = tmpbuf (size); 2496 char *value = tmpbuf (size);
2509 NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, size, value, 0)); 2497 NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, size, value, 0));
2510 EXTEND (SP, 1); 2498 EXTEND (SP, 1);
2511 const int i = 0; 2499 const int i = 0;
2512 PUSHs (sv_2mortal (newSVpv (value, 0))); 2500 PUSHs (sv_2mortal (newSVpv (value, 0)));
2501
2502void
2503binary_type (OpenCL::Program self, OpenCL::Device device)
2504 PPCODE:
2505 cl_uint value [1];
2506 NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BINARY_TYPE, sizeof (value), value, 0));
2507 EXTEND (SP, 1);
2508 const int i = 0;
2509 PUSHs (sv_2mortal (newSVuv ((UV)value [i])));
2513 2510
2514#END:program_build 2511#END:program_build
2515 2512
2516void 2513void
2517kernel (OpenCL::Program program, SV *function) 2514kernel (OpenCL::Program program, SV *function)
… …
2584 PPCODE: 2581 PPCODE:
2585 cl_context value [1]; 2582 cl_context value [1];
2586 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_CONTEXT, sizeof (value), value, 0)); 2583 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_CONTEXT, sizeof (value), value, 0));
2587 EXTEND (SP, 1); 2584 EXTEND (SP, 1);
2588 const int i = 0; 2585 const int i = 0;
2589 {
2590 NEED_SUCCESS (RetainContext, (value [i])); 2586 NEED_SUCCESS (RetainContext, (value [i]));
2591 PUSH_CLOBJ (stash_context, value [i]); 2587 PUSH_CLOBJ (stash_context, value [i]);
2592 }
2593 2588
2594void 2589void
2595devices (OpenCL::Program self) 2590devices (OpenCL::Program self)
2596 PPCODE: 2591 PPCODE:
2597 size_t size; 2592 size_t size;
… …
2599 cl_device_id *value = tmpbuf (size); 2594 cl_device_id *value = tmpbuf (size);
2600 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, size, value, 0)); 2595 NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, size, value, 0));
2601 int i, n = size / sizeof (*value); 2596 int i, n = size / sizeof (*value);
2602 EXTEND (SP, n); 2597 EXTEND (SP, n);
2603 for (i = 0; i < n; ++i) 2598 for (i = 0; i < n; ++i)
2604 {
2605 PUSH_CLOBJ (stash_device, value [i]); 2599 PUSH_CLOBJ (stash_device, value [i]);
2606 }
2607 2600
2608void 2601void
2609source (OpenCL::Program self) 2602source (OpenCL::Program self)
2610 PPCODE: 2603 PPCODE:
2611 size_t size; 2604 size_t size;
… …
2684 case 'f': arg.cf = SvNV (sv); size = sizeof (arg.cf); break; 2677 case 'f': arg.cf = SvNV (sv); size = sizeof (arg.cf); break;
2685 case 'd': arg.cd = SvNV (sv); size = sizeof (arg.cd); break; 2678 case 'd': arg.cd = SvNV (sv); size = sizeof (arg.cd); break;
2686 2679
2687 case 'z': nullarg = 1; size = SvIV (sv); break; 2680 case 'z': nullarg = 1; size = SvIV (sv); break;
2688 2681
2689 case 'm': nullarg = !SvOK (sv); arg.cm = SvCLOBJ ("OpenCL::Kernel::setf", "m", sv, "OpenCL::Memory" ); size = sizeof (arg.cm); break; 2682 case 'm': nullarg = !SvOK (sv); arg.cm = SvCLOBJ (cv, "m", sv, "OpenCL::Memory" ); size = sizeof (arg.cm); break;
2690 case 'a': nullarg = !SvOK (sv); arg.ca = SvCLOBJ ("OpenCL::Kernel::setf", "a", sv, "OpenCL::Sampler"); size = sizeof (arg.ca); break; 2683 case 'a': nullarg = !SvOK (sv); arg.ca = SvCLOBJ (cv, "a", sv, "OpenCL::Sampler"); size = sizeof (arg.ca); break;
2691 case 'e': nullarg = !SvOK (sv); arg.ca = SvCLOBJ ("OpenCL::Kernel::setf", "e", sv, "OpenCL::Event" ); size = sizeof (arg.ce); break; 2684 case 'e': nullarg = !SvOK (sv); arg.ca = SvCLOBJ (cv, "e", sv, "OpenCL::Event" ); size = sizeof (arg.ce); break;
2692 2685
2693 default: 2686 default:
2694 croak ("OpenCL::Kernel::setf format character '%c' not supported", type); 2687 croak ("OpenCL::Kernel::setf format character '%c' not supported", type);
2695 } 2688 }
2696 2689
… …
2767 CODE: 2760 CODE:
2768 clSetKernelArg (self, idx, sizeof (value), value ? &value : 0); 2761 clSetKernelArg (self, idx, sizeof (value), value ? &value : 0);
2769 2762
2770void 2763void
2771set_image (OpenCL::Kernel self, cl_uint idx, OpenCL::Image_ornull value) 2764set_image (OpenCL::Kernel self, cl_uint idx, OpenCL::Image_ornull value)
2772 ALIAS:
2773 set_image2d = 0
2774 set_image3d = 0
2775 CODE: 2765 CODE:
2776 clSetKernelArg (self, idx, sizeof (value), value ? &value : 0); 2766 clSetKernelArg (self, idx, sizeof (value), value ? &value : 0);
2777 2767
2778void 2768void
2779set_sampler (OpenCL::Kernel self, cl_uint idx, OpenCL::Sampler value) 2769set_sampler (OpenCL::Kernel self, cl_uint idx, OpenCL::Sampler value)
… …
2825 PPCODE: 2815 PPCODE:
2826 cl_context value [1]; 2816 cl_context value [1];
2827 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_CONTEXT, sizeof (value), value, 0)); 2817 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_CONTEXT, sizeof (value), value, 0));
2828 EXTEND (SP, 1); 2818 EXTEND (SP, 1);
2829 const int i = 0; 2819 const int i = 0;
2830 {
2831 NEED_SUCCESS (RetainContext, (value [i])); 2820 NEED_SUCCESS (RetainContext, (value [i]));
2832 PUSH_CLOBJ (stash_context, value [i]); 2821 PUSH_CLOBJ (stash_context, value [i]);
2833 }
2834 2822
2835void 2823void
2836program (OpenCL::Kernel self) 2824program (OpenCL::Kernel self)
2837 PPCODE: 2825 PPCODE:
2838 cl_program value [1]; 2826 cl_program value [1];
2839 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_PROGRAM, sizeof (value), value, 0)); 2827 NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_PROGRAM, sizeof (value), value, 0));
2840 EXTEND (SP, 1); 2828 EXTEND (SP, 1);
2841 const int i = 0; 2829 const int i = 0;
2842 {
2843 NEED_SUCCESS (RetainProgram, (value [i])); 2830 NEED_SUCCESS (RetainProgram, (value [i]));
2844 PUSH_CLOBJ (stash_program, value [i]); 2831 PUSH_CLOBJ (stash_program, value [i]);
2845 }
2846 2832
2847#END:kernel 2833#END:kernel
2848 2834
2849void 2835void
2850work_group_info (OpenCL::Kernel self, OpenCL::Device device, cl_kernel_work_group_info name) 2836work_group_info (OpenCL::Kernel self, OpenCL::Device device, cl_kernel_work_group_info name)
… …
2914 2900
2915#BEGIN:kernel_arg 2901#BEGIN:kernel_arg
2916 2902
2917void 2903void
2918arg_address_qualifier (OpenCL::Kernel self, cl_uint idx) 2904arg_address_qualifier (OpenCL::Kernel self, cl_uint idx)
2905 ALIAS:
2906 arg_address_qualifier = CL_KERNEL_ARG_ADDRESS_QUALIFIER
2907 arg_access_qualifier = CL_KERNEL_ARG_ACCESS_QUALIFIER
2919 PPCODE: 2908 PPCODE:
2920 cl_kernel_arg_address_qualifier value [1]; 2909 cl_uint value [1];
2921 NEED_SUCCESS (GetKernelArgInfo, (self, idx, CL_KERNEL_ARG_ADDRESS_QUALIFIER, sizeof (value), value, 0));
2922 EXTEND (SP, 1);
2923 const int i = 0;
2924 PUSHs (sv_2mortal (newSVuv (value [i])));
2925
2926void
2927arg_access_qualifier (OpenCL::Kernel self, cl_uint idx)
2928 PPCODE:
2929 cl_kernel_arg_access_qualifier value [1];
2930 NEED_SUCCESS (GetKernelArgInfo, (self, idx, CL_KERNEL_ARG_ACCESS_QUALIFIER, sizeof (value), value, 0)); 2910 NEED_SUCCESS (GetKernelArgInfo, (self, idx, ix, sizeof (value), value, 0));
2931 EXTEND (SP, 1); 2911 EXTEND (SP, 1);
2932 const int i = 0; 2912 const int i = 0;
2933 PUSHs (sv_2mortal (newSVuv (value [i]))); 2913 PUSHs (sv_2mortal (newSVuv (value [i])));
2934 2914
2935void 2915void
… …
2947 PUSHs (sv_2mortal (newSVpv (value, 0))); 2927 PUSHs (sv_2mortal (newSVpv (value, 0)));
2948 2928
2949void 2929void
2950arg_type_qualifier (OpenCL::Kernel self, cl_uint idx) 2930arg_type_qualifier (OpenCL::Kernel self, cl_uint idx)
2951 PPCODE: 2931 PPCODE:
2952 cl_kernel_arg_type_qualifier value [1]; 2932 cl_ulong value [1];
2953 NEED_SUCCESS (GetKernelArgInfo, (self, idx, CL_KERNEL_ARG_TYPE_QUALIFIER, sizeof (value), value, 0)); 2933 NEED_SUCCESS (GetKernelArgInfo, (self, idx, CL_KERNEL_ARG_TYPE_QUALIFIER, sizeof (value), value, 0));
2954 EXTEND (SP, 1); 2934 EXTEND (SP, 1);
2955 const int i = 0; 2935 const int i = 0;
2956 PUSHs (sv_2mortal (newSVuv (value [i]))); 2936 PUSHs (sv_2mortal (newSVuv (value [i])));
2957 2937
… …
2988 PPCODE: 2968 PPCODE:
2989 cl_command_queue value [1]; 2969 cl_command_queue value [1];
2990 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_QUEUE, sizeof (value), value, 0)); 2970 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_QUEUE, sizeof (value), value, 0));
2991 EXTEND (SP, 1); 2971 EXTEND (SP, 1);
2992 const int i = 0; 2972 const int i = 0;
2993 {
2994 NEED_SUCCESS (RetainCommandQueue, (value [i])); 2973 NEED_SUCCESS (RetainCommandQueue, (value [i]));
2995 PUSH_CLOBJ (stash_queue, value [i]); 2974 PUSH_CLOBJ (stash_queue, value [i]);
2996 }
2997 2975
2998void 2976void
2999command_type (OpenCL::Event self) 2977command_type (OpenCL::Event self)
3000 PPCODE:
3001 cl_command_type value [1];
3002 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_TYPE, sizeof (value), value, 0));
3003 EXTEND (SP, 1);
3004 const int i = 0;
3005 PUSHs (sv_2mortal (newSVuv (value [i])));
3006
3007void
3008reference_count (OpenCL::Event self)
3009 ALIAS: 2978 ALIAS:
2979 command_type = CL_EVENT_COMMAND_TYPE
3010 reference_count = CL_EVENT_REFERENCE_COUNT 2980 reference_count = CL_EVENT_REFERENCE_COUNT
3011 command_execution_status = CL_EVENT_COMMAND_EXECUTION_STATUS 2981 command_execution_status = CL_EVENT_COMMAND_EXECUTION_STATUS
3012 PPCODE: 2982 PPCODE:
3013 cl_uint value [1]; 2983 cl_uint value [1];
3014 NEED_SUCCESS (GetEventInfo, (self, ix, sizeof (value), value, 0)); 2984 NEED_SUCCESS (GetEventInfo, (self, ix, sizeof (value), value, 0));
… …
3021 PPCODE: 2991 PPCODE:
3022 cl_context value [1]; 2992 cl_context value [1];
3023 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_CONTEXT, sizeof (value), value, 0)); 2993 NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_CONTEXT, sizeof (value), value, 0));
3024 EXTEND (SP, 1); 2994 EXTEND (SP, 1);
3025 const int i = 0; 2995 const int i = 0;
3026 {
3027 NEED_SUCCESS (RetainContext, (value [i])); 2996 NEED_SUCCESS (RetainContext, (value [i]));
3028 PUSH_CLOBJ (stash_context, value [i]); 2997 PUSH_CLOBJ (stash_context, value [i]);
3029 }
3030 2998
3031#END:event 2999#END:event
3032 3000
3033void 3001void
3034profiling_info (OpenCL::Event self, cl_profiling_info name) 3002profiling_info (OpenCL::Event self, cl_profiling_info name)
… …
3075 Safefree (mapped); 3043 Safefree (mapped);
3076 3044
3077void 3045void
3078unmap (OpenCL::Mapped self, ...) 3046unmap (OpenCL::Mapped self, ...)
3079 CODE: 3047 CODE:
3080 mapped_unmap (ST (0), self, self->queue, &ST (1), items - 1); 3048 mapped_unmap (cv, ST (0), self, self->queue, &ST (1), items - 1);
3081 3049
3082bool 3050bool
3083mapped (OpenCL::Mapped self) 3051mapped (OpenCL::Mapped self)
3084 CODE: 3052 CODE:
3085 RETVAL = !!self->ptr; 3053 RETVAL = !!self->ptr;
… …
3099 XSRETURN_UNDEF; 3067 XSRETURN_UNDEF;
3100 3068
3101 clRetainEvent (self->event); 3069 clRetainEvent (self->event);
3102 XPUSH_CLOBJ (stash_event, self->event); 3070 XPUSH_CLOBJ (stash_event, self->event);
3103 3071
3104size_t 3072#define MAPPED_OFFSET_CB offsetof (struct mapped, cb)
3073#define MAPPED_OFFSET_ROW_PITCH offsetof (struct mapped, row_pitch)
3074#define MAPPED_OFFSET_SLICE_PITCH offsetof (struct mapped, slice_pitch)
3075#define MAPPED_OFFSET_WIDTH offsetof (struct mapped, width)
3076#define MAPPED_OFFSET_HEIGHT offsetof (struct mapped, height)
3077#define MAPPED_OFFSET_DEPTH offsetof (struct mapped, depth)
3078
3079IV
3105size (OpenCL::Mapped self) 3080size (OpenCL::Mapped self)
3081 ALIAS:
3082 size = MAPPED_OFFSET_CB
3083 row_pitch = MAPPED_OFFSET_ROW_PITCH
3084 slice_pitch = MAPPED_OFFSET_SLICE_PITCH
3085 width = MAPPED_OFFSET_WIDTH
3086 height = MAPPED_OFFSET_HEIGHT
3087 depth = MAPPED_OFFSET_DEPTH
3106 CODE: 3088 CODE:
3107 RETVAL = self->cb; 3089 RETVAL = *(size_t *)((char *)self + ix);
3108 OUTPUT: 3090 OUTPUT:
3109 RETVAL 3091 RETVAL
3110 3092
3111IV 3093IV
3112ptr (OpenCL::Mapped self) 3094ptr (OpenCL::Mapped self)
… …
3124 if (offset + len > self->cb) 3106 if (offset + len > self->cb)
3125 croak ("OpenCL::Mapped::set out of bound condition detected"); 3107 croak ("OpenCL::Mapped::set out of bound condition detected");
3126 3108
3127 memcpy (offset + (char *)self->ptr, ptr, len); 3109 memcpy (offset + (char *)self->ptr, ptr, len);
3128 3110
3111void
3112get_row (OpenCL::Mapped self, size_t count, size_t x = 0, size_t y = 0, size_t z = 0)
3113 PPCODE:
3114 if (!SvOK (ST (1)))
3115 count = self->width - x;
3116
3117 if (x + count > self->width)
3118 croak ("OpenCL::Mapped::get: x + count crosses a row boundary");
3119
3120 if (y >= self->height)
3121 croak ("OpenCL::Mapped::get: y coordinate out of bounds");
3122
3123 if (z >= self->depth)
3124 croak ("OpenCL::Mapped::get: z coordinate out of bounds");
3125
3126 size_t element = mapped_element_size (self);
3127
3128 count *= element;
3129 x *= element;
3130
3131 char *ptr = (char *)self->ptr + x + y * self->row_pitch + z * self->slice_pitch;
3132 XPUSHs (sv_2mortal (newSVpvn (ptr, count)));
3133
3134void
3135set_row (OpenCL::Mapped self, SV *data, size_t x = 0, size_t y = 0, size_t z = 0)
3136 PPCODE:
3137 STRLEN count;
3138 char *dataptr = SvPVbyte (data, count);
3139 size_t element = mapped_element_size (self);
3140
3141 x *= element;
3142
3143 if (x + count > self->width * element)
3144 croak ("OpenCL::Mapped::set: x + data size crosses a row boundary");
3145
3146 if (y >= self->height)
3147 croak ("OpenCL::Mapped::set: y coordinate out of bounds");
3148
3149 if (z >= self->depth)
3150 croak ("OpenCL::Mapped::set: z coordinate out of bounds");
3151
3152 char *ptr = (char *)self->ptr + x + y * self->row_pitch + z * self->slice_pitch;
3153 memcpy (ptr, dataptr, count);
3154
3129MODULE = OpenCL PACKAGE = OpenCL::MappedBuffer 3155MODULE = OpenCL PACKAGE = OpenCL::MappedBuffer
3130 3156
3131MODULE = OpenCL PACKAGE = OpenCL::MappedImage 3157MODULE = OpenCL PACKAGE = OpenCL::MappedImage
3132 3158
3133IV 3159IV
3134row_pitch (OpenCL::Mapped self) 3160element_size (OpenCL::Mapped self)
3135 ALIAS:
3136 slice_pitch = 1
3137 CODE: 3161 CODE:
3138 RETVAL = ix ? self->slice_pitch : self->row_pitch; 3162 RETVAL = mapped_element_size (self);
3139 OUTPUT: 3163 OUTPUT:
3140 RETVAL 3164 RETVAL
3141 3165
3142
3143

Diff Legend

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