← Back to branch summary

~ubuntu-branches/ubuntu/wily/pyopencl/wily

« back to all changes in this revision

Viewing changes to src/wrapper/wrap_constants.cpp

  • Committer: Package Import Robot
  • Author(s): Tomasz Rybak
  • Date: 2012-06-21 21:18:03 UTC
  • mfrom: (2.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20120621211803-424gma7uil7lje4u
* New upstream release.
* Depend on free ocl-icd-libopencl1 instead of non-free libraries.
* Add NEWS entry describing OpenCL library dependencies.
* Change my email.
* Move python-pyopengl from Recommends to Suggests because package
  can be used for computations without any graphical environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/wrapper/wrap_constants.cpp
22
22
  void translate_cl_error(const error &err)
23
23
  {
24
24
    if (err.code() == CL_MEM_OBJECT_ALLOCATION_FAILURE)
25
 
      PyErr_SetString(CLMemoryError.get(), err.what());
 
25
      PyErr_SetObject(CLMemoryError.get(), py::object(err).ptr());
26
26
    else if (err.code() <= CL_INVALID_VALUE)
27
 
      PyErr_SetString(CLLogicError.get(), err.what());
 
27
      PyErr_SetObject(CLLogicError.get(), py::object(err).ptr());
28
28
    else if (err.code() > CL_INVALID_VALUE && err.code() < CL_SUCCESS)
29
 
      PyErr_SetString(CLRuntimeError.get(), err.what());
 
29
      PyErr_SetObject(CLRuntimeError.get(), py::object(err).ptr());
30
30
    else
31
 
      PyErr_SetString(CLError.get(), err.what());
 
31
      PyErr_SetObject(CLError.get(), py::object(err).ptr());
32
32
  }
33
33
 
34
34
 
35
35
 
36
36
 
37
37
  // {{{ 'fake' constant scopes
 
38
  class status_code { };
38
39
  class platform_info { };
39
40
  class device_type { };
40
41
  class device_info { };
59
60
  class map_flags { };
60
61
  class program_info { };
61
62
  class program_build_info { };
 
63
  class program_binary_type { };
62
64
  class build_status { };
63
65
  class kernel_info { };
 
66
  class kernel_arg_info { };
 
67
  class kernel_arg_address_qualifier { };
 
68
  class kernel_arg_access_qualifier { };
64
69
  class kernel_work_group_info { };
65
70
  class event_info { };
66
71
  class command_type { };
67
72
  class command_execution_status { };
68
73
  class profiling_info { };
69
74
  class buffer_create_type { };
 
75
  class mem_migration_flags { };
 
76
 
 
77
  class device_partition_property { };
 
78
  class device_affinity_domain { };
 
79
 
 
80
  class device_partition_property_ext { };
 
81
  class affinity_domain_ext { };
70
82
 
71
83
  class gl_object_type { };
72
84
  class gl_texture_info { };
 
85
 
 
86
  class migrate_mem_object_flags_ext {};
73
87
  // }}}
74
88
}
75
89
 
89
103
        CLError,
90
104
        py::handle<>(py::borrowed(PyExc_MemoryError)));
91
105
    DECLARE_EXC(MemoryError, memerr_bases.ptr());
92
 
    DECLARE_EXC(LogicError, CLLogicError.get());
 
106
    DECLARE_EXC(LogicError, CLError.get());
93
107
    DECLARE_EXC(RuntimeError, CLError.get());
94
108
 
95
109
    py::register_exception_translator<error>(translate_cl_error);
99
113
  // {{{ constants
100
114
#define ADD_ATTR(PREFIX, NAME) \
101
115
  cls.attr(#NAME) = CL_##PREFIX##NAME
 
116
#define ADD_ATTR_SUFFIX(PREFIX, NAME, SUFFIX) \
 
117
  cls.attr(#NAME) = CL_##PREFIX##NAME##SUFFIX
 
118
 
 
119
  {
 
120
    typedef error cls;
 
121
    py::class_<error> ("_error", py::no_init)
 
122
      .DEF_SIMPLE_METHOD(routine)
 
123
      .DEF_SIMPLE_METHOD(code)
 
124
      .DEF_SIMPLE_METHOD(what)
 
125
      ;
 
126
  }
 
127
 
 
128
  {
 
129
    py::class_<status_code> cls("status_code", py::no_init);
 
130
 
 
131
    ADD_ATTR(, SUCCESS);
 
132
    ADD_ATTR(, DEVICE_NOT_FOUND);
 
133
    ADD_ATTR(, DEVICE_NOT_AVAILABLE);
 
134
#if !(defined(CL_PLATFORM_NVIDIA) && CL_PLATFORM_NVIDIA == 0x3001)
 
135
    ADD_ATTR(, COMPILER_NOT_AVAILABLE);
 
136
#endif
 
137
    ADD_ATTR(, MEM_OBJECT_ALLOCATION_FAILURE);
 
138
    ADD_ATTR(, OUT_OF_RESOURCES);
 
139
    ADD_ATTR(, OUT_OF_HOST_MEMORY);
 
140
    ADD_ATTR(, PROFILING_INFO_NOT_AVAILABLE);
 
141
    ADD_ATTR(, MEM_COPY_OVERLAP);
 
142
    ADD_ATTR(, IMAGE_FORMAT_MISMATCH);
 
143
    ADD_ATTR(, IMAGE_FORMAT_NOT_SUPPORTED);
 
144
    ADD_ATTR(, BUILD_PROGRAM_FAILURE);
 
145
    ADD_ATTR(, MAP_FAILURE);
 
146
 
 
147
    ADD_ATTR(, INVALID_VALUE);
 
148
    ADD_ATTR(, INVALID_DEVICE_TYPE);
 
149
    ADD_ATTR(, INVALID_PLATFORM);
 
150
    ADD_ATTR(, INVALID_DEVICE);
 
151
    ADD_ATTR(, INVALID_CONTEXT);
 
152
    ADD_ATTR(, INVALID_QUEUE_PROPERTIES);
 
153
    ADD_ATTR(, INVALID_COMMAND_QUEUE);
 
154
    ADD_ATTR(, INVALID_HOST_PTR);
 
155
    ADD_ATTR(, INVALID_MEM_OBJECT);
 
156
    ADD_ATTR(, INVALID_IMAGE_FORMAT_DESCRIPTOR);
 
157
    ADD_ATTR(, INVALID_IMAGE_SIZE);
 
158
    ADD_ATTR(, INVALID_SAMPLER);
 
159
    ADD_ATTR(, INVALID_BINARY);
 
160
    ADD_ATTR(, INVALID_BUILD_OPTIONS);
 
161
    ADD_ATTR(, INVALID_PROGRAM);
 
162
    ADD_ATTR(, INVALID_PROGRAM_EXECUTABLE);
 
163
    ADD_ATTR(, INVALID_KERNEL_NAME);
 
164
    ADD_ATTR(, INVALID_KERNEL_DEFINITION);
 
165
    ADD_ATTR(, INVALID_KERNEL);
 
166
    ADD_ATTR(, INVALID_ARG_INDEX);
 
167
    ADD_ATTR(, INVALID_ARG_VALUE);
 
168
    ADD_ATTR(, INVALID_ARG_SIZE);
 
169
    ADD_ATTR(, INVALID_KERNEL_ARGS);
 
170
    ADD_ATTR(, INVALID_WORK_DIMENSION);
 
171
    ADD_ATTR(, INVALID_WORK_GROUP_SIZE);
 
172
    ADD_ATTR(, INVALID_WORK_ITEM_SIZE);
 
173
    ADD_ATTR(, INVALID_GLOBAL_OFFSET);
 
174
    ADD_ATTR(, INVALID_EVENT_WAIT_LIST);
 
175
    ADD_ATTR(, INVALID_EVENT);
 
176
    ADD_ATTR(, INVALID_OPERATION);
 
177
    ADD_ATTR(, INVALID_GL_OBJECT);
 
178
    ADD_ATTR(, INVALID_BUFFER_SIZE);
 
179
    ADD_ATTR(, INVALID_MIP_LEVEL);
 
180
 
 
181
#if defined(cl_khr_icd) && (cl_khr_icd >= 1)
 
182
    ADD_ATTR(, PLATFORM_NOT_FOUND_KHR);
 
183
#endif
 
184
 
 
185
#if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1)
 
186
    ADD_ATTR(, INVALID_GL_SHAREGROUP_REFERENCE_KHR);
 
187
#endif
 
188
 
 
189
#if PYOPENCL_CL_VERSION >= 0x1010
 
190
    ADD_ATTR(, MISALIGNED_SUB_BUFFER_OFFSET);
 
191
    ADD_ATTR(, EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
 
192
    ADD_ATTR(, INVALID_GLOBAL_WORK_SIZE);
 
193
#endif
 
194
 
 
195
#if PYOPENCL_CL_VERSION >= 0x1020
 
196
    ADD_ATTR(, COMPILE_PROGRAM_FAILURE);
 
197
    ADD_ATTR(, LINKER_NOT_AVAILABLE);
 
198
    ADD_ATTR(, LINK_PROGRAM_FAILURE);
 
199
    ADD_ATTR(, DEVICE_PARTITION_FAILED);
 
200
    ADD_ATTR(, KERNEL_ARG_INFO_NOT_AVAILABLE);
 
201
    ADD_ATTR(, INVALID_IMAGE_DESCRIPTOR);
 
202
    ADD_ATTR(, INVALID_COMPILER_OPTIONS);
 
203
    ADD_ATTR(, INVALID_LINKER_OPTIONS);
 
204
    ADD_ATTR(, INVALID_DEVICE_PARTITION_COUNT);
 
205
#endif
 
206
 
 
207
#if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION)
 
208
    ADD_ATTR(, DEVICE_PARTITION_FAILED_EXT);
 
209
    ADD_ATTR(, INVALID_PARTITION_COUNT_EXT);
 
210
    ADD_ATTR(, INVALID_PARTITION_NAME_EXT);
 
211
#endif
 
212
  }
102
213
 
103
214
  {
104
215
    py::class_<platform_info> cls("platform_info", py::no_init);
117
228
    ADD_ATTR(DEVICE_TYPE_, CPU);
118
229
    ADD_ATTR(DEVICE_TYPE_, GPU);
119
230
    ADD_ATTR(DEVICE_TYPE_, ACCELERATOR);
 
231
#if PYOPENCL_CL_VERSION >= 0x1020
 
232
    ADD_ATTR(DEVICE_TYPE_, CUSTOM);
 
233
#endif
120
234
    ADD_ATTR(DEVICE_TYPE_, ALL);
121
235
  }
122
236
 
150
264
    ADD_ATTR(DEVICE_, MEM_BASE_ADDR_ALIGN);
151
265
    ADD_ATTR(DEVICE_, MIN_DATA_TYPE_ALIGN_SIZE);
152
266
    ADD_ATTR(DEVICE_, SINGLE_FP_CONFIG);
 
267
#ifdef CL_DEVICE_DOUBLE_FP_CONFIG
 
268
    ADD_ATTR(DEVICE_, DOUBLE_FP_CONFIG);
 
269
#endif
 
270
#ifdef CL_DEVICE_HALF_FP_CONFIG
 
271
    ADD_ATTR(DEVICE_, HALF_FP_CONFIG);
 
272
#endif
153
273
    ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_TYPE);
154
274
    ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHELINE_SIZE);
155
275
    ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_SIZE);
173
293
    ADD_ATTR(DEVICE_, VERSION);
174
294
    ADD_ATTR(DEVICE_, EXTENSIONS);
175
295
    ADD_ATTR(DEVICE_, PLATFORM);
176
 
#ifdef CL_VERSION_1_1
 
296
#if PYOPENCL_CL_VERSION >= 0x1010
177
297
    ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_HALF);
178
298
    ADD_ATTR(DEVICE_, HOST_UNIFIED_MEMORY);
179
299
    ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_CHAR);
195
315
    ADD_ATTR(DEVICE_, KERNEL_EXEC_TIMEOUT_NV);
196
316
    ADD_ATTR(DEVICE_, INTEGRATED_MEMORY_NV);
197
317
#endif
 
318
// cl_amd_device_attribute_query
 
319
#ifdef CL_DEVICE_PROFILING_TIMER_OFFSET_AMD
 
320
    ADD_ATTR(DEVICE_, PROFILING_TIMER_OFFSET_AMD);
 
321
#endif
 
322
#if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION)
 
323
    ADD_ATTR(DEVICE_, PARENT_DEVICE_EXT);
 
324
    ADD_ATTR(DEVICE_, PARTITION_TYPES_EXT);
 
325
    ADD_ATTR(DEVICE_, AFFINITY_DOMAINS_EXT);
 
326
    ADD_ATTR(DEVICE_, REFERENCE_COUNT_EXT);
 
327
    ADD_ATTR(DEVICE_, PARTITION_STYLE_EXT);
 
328
#endif
 
329
#if PYOPENCL_CL_VERSION >= 0x1020
 
330
    ADD_ATTR(DEVICE_, LINKER_AVAILABLE);
 
331
    ADD_ATTR(DEVICE_, BUILT_IN_KERNELS);
 
332
    ADD_ATTR(DEVICE_, IMAGE_MAX_BUFFER_SIZE);
 
333
    ADD_ATTR(DEVICE_, IMAGE_MAX_ARRAY_SIZE);
 
334
    ADD_ATTR(DEVICE_, PARENT_DEVICE);
 
335
    ADD_ATTR(DEVICE_, PARTITION_MAX_SUB_DEVICES);
 
336
    ADD_ATTR(DEVICE_, PARTITION_PROPERTIES);
 
337
    ADD_ATTR(DEVICE_, PARTITION_AFFINITY_DOMAIN);
 
338
    ADD_ATTR(DEVICE_, PARTITION_TYPE);
 
339
    ADD_ATTR(DEVICE_, REFERENCE_COUNT);
 
340
    ADD_ATTR(DEVICE_, PREFERRED_INTEROP_USER_SYNC);
 
341
    ADD_ATTR(DEVICE_, PRINTF_BUFFER_SIZE);
 
342
#endif
198
343
  }
199
344
 
200
345
  {
205
350
    ADD_ATTR(FP_, ROUND_TO_ZERO);
206
351
    ADD_ATTR(FP_, ROUND_TO_INF);
207
352
    ADD_ATTR(FP_, FMA);
208
 
#ifdef CL_VERSION_1_1
 
353
#if PYOPENCL_CL_VERSION >= 0x1010
209
354
    ADD_ATTR(FP_, SOFT_FLOAT);
210
355
#endif
 
356
#if PYOPENCL_CL_VERSION >= 0x1020
 
357
    ADD_ATTR(FP_, CORRECTLY_ROUNDED_DIVIDE_SQRT);
 
358
#endif
211
359
  }
212
360
 
213
361
  {
227
375
    py::class_<device_exec_capabilities> cls("device_exec_capabilities", py::no_init);
228
376
    ADD_ATTR(EXEC_, KERNEL);
229
377
    ADD_ATTR(EXEC_, NATIVE_KERNEL);
 
378
#ifdef CL_EXEC_IMMEDIATE_EXECUTION_INTEL
 
379
    ADD_ATTR(EXEC_, IMMEDIATE_EXECUTION_INTEL);
 
380
#endif
230
381
  }
231
382
 
232
383
  {
233
384
    py::class_<command_queue_properties> cls("command_queue_properties", py::no_init);
234
385
    ADD_ATTR(QUEUE_, OUT_OF_ORDER_EXEC_MODE_ENABLE);
235
386
    ADD_ATTR(QUEUE_, PROFILING_ENABLE);
 
387
#ifdef CL_QUEUE_IMMEDIATE_EXECUTION_ENABLE_INTEL
 
388
    ADD_ATTR(QUEUE_, IMMEDIATE_EXECUTION_ENABLE_INTEL);
 
389
#endif
236
390
  }
237
391
 
238
392
  {
240
394
    ADD_ATTR(CONTEXT_, REFERENCE_COUNT);
241
395
    ADD_ATTR(CONTEXT_, DEVICES);
242
396
    ADD_ATTR(CONTEXT_, PROPERTIES);
243
 
#ifdef CL_VERSION_1_1
 
397
#if PYOPENCL_CL_VERSION >= 0x1010
244
398
    ADD_ATTR(CONTEXT_, NUM_DEVICES);
245
399
#endif
 
400
#if PYOPENCL_CL_VERSION >= 0x1020
 
401
    ADD_ATTR(CONTEXT_, INTEROP_USER_SYNC);
 
402
#endif
246
403
  }
247
404
 
248
405
  {
263
420
    ADD_ATTR( ,WGL_HDC_KHR);
264
421
    ADD_ATTR( ,CGL_SHAREGROUP_KHR);
265
422
#endif
 
423
#if defined(__APPLE__) && defined(HAVE_GL)
 
424
    ADD_ATTR( ,CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE);
 
425
#endif /* __APPLE__ */
 
426
// cl_amd_offline_devices
 
427
#ifdef CL_CONTEXT_OFFLINE_DEVICES_AMD
 
428
    ADD_ATTR(CONTEXT_, OFFLINE_DEVICES_AMD);
 
429
#endif
266
430
  }
267
431
 
268
432
  {
281
445
    ADD_ATTR(MEM_, USE_HOST_PTR);
282
446
    ADD_ATTR(MEM_, ALLOC_HOST_PTR);
283
447
    ADD_ATTR(MEM_, COPY_HOST_PTR);
 
448
#ifdef cl_amd_device_memory_flags
 
449
    ADD_ATTR(MEM_, USE_PERSISTENT_MEM_AMD);
 
450
#endif
 
451
#if PYOPENCL_CL_VERSION >= 0x1020
 
452
    ADD_ATTR(MEM_, HOST_WRITE_ONLY);
 
453
    ADD_ATTR(MEM_, HOST_READ_ONLY);
 
454
    ADD_ATTR(MEM_, HOST_NO_ACCESS);
 
455
#endif
284
456
  }
285
457
 
286
458
  {
294
466
    ADD_ATTR( , BGRA);
295
467
    ADD_ATTR( , INTENSITY);
296
468
    ADD_ATTR( , LUMINANCE);
297
 
#ifdef CL_VERSION_1_1
 
469
#if PYOPENCL_CL_VERSION >= 0x1010
298
470
    ADD_ATTR( , Rx);
299
471
    ADD_ATTR( , RGx);
300
472
    ADD_ATTR( , RGBx);
325
497
    ADD_ATTR(MEM_OBJECT_, BUFFER);
326
498
    ADD_ATTR(MEM_OBJECT_, IMAGE2D);
327
499
    ADD_ATTR(MEM_OBJECT_, IMAGE3D);
 
500
#if PYOPENCL_CL_VERSION >= 0x1020
 
501
    ADD_ATTR(MEM_OBJECT_, IMAGE2D_ARRAY);
 
502
    ADD_ATTR(MEM_OBJECT_, IMAGE1D);
 
503
    ADD_ATTR(MEM_OBJECT_, IMAGE1D_ARRAY);
 
504
    ADD_ATTR(MEM_OBJECT_, IMAGE1D_BUFFER);
 
505
#endif
328
506
  }
329
507
 
330
508
  {
336
514
    ADD_ATTR(MEM_, MAP_COUNT);
337
515
    ADD_ATTR(MEM_, REFERENCE_COUNT);
338
516
    ADD_ATTR(MEM_, CONTEXT);
339
 
#ifdef CL_VERSION_1_1
 
517
#if PYOPENCL_CL_VERSION >= 0x1010
340
518
    ADD_ATTR(MEM_, ASSOCIATED_MEMOBJECT);
341
519
    ADD_ATTR(MEM_, OFFSET);
342
520
#endif
351
529
    ADD_ATTR(IMAGE_, WIDTH);
352
530
    ADD_ATTR(IMAGE_, HEIGHT);
353
531
    ADD_ATTR(IMAGE_, DEPTH);
 
532
#if PYOPENCL_CL_VERSION >= 0x1020
 
533
    ADD_ATTR(IMAGE_, ARRAY_SIZE);
 
534
    ADD_ATTR(IMAGE_, BUFFER);
 
535
    ADD_ATTR(IMAGE_, NUM_MIP_LEVELS);
 
536
    ADD_ATTR(IMAGE_, NUM_SAMPLES);
 
537
#endif
354
538
  }
355
539
 
356
540
  {
359
543
    ADD_ATTR(ADDRESS_, CLAMP_TO_EDGE);
360
544
    ADD_ATTR(ADDRESS_, CLAMP);
361
545
    ADD_ATTR(ADDRESS_, REPEAT);
362
 
#ifdef CL_VERSION_1_1
 
546
#if PYOPENCL_CL_VERSION >= 0x1010
363
547
    ADD_ATTR(ADDRESS_, MIRRORED_REPEAT);
364
548
#endif
365
549
  }
383
567
    py::class_<map_flags> cls("map_flags", py::no_init);
384
568
    ADD_ATTR(MAP_, READ);
385
569
    ADD_ATTR(MAP_, WRITE);
 
570
#if PYOPENCL_CL_VERSION >= 0x1020
 
571
    ADD_ATTR(MAP_, WRITE_INVALIDATE_REGION);
 
572
#endif
386
573
  }
387
574
 
388
575
  {
394
581
    ADD_ATTR(PROGRAM_, SOURCE);
395
582
    ADD_ATTR(PROGRAM_, BINARY_SIZES);
396
583
    ADD_ATTR(PROGRAM_, BINARIES);
 
584
#if PYOPENCL_CL_VERSION >= 0x1020
 
585
    ADD_ATTR(PROGRAM_, NUM_KERNELS);
 
586
    ADD_ATTR(PROGRAM_, KERNEL_NAMES);
 
587
#endif
397
588
  }
398
589
 
399
590
  {
401
592
    ADD_ATTR(PROGRAM_BUILD_, STATUS);
402
593
    ADD_ATTR(PROGRAM_BUILD_, OPTIONS);
403
594
    ADD_ATTR(PROGRAM_BUILD_, LOG);
 
595
#if PYOPENCL_CL_VERSION >= 0x1020
 
596
    ADD_ATTR(PROGRAM_, BINARY_TYPE);
 
597
#endif
 
598
  }
 
599
 
 
600
  {
 
601
    py::class_<program_binary_type> cls("program_binary_type", py::no_init);
 
602
#if PYOPENCL_CL_VERSION >= 0x1020
 
603
    ADD_ATTR(PROGRAM_BINARY_TYPE_, NONE);
 
604
    ADD_ATTR(PROGRAM_BINARY_TYPE_, COMPILED_OBJECT);
 
605
    ADD_ATTR(PROGRAM_BINARY_TYPE_, LIBRARY);
 
606
    ADD_ATTR(PROGRAM_BINARY_TYPE_, EXECUTABLE);
 
607
#endif
404
608
  }
405
609
 
406
610
  {
410
614
    ADD_ATTR(KERNEL_, REFERENCE_COUNT);
411
615
    ADD_ATTR(KERNEL_, CONTEXT);
412
616
    ADD_ATTR(KERNEL_, PROGRAM);
 
617
#if PYOPENCL_CL_VERSION >= 0x1020
 
618
    ADD_ATTR(KERNEL_, ATTRIBUTES);
 
619
#endif
 
620
  }
 
621
 
 
622
  {
 
623
    py::class_<kernel_arg_info> cls("kernel_arg_info", py::no_init);
 
624
#if PYOPENCL_CL_VERSION >= 0x1020
 
625
    ADD_ATTR(KERNEL_ARG_, ADDRESS_QUALIFIER);
 
626
    ADD_ATTR(KERNEL_ARG_, ACCESS_QUALIFIER);
 
627
    ADD_ATTR(KERNEL_ARG_, TYPE_NAME);
 
628
    ADD_ATTR(KERNEL_ARG_, NAME);
 
629
#endif
 
630
  }
 
631
 
 
632
  {
 
633
    py::class_<kernel_arg_address_qualifier> cls(
 
634
        "kernel_arg_address_qualifier", py::no_init);
 
635
#if PYOPENCL_CL_VERSION >= 0x1020
 
636
    ADD_ATTR(KERNEL_ARG_ADDRESS_, GLOBAL);
 
637
    ADD_ATTR(KERNEL_ARG_ADDRESS_, LOCAL);
 
638
    ADD_ATTR(KERNEL_ARG_ADDRESS_, CONSTANT);
 
639
    ADD_ATTR(KERNEL_ARG_ADDRESS_, PRIVATE);
 
640
#endif
 
641
  }
 
642
 
 
643
  {
 
644
    py::class_<kernel_arg_access_qualifier> cls(
 
645
        "kernel_arg_access_qualifier", py::no_init);
 
646
#if PYOPENCL_CL_VERSION >= 0x1020
 
647
    ADD_ATTR(KERNEL_ARG_ACCESS_, READ_ONLY);
 
648
    ADD_ATTR(KERNEL_ARG_ACCESS_, WRITE_ONLY);
 
649
    ADD_ATTR(KERNEL_ARG_ACCESS_, READ_WRITE);
 
650
    ADD_ATTR(KERNEL_ARG_ACCESS_, NONE);
 
651
#endif
413
652
  }
414
653
 
415
654
  {
417
656
    ADD_ATTR(KERNEL_, WORK_GROUP_SIZE);
418
657
    ADD_ATTR(KERNEL_, COMPILE_WORK_GROUP_SIZE);
419
658
    ADD_ATTR(KERNEL_, LOCAL_MEM_SIZE);
420
 
#ifdef CL_VERSION_1_1
 
659
#if PYOPENCL_CL_VERSION >= 0x1010
421
660
    ADD_ATTR(KERNEL_, PREFERRED_WORK_GROUP_SIZE_MULTIPLE);
422
661
    ADD_ATTR(KERNEL_, PRIVATE_MEM_SIZE);
423
662
#endif
 
663
#if PYOPENCL_CL_VERSION >= 0x1020
 
664
    ADD_ATTR(KERNEL_, GLOBAL_WORK_SIZE);
 
665
#endif
424
666
  }
425
667
 
426
668
  {
429
671
    ADD_ATTR(EVENT_, COMMAND_TYPE);
430
672
    ADD_ATTR(EVENT_, REFERENCE_COUNT);
431
673
    ADD_ATTR(EVENT_, COMMAND_EXECUTION_STATUS);
432
 
#ifdef CL_VERSION_1_1
 
674
#if PYOPENCL_CL_VERSION >= 0x1010
433
675
    ADD_ATTR(EVENT_, CONTEXT);
434
676
#endif
435
677
  }
453
695
    ADD_ATTR(COMMAND_, MARKER);
454
696
    ADD_ATTR(COMMAND_, ACQUIRE_GL_OBJECTS);
455
697
    ADD_ATTR(COMMAND_, RELEASE_GL_OBJECTS);
456
 
#ifdef CL_VERSION_1_1
 
698
#if PYOPENCL_CL_VERSION >= 0x1010
457
699
    ADD_ATTR(COMMAND_, READ_BUFFER_RECT);
458
700
    ADD_ATTR(COMMAND_, WRITE_BUFFER_RECT);
459
701
    ADD_ATTR(COMMAND_, COPY_BUFFER_RECT);
460
702
    ADD_ATTR(COMMAND_, USER);
461
703
#endif
 
704
#ifdef cl_ext_migrate_memobject
 
705
    ADD_ATTR(COMMAND_, MIGRATE_MEM_OBJECT_EXT);
 
706
#endif
 
707
#if PYOPENCL_CL_VERSION >= 0x1020
 
708
    ADD_ATTR(COMMAND_, BARRIER);
 
709
    ADD_ATTR(COMMAND_, MIGRATE_MEM_OBJECTS);
 
710
    ADD_ATTR(COMMAND_, FILL_BUFFER);
 
711
    ADD_ATTR(COMMAND_, FILL_IMAGE);
 
712
#endif
462
713
  }
463
714
 
464
715
  {
478
729
  }
479
730
 
480
731
/* not needed--filled in automatically by implementation.
481
 
#ifdef CL_VERSION_1_1
 
732
#if PYOPENCL_CL_VERSION >= 0x1010
482
733
  {
483
734
    py::class_<buffer_create_type> cls("buffer_create_type", py::no_init);
484
735
    ADD_ATTR(BUFFER_CREATE_TYPE_, REGION);
486
737
#endif
487
738
*/
488
739
 
 
740
  {
 
741
    py::class_<mem_migration_flags> cls(
 
742
        "mem_migration_flags", py::no_init);
 
743
#if PYOPENCL_CL_VERSION >= 0x1020
 
744
    ADD_ATTR(MIGRATE_MEM_OBJECT_, HOST);
 
745
    ADD_ATTR(MIGRATE_MEM_OBJECT_, CONTENT_UNDEFINED);
 
746
#endif
 
747
  }
 
748
 
 
749
  {
 
750
    py::class_<device_partition_property_ext> cls(
 
751
        "device_partition_property_ext", py::no_init);
 
752
#if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION)
 
753
    ADD_ATTR_SUFFIX(DEVICE_PARTITION_, EQUALLY, _EXT);
 
754
    ADD_ATTR_SUFFIX(DEVICE_PARTITION_, BY_COUNTS, _EXT);
 
755
    ADD_ATTR_SUFFIX(DEVICE_PARTITION_, BY_NAMES, _EXT);
 
756
    ADD_ATTR_SUFFIX(DEVICE_PARTITION_, BY_AFFINITY_DOMAIN, _EXT);
 
757
    ADD_ATTR_SUFFIX(, PROPERTIES_LIST_END, _EXT);
 
758
    ADD_ATTR_SUFFIX(, PARTITION_BY_COUNTS_LIST_END, _EXT);
 
759
    ADD_ATTR_SUFFIX(, PARTITION_BY_NAMES_LIST_END, _EXT);
 
760
#endif
 
761
  }
 
762
 
 
763
  {
 
764
    py::class_<affinity_domain_ext> cls("affinity_domain_ext", py::no_init);
 
765
#if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION)
 
766
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L1_CACHE, _EXT);
 
767
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L2_CACHE, _EXT);
 
768
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L3_CACHE, _EXT);
 
769
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L4_CACHE, _EXT);
 
770
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, NUMA, _EXT);
 
771
    ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, NEXT_FISSIONABLE, _EXT);
 
772
#endif
 
773
  }
 
774
 
 
775
  {
 
776
    py::class_<device_partition_property> cls(
 
777
        "device_partition_property", py::no_init);
 
778
#if PYOPENCL_CL_VERSION >= 0x1020
 
779
    ADD_ATTR(DEVICE_PARTITION_, EQUALLY);
 
780
    ADD_ATTR(DEVICE_PARTITION_, BY_COUNTS);
 
781
    ADD_ATTR(DEVICE_PARTITION_, BY_COUNTS_LIST_END);
 
782
    ADD_ATTR(DEVICE_PARTITION_, BY_AFFINITY_DOMAIN);
 
783
#endif
 
784
  }
 
785
 
 
786
  {
 
787
    py::class_<device_affinity_domain> cls("device_affinity_domain", py::no_init);
 
788
#if PYOPENCL_CL_VERSION >= 0x1020
 
789
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, NUMA);
 
790
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L4_CACHE);
 
791
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L3_CACHE);
 
792
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L2_CACHE);
 
793
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L1_CACHE);
 
794
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, NEXT_PARTITIONABLE);
 
795
#endif
 
796
  }
 
797
 
489
798
#ifdef HAVE_GL
490
799
  {
491
800
    py::class_<gl_object_type> cls("gl_object_type", py::no_init);
502
811
  }
503
812
#endif
504
813
 
 
814
  {
 
815
    py::class_<migrate_mem_object_flags_ext> cls("migrate_mem_object_flags_ext", py::no_init);
 
816
#ifdef cl_ext_migrate_memobject
 
817
    ADD_ATTR_SUFFIX(MIGRATE_MEM_OBJECT_, HOST, _EXT);
 
818
#endif
 
819
  }
 
820
 
505
821
  // }}}
506
822
}
507
823