This is an archive of the discontinued LLVM Phabricator instance.

Differential D106111

opencl-c.h: add initial CL 3.0 conditionals for atomic operations.
ClosedPublic

Authored by airlied on Jul 15 2021, 4:45 PM.

Details

Reviewers
Anastasia
Commits
rG9451403c5f8c: [OPENCL] opencl-c.h: add initial CL 3.0 conditionals for atomic operations.
Summary

This adds the optional wrappers around things, however this isn't sufficient yet for CL 3.0 without generic address space, I've got one more additional patch to add all those APIs, but this is an easier to review precursor.

Diff Detail

Unit TestsFailed

TimeTest
2,570 msx64 debian > libarcher.critical::critical.c
2,590 msx64 debian > libarcher.critical::lock-nested.c
2,420 msx64 debian > libarcher.critical::lock.c
2,610 msx64 debian > libarcher.parallel::parallel-simple2.c
2,630 msx64 debian > libarcher.races::critical-unrelated.c
View Full Test Results (18 Failed)

Event Timeline

airlied created this revision.Jul 15 2021, 4:45 PM
Herald added subscribers: ldrumm, jfb, Anastasia, yaxunl. · View Herald TranscriptJul 15 2021, 4:45 PM
airlied requested review of this revision.Jul 15 2021, 4:45 PM
Herald added a subscriber: cfe-commits. · View Herald TranscriptJul 15 2021, 4:45 PM
Harbormaster completed remote builds in B114384: Diff 359169.Jul 15 2021, 6:16 PM
Anastasia accepted this revision.Jul 19 2021, 3:11 PM

LGTM. Thanks!

This revision is now accepted and ready to land.Jul 19 2021, 3:11 PM
Anastasia added a subscriber: azabaznov.Jul 19 2021, 3:11 PM

CC @azabaznov in case he has any feedback.

azabaznov added a comment.Jul 20 2021, 2:59 AM

You also need to guard memory_order_seq_cst enum entry. Note that memory_order_acq_rel is always defined as it can be used in atomic_work_item_fence() built-in function, AFAIR in all other cases if memory_order_acq_rel is used without __opencl_c_atomic_order_acq_rel feature it is undefined behavior.

airlied updated this revision to Diff 360349.Jul 20 2021, 8:32 PM

add conditional around memory_order_seq_cst

Harbormaster completed remote builds in B115241: Diff 360349.Jul 20 2021, 9:11 PM
This revision was landed with ongoing or failed builds.Jul 25 2021, 6:06 PM
Closed by commit rG9451403c5f8c: [OPENCL] opencl-c.h: add initial CL 3.0 conditionals for atomic operations. (authored by airlied). · Explain Why
This revision was automatically updated to reflect the committed changes.
airlied added a commit: rG9451403c5f8c: [OPENCL] opencl-c.h: add initial CL 3.0 conditionals for atomic operations..

Revision Contents

PathSize
clang/
lib/
Headers/
2 lines
35 lines

Diff 360349

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

