opencl-c.h: add 3.0 optional extension support for a few more bits

[airlied]

Summary

These 3 are fairly simple, pipes, workgroups and subgroups.

[Anastasia]

clang/lib/Headers/opencl-c-base.h

329

We had a discussion with @azabaznov around features that are aliasing each other and we have discussed to use one feature macro for those. Clang should already ensure that both are set/unset simultaneously? And for those that are not set in clang we can set them correctly here in the header directly.

clang/lib/Headers/opencl-c.h

15290

I think that here guarding the OpenCL version is correct?

[azabaznov]

clang/lib/Headers/opencl-c-base.h

329

Yeah, I we did. Note that this is applicable to fp64 and 3d image writes, while __openc_c_subgroups and cl_khr_subgroups are not equivalent as extension requires subgroup-independent forward progress but subgroup-independent forward progress is optional in OpenCL C 3.0. I'll try submit a patch for 3d image writes feature macro support this week.

[airlied]

fixed up missing cl_khr_subgroups checks.

[airlied]

leave version checks alone since they are inside the outer extension check.

[airlied]

yeah I agree I'll drop those two changes.

[Anastasia]

clang/lib/Headers/opencl-c-base.h

329

Ok, I see so while the functions are identical they are not entirely equivalent extensions so vendors might support one but not the other? In this case I think we should keep checking both but it would be good to add a comment explaining why we are checking both macros here.

Btw do you happen to have spec reference? I can't find anything relevant.

[airlied]

Added a comment on the subgroups difference.

[Anastasia]

LGTM! Thanks

clang/lib/Headers/opencl-c-base.h

typedef enum memory_scope {
   memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP,
   memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE,
 #if defined(__opencl_c_atomic_scope_all_devices)
   memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
 #if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
   memory_scope_all_devices = memory_scope_all_svm_devices,
 #endif // __OPENCL_C_VERSION__ >= CL_VERSION_3_0
 #endif // defined(__opencl_c_atomic_scope_all_devices)
-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups)
   memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP
 #endif
 } memory_scope;
 
 /**
  * Queue a memory fence to ensure correct ordering of memory
  * operations between work-items of a work-group to
  * image memory.

 
 #define kernel_exec(X, typen) __kernel \
   __attribute__((work_group_size_hint(X, 1, 1))) \
   __attribute__((vec_type_hint(typen)))
 
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 // OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf
 
 int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));
 #endif
 
 #ifdef cl_intel_device_side_avc_motion_estimation
 
 #define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0
 #define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1
 #define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2
 #define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3

clang/lib/Headers/opencl-c.h

  *
  * The address computed as (p + (offset * n)) must be
  * 8-bit aligned if gentype is char, uchar;
  * 16-bit aligned if gentype is short, ushort, half;
  * 32-bit aligned if gentype is int, uint, float;
  * 64-bit aligned if gentype is long, ulong, double.
  */
 
 char2 __ovld vload2(size_t offset, const __constant char *p);
 uchar2 __ovld vload2(size_t offset, const __constant uchar *p);
 short2 __ovld vload2(size_t offset, const __constant short *p);
 ushort2 __ovld vload2(size_t offset, const __constant ushort *p);
 int2 __ovld vload2(size_t offset, const __constant int *p);
 uint2 __ovld vload2(size_t offset, const __constant uint *p);
 long2 __ovld vload2(size_t offset, const __constant long *p);
 ulong2 __ovld vload2(size_t offset, const __constant ulong *p);
 float2 __ovld vload2(size_t offset, const __constant float *p);
 char3 __ovld vload3(size_t offset, const __constant char *p);
 uchar3 __ovld vload3(size_t offset, const __constant uchar *p);
 short3 __ovld vload3(size_t offset, const __constant short *p);
 ushort3 __ovld vload3(size_t offset, const __constant ushort *p);
 int3 __ovld vload3(size_t offset, const __constant int *p);
 uint3 __ovld vload3(size_t offset, const __constant uint *p);
 long3 __ovld vload3(size_t offset, const __constant long *p);
 ulong3 __ovld vload3(size_t offset, const __constant ulong *p);
 float3 __ovld vload3(size_t offset, const __constant float *p);
 char4 __ovld vload4(size_t offset, const __constant char *p);
 uchar4 __ovld vload4(size_t offset, const __constant uchar *p);

 int __ovld get_image_num_samples(read_write image2d_msaa_depth_t image);
 int __ovld get_image_num_samples(read_write image2d_array_msaa_t image);
 int __ovld get_image_num_samples(read_write image2d_array_msaa_depth_t image);
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 #endif
 
 // OpenCL v2.0 s6.13.15 - Work-group Functions
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_work_group_collective_functions)
 int __ovld __conv work_group_all(int predicate);
 int __ovld __conv work_group_any(int predicate);
 
 #ifdef cl_khr_fp16
 half __ovld __conv work_group_broadcast(half a, size_t local_id);
 half __ovld __conv work_group_broadcast(half a, size_t x, size_t y);
 half __ovld __conv work_group_broadcast(half a, size_t x, size_t y, size_t z);
 #endif

 half __ovld __conv work_group_scan_inclusive_add(half x);
 half __ovld __conv work_group_scan_inclusive_min(half x);
 half __ovld __conv work_group_scan_inclusive_max(half x);
 #endif
 int __ovld __conv work_group_reduce_add(int x);
 int __ovld __conv work_group_reduce_min(int x);
 int __ovld __conv work_group_reduce_max(int x);
 int __ovld __conv work_group_scan_exclusive_add(int x);
 int __ovld __conv work_group_scan_exclusive_min(int x);
 int __ovld __conv work_group_scan_exclusive_max(int x);
 int __ovld __conv work_group_scan_inclusive_add(int x);
 int __ovld __conv work_group_scan_inclusive_min(int x);
 int __ovld __conv work_group_scan_inclusive_max(int x);
 uint __ovld __conv work_group_reduce_add(uint x);
 uint __ovld __conv work_group_reduce_min(uint x);
 uint __ovld __conv work_group_reduce_max(uint x);
 uint __ovld __conv work_group_scan_exclusive_add(uint x);
 uint __ovld __conv work_group_scan_exclusive_min(uint x);
 uint __ovld __conv work_group_scan_exclusive_max(uint x);
 uint __ovld __conv work_group_scan_inclusive_add(uint x);
 uint __ovld __conv work_group_scan_inclusive_min(uint x);
 uint __ovld __conv work_group_scan_inclusive_max(uint x);

 float __ovld __conv work_group_reduce_max(float x);
 float __ovld __conv work_group_scan_exclusive_add(float x);
 float __ovld __conv work_group_scan_exclusive_min(float x);
 float __ovld __conv work_group_scan_exclusive_max(float x);
 float __ovld __conv work_group_scan_inclusive_add(float x);
 float __ovld __conv work_group_scan_inclusive_min(float x);
 float __ovld __conv work_group_scan_inclusive_max(float x);
 #ifdef cl_khr_fp64
 double __ovld __conv work_group_reduce_add(double x);
 double __ovld __conv work_group_reduce_min(double x);
 double __ovld __conv work_group_reduce_max(double x);
 double __ovld __conv work_group_scan_exclusive_add(double x);
 double __ovld __conv work_group_scan_exclusive_min(double x);
 double __ovld __conv work_group_scan_exclusive_max(double x);
 double __ovld __conv work_group_scan_inclusive_add(double x);
 double __ovld __conv work_group_scan_inclusive_min(double x);
 double __ovld __conv work_group_scan_inclusive_max(double x);
 #endif //cl_khr_fp64
 
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_work_group_collective_functions)
 
 // OpenCL v2.0 s6.13.16 - Pipe Functions
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_pipes)
 bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_pipes)
 
 
 // OpenCL v2.0 s6.13.17 - Enqueue Kernels
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
 ndrange_t __ovld ndrange_1D(size_t);
 ndrange_t __ovld ndrange_1D(size_t, size_t);
 ndrange_t __ovld ndrange_1D(size_t, size_t, size_t);

 
 void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void* value);
 
 queue_t __ovld get_default_queue(void);
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
 // OpenCL Extension v2.0 s9.17 - Sub-groups
 
-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups)
 // Shared Sub Group Functions
 uint    __ovld get_sub_group_size(void);
 uint    __ovld get_max_sub_group_size(void);
 uint    __ovld get_num_sub_groups(void);
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_subgroups)
 uint    __ovld get_enqueued_num_sub_groups(void);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_subgroups)
 uint    __ovld get_sub_group_id(void);
 uint    __ovld get_sub_group_local_id(void);
 
 void    __ovld __conv sub_group_barrier(cl_mem_fence_flags flags);
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_subgroups)
 void    __ovld __conv sub_group_barrier(cl_mem_fence_flags flags, memory_scope scope);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_subgroups)
 
 int     __ovld __conv sub_group_all(int predicate);
 int     __ovld __conv sub_group_any(int predicate);
 
 int     __ovld __conv sub_group_broadcast(int   x, uint sub_group_local_id);
 uint    __ovld __conv sub_group_broadcast(uint  x, uint sub_group_local_id);
 long    __ovld __conv sub_group_broadcast(long  x, uint sub_group_local_id);
 ulong   __ovld __conv sub_group_broadcast(ulong x, uint sub_group_local_id);

 ulong   __ovld __conv sub_group_reduce_max(ulong x);
 float   __ovld __conv sub_group_reduce_max(float x);
 
 int     __ovld __conv sub_group_scan_exclusive_add(int   x);
 uint    __ovld __conv sub_group_scan_exclusive_add(uint  x);
 long    __ovld __conv sub_group_scan_exclusive_add(long  x);
 ulong   __ovld __conv sub_group_scan_exclusive_add(ulong x);
 float   __ovld __conv sub_group_scan_exclusive_add(float x);
 int     __ovld __conv sub_group_scan_exclusive_min(int   x);
 uint    __ovld __conv sub_group_scan_exclusive_min(uint  x);
 long    __ovld __conv sub_group_scan_exclusive_min(long  x);
 ulong   __ovld __conv sub_group_scan_exclusive_min(ulong x);
 float   __ovld __conv sub_group_scan_exclusive_min(float x);
 int     __ovld __conv sub_group_scan_exclusive_max(int   x);
 uint    __ovld __conv sub_group_scan_exclusive_max(uint  x);
 long    __ovld __conv sub_group_scan_exclusive_max(long  x);
 ulong   __ovld __conv sub_group_scan_exclusive_max(ulong x);

 double  __ovld __conv sub_group_scan_exclusive_add(double x);
 double  __ovld __conv sub_group_scan_exclusive_min(double x);
 double  __ovld __conv sub_group_scan_exclusive_max(double x);
 double  __ovld __conv sub_group_scan_inclusive_add(double x);
 double  __ovld __conv sub_group_scan_inclusive_min(double x);
 double  __ovld __conv sub_group_scan_inclusive_max(double x);
 #endif //cl_khr_fp64
 
-#endif //cl_khr_subgroups cl_intel_subgroups
+#endif //cl_khr_subgroups cl_intel_subgroups __opencl_c_subgroups
 
 #if defined(cl_khr_subgroup_extended_types)
 char __ovld __conv sub_group_broadcast( char value, uint index );
 char2 __ovld __conv sub_group_broadcast( char2 value, uint index );
 char3 __ovld __conv sub_group_broadcast( char3 value, uint index );
 char4 __ovld __conv sub_group_broadcast( char4 value, uint index );
 char8 __ovld __conv sub_group_broadcast( char8 value, uint index );
 char16 __ovld __conv sub_group_broadcast( char16 value, uint index );