Show First 20 Lines • Show All 338 Lines • ▼ Show 20 Lines
#define CLK_IMAGE_MEM_FENCE 0x04 #define CLK_IMAGE_MEM_FENCE 0x04
#ifndef ATOMIC_VAR_INIT #ifndef ATOMIC_VAR_INIT
#define ATOMIC_VAR_INIT(x) (x) #define ATOMIC_VAR_INIT(x) (x)
#endif //ATOMIC_VAR_INIT #endif //ATOMIC_VAR_INIT
#define ATOMIC_FLAG_INIT 0 #define ATOMIC_FLAG_INIT 0
// enum values aligned with what clang uses in EmitAtomicExpr() // enum values aligned with what clang uses in EmitAtomicExpr()
typedef enum memory_order typedef enum memory_order
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-typedef enum memory_order
-{
+typedef enum memory_order {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -typedef enum memory_order -{ +typedef enum…
{ {
memory_order_relaxed = __ATOMIC_RELAXED, memory_order_relaxed = __ATOMIC_RELAXED,
memory_order_acquire = __ATOMIC_ACQUIRE, memory_order_acquire = __ATOMIC_ACQUIRE,
memory_order_release = __ATOMIC_RELEASE, memory_order_release = __ATOMIC_RELEASE,
memory_order_acq_rel = __ATOMIC_ACQ_REL, memory_order_acq_rel = __ATOMIC_ACQ_REL,
#ifdef __opencl_c_atomic_order_seq_cst
memory_order_seq_cst = __ATOMIC_SEQ_CST memory_order_seq_cst = __ATOMIC_SEQ_CST
#endif
} memory_order; } memory_order;
#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions // OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions
// These values need to match the runtime equivalent // These values need to match the runtime equivalent
// //
▲ Show 20 Lines • Show All 209 Lines • ▼ Show 20 Lines
#define kernel_exec(X, typen) __kernel \ #define kernel_exec(X, typen) __kernel \
__attribute__((work_group_size_hint(X, 1, 1))) \ __attribute__((work_group_size_hint(X, 1, 1))) \
__attribute__((vec_type_hint(typen))) __attribute__((vec_type_hint(typen)))
#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
// OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf // OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf
int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2))); int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name 'constant' [clang-diagnostic-error]
not useful
clang-tidy: error: format argument not a string type [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'constant' [clang-diagnostic-error]
not useful
clang-tidy: error: format argument not a string type [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__constant' [clang-diagnostic-error] [[https://github.
#endif #endif
#ifdef cl_intel_device_side_avc_motion_estimation #ifdef cl_intel_device_side_avc_motion_estimation
#define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0 #define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0
#define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1 #define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1
#define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2 #define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2
#define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3 #define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

clang/lib/Headers/opencl-c.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,277 Lines • ▼ Show 20 Lines
half __ovld fract(half x, half *iptr); half __ovld fract(half x, half *iptr);
half2 __ovld fract(half2 x, half2 *iptr); half2 __ovld fract(half2 x, half2 *iptr);
half3 __ovld fract(half3 x, half3 *iptr); half3 __ovld fract(half3 x, half3 *iptr);
half4 __ovld fract(half4 x, half4 *iptr); half4 __ovld fract(half4 x, half4 *iptr);
half8 __ovld fract(half8 x, half8 *iptr); half8 __ovld fract(half8 x, half8 *iptr);
half16 __ovld fract(half16 x, half16 *iptr); half16 __ovld fract(half16 x, half16 *iptr);
#endif //cl_khr_fp16 #endif //cl_khr_fp16
#else #else
float __ovld fract(float x, __global float *iptr); float __ovld fract(float x, __global float *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float2 __ovld fract(float2 x, __global float2 *iptr); float2 __ovld fract(float2 x, __global float2 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float3 __ovld fract(float3 x, __global float3 *iptr); float3 __ovld fract(float3 x, __global float3 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float4 __ovld fract(float4 x, __global float4 *iptr); float4 __ovld fract(float4 x, __global float4 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float8 __ovld fract(float8 x, __global float8 *iptr); float8 __ovld fract(float8 x, __global float8 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float16 __ovld fract(float16 x, __global float16 *iptr); float16 __ovld fract(float16 x, __global float16 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__global' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__global' [clang-diagnostic-error] [[https://github.
float __ovld fract(float x, __local float *iptr); float __ovld fract(float x, __local float *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__local' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__local' [clang-diagnostic-error] [[https://github.
float2 __ovld fract(float2 x, __local float2 *iptr); float2 __ovld fract(float2 x, __local float2 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__local' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__local' [clang-diagnostic-error] [[https://github.
float3 __ovld fract(float3 x, __local float3 *iptr); float3 __ovld fract(float3 x, __local float3 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__local' [clang-diagnostic-error]
not useful
clang-tidy: error: expected ')' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__local' [clang-diagnostic-error] [[https://github.
float4 __ovld fract(float4 x, __local float4 *iptr); float4 __ovld fract(float4 x, __local float4 *iptr);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: unknown type name '__local' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: unknown type name '__local' [clang-diagnostic-error] [[https://github.
float8 __ovld fract(float8 x, __local float8 *iptr); float8 __ovld fract(float8 x, __local float8 *iptr);
float16 __ovld fract(float16 x, __local float16 *iptr); float16 __ovld fract(float16 x, __local float16 *iptr);
float __ovld fract(float x, __private float *iptr); float __ovld fract(float x, __private float *iptr);
float2 __ovld fract(float2 x, __private float2 *iptr); float2 __ovld fract(float2 x, __private float2 *iptr);
float3 __ovld fract(float3 x, __private float3 *iptr); float3 __ovld fract(float3 x, __private float3 *iptr);
float4 __ovld fract(float4 x, __private float4 *iptr); float4 __ovld fract(float4 x, __private float4 *iptr);
float8 __ovld fract(float8 x, __private float8 *iptr); float8 __ovld fract(float8 x, __private float8 *iptr);
float16 __ovld fract(float16 x, __private float16 *iptr); float16 __ovld fract(float16 x, __private float16 *iptr);
▲ Show 20 Lines • Show All 5,995 Lines • ▼ Show 20 Lines
void __ovld atomic_init(volatile atomic_double *object, double value); void __ovld atomic_init(volatile atomic_double *object, double value);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
#endif #endif
// atomic_work_item_fence() // atomic_work_item_fence()
void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope); void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);
// atomic_fetch() // atomic_fetch()
// OpenCL v2.0 s6.13.11.7.5:
// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t.
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t.
+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
+// can be ptrdiff_t.
Lint: Pre-merge checks: clang-format: please reformat the code ``` -// add/sub: atomic type argument can be…
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
int __ovld atomic_fetch_add(volatile atomic_int *object, int operand); int __ovld atomic_fetch_add(volatile atomic_int *object, int operand);
uint __ovld atomic_fetch_add(volatile atomic_uint *object, uint operand); uint __ovld atomic_fetch_add(volatile atomic_uint *object, uint operand);
int __ovld atomic_fetch_sub(volatile atomic_int *object, int operand); int __ovld atomic_fetch_sub(volatile atomic_int *object, int operand);
uint __ovld atomic_fetch_sub(volatile atomic_uint *object, uint operand); uint __ovld atomic_fetch_sub(volatile atomic_uint *object, uint operand);
int __ovld atomic_fetch_or(volatile atomic_int *object, int operand); int __ovld atomic_fetch_or(volatile atomic_int *object, int operand);
uint __ovld atomic_fetch_or(volatile atomic_uint *object, uint operand); uint __ovld atomic_fetch_or(volatile atomic_uint *object, uint operand);
int __ovld atomic_fetch_xor(volatile atomic_int *object, int operand); int __ovld atomic_fetch_xor(volatile atomic_int *object, int operand);
uint __ovld atomic_fetch_xor(volatile atomic_uint *object, uint operand); uint __ovld atomic_fetch_xor(volatile atomic_uint *object, uint operand);
Show All 14 Lines
long __ovld atomic_fetch_xor(volatile atomic_long *object, long operand); long __ovld atomic_fetch_xor(volatile atomic_long *object, long operand);
ulong __ovld atomic_fetch_xor(volatile atomic_ulong *object, ulong operand); ulong __ovld atomic_fetch_xor(volatile atomic_ulong *object, ulong operand);
long __ovld atomic_fetch_and(volatile atomic_long *object, long operand); long __ovld atomic_fetch_and(volatile atomic_long *object, long operand);
ulong __ovld atomic_fetch_and(volatile atomic_ulong *object, ulong operand); ulong __ovld atomic_fetch_and(volatile atomic_ulong *object, ulong operand);
long __ovld atomic_fetch_min(volatile atomic_long *object, long operand); long __ovld atomic_fetch_min(volatile atomic_long *object, long operand);
ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, ulong operand); ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, ulong operand);
long __ovld atomic_fetch_max(volatile atomic_long *object, long operand); long __ovld atomic_fetch_max(volatile atomic_long *object, long operand);
ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, ulong operand); ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, ulong operand);
#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
// OpenCL v2.0 s6.13.11.7.5:
// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t.
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object, ptrdiff_t operand); uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object, ptrdiff_t operand);
uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object, ptrdiff_t operand); uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object, ptrdiff_t operand);
#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // defined(cl_khr_int64_base_atomics) &&
+       // defined(cl_khr_int64_extended_atomics)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#endif //defined(cl_khr_int64_base_atomics) &&…
#endif #endif
#if defined(__opencl_c_atomic_scope_device)
int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order); int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order);
uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order); uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order);
int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order); int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order);
uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order); uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order);
int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order); int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order);
uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order); uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order);
int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order); int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order);
uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order); uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order);
Show All 13 Lines
long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order); long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order);
ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order); ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order); long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order);
ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order); ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order); long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order);
ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order); ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order); long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order);
ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order); ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order); uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order); uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // defined(cl_khr_int64_base_atomics) &&
+       // defined(cl_khr_int64_extended_atomics)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#endif //defined(cl_khr_int64_base_atomics) &&…
#endif #endif
int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope); int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope); uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope); int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope); uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope); int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope); uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
Show All 23 Lines
#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope); uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope); uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
#endif #endif
// atomic_store() // atomic_store()
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
void __ovld atomic_store(volatile atomic_int *object, int desired); void __ovld atomic_store(volatile atomic_int *object, int desired);
void __ovld atomic_store(volatile atomic_uint *object, uint desired); void __ovld atomic_store(volatile atomic_uint *object, uint desired);
void __ovld atomic_store(volatile atomic_float *object, float desired); void __ovld atomic_store(volatile atomic_float *object, float desired);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
void __ovld atomic_store(volatile atomic_double *object, double desired); void __ovld atomic_store(volatile atomic_double *object, double desired);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
void __ovld atomic_store(volatile atomic_long *object, long desired); void __ovld atomic_store(volatile atomic_long *object, long desired);
void __ovld atomic_store(volatile atomic_ulong *object, ulong desired); void __ovld atomic_store(volatile atomic_ulong *object, ulong desired);
#endif #endif
#endif
#if defined(__opencl_c_atomic_scope_device)
void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order);
void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order);
void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order);
void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order); void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
#endif #endif
#endif
void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope); void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
#endif #endif
// atomic_load() // atomic_load()
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
int __ovld atomic_load(volatile atomic_int *object); int __ovld atomic_load(volatile atomic_int *object);
uint __ovld atomic_load(volatile atomic_uint *object); uint __ovld atomic_load(volatile atomic_uint *object);
float __ovld atomic_load(volatile atomic_float *object); float __ovld atomic_load(volatile atomic_float *object);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_load(volatile atomic_double *object); double __ovld atomic_load(volatile atomic_double *object);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_load(volatile atomic_long *object); long __ovld atomic_load(volatile atomic_long *object);
ulong __ovld atomic_load(volatile atomic_ulong *object); ulong __ovld atomic_load(volatile atomic_ulong *object);
#endif #endif
#endif
#if defined(__opencl_c_atomic_scope_device)
int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order); int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order);
uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order); uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order);
float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order); float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order); double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order); long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order);
ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order); ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order);
#endif #endif
#endif
int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope); int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope);
uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope); uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope);
float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope); float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope); double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope); long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope);
ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope); ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope);
#endif #endif
// atomic_exchange() // atomic_exchange()
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
int __ovld atomic_exchange(volatile atomic_int *object, int desired); int __ovld atomic_exchange(volatile atomic_int *object, int desired);
uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired); uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired);
float __ovld atomic_exchange(volatile atomic_float *object, float desired); float __ovld atomic_exchange(volatile atomic_float *object, float desired);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_exchange(volatile atomic_double *object, double desired); double __ovld atomic_exchange(volatile atomic_double *object, double desired);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_exchange(volatile atomic_long *object, long desired); long __ovld atomic_exchange(volatile atomic_long *object, long desired);
ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired); ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired);
#endif #endif
#endif
#if defined(__opencl_c_atomic_scope_device)
int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order); int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order);
uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order); uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order);
float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order); float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order); double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order); long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order);
ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order); ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
#endif #endif
#endif
int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope); int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope); uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope); float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope); double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope); long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope); ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
#endif #endif
// atomic_compare_exchange_strong() and atomic_compare_exchange_weak() // atomic_compare_exchange_strong() and atomic_compare_exchange_weak()
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object, int *expected, int desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object, int *expected, int desired);
bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object, uint *expected, uint desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object, uint *expected, uint desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object, int *expected, int desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object, int *expected, int desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object, uint *expected, uint desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object, uint *expected, uint desired);
bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object, float *expected, float desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object, float *expected, float desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired);
#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
#ifdef cl_khr_fp64 #ifdef cl_khr_fp64
bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired);
#endif //cl_khr_fp64 #endif //cl_khr_fp64
bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired);
bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object, ulong *expected, ulong desired); bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object, ulong *expected, ulong desired);
bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object, ulong *expected, ulong desired); bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object, ulong *expected, ulong desired);
#endif #endif
#endif
bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected, bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,
int desired, memory_order success, memory_order failure); int desired, memory_order success, memory_order failure);
bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected, bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,
uint desired, memory_order success, memory_order failure); uint desired, memory_order success, memory_order failure);
bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected, bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,
int desired, memory_order success, memory_order failure); int desired, memory_order success, memory_order failure);
bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected, bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesbool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
long desired, memory_order success, memory_order failure, memory_scope scope); long desired, memory_order success, memory_order failure, memory_scope scope);
bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected, bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,
ulong desired, memory_order success, memory_order failure, memory_scope scope); ulong desired, memory_order success, memory_order failure, memory_scope scope);
bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected, bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,
ulong desired, memory_order success, memory_order failure, memory_scope scope); ulong desired, memory_order success, memory_order failure, memory_scope scope);
#endif #endif
// atomic_flag_test_and_set() and atomic_flag_clear() // atomic_flag_test_and_set() and atomic_flag_clear()
#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_atomic_order_seq_cst) &&                                \
+    defined(__opencl_c_atomic_scope_device)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#if defined(__opencl_c_atomic_order_seq_cst) &&…
bool __ovld atomic_flag_test_and_set(volatile atomic_flag *object); bool __ovld atomic_flag_test_and_set(volatile atomic_flag *object);
void __ovld atomic_flag_clear(volatile atomic_flag *object); void __ovld atomic_flag_clear(volatile atomic_flag *object);
#endif
#if defined(__opencl_c_atomic_scope_device)
bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order); bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);
void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order); void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);
#endif
bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope); bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope); void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
// OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions // OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions
/** /**
▲ Show 20 Lines • Show All 3,459 Lines • Show Last 20 Lines