Fix atomic CAS functionality in CUDA

Currently, the functionality is `compare_exchange_strong` is broken
because it relies on the CUDA `atomicCAS` builtin which functions
fundamentally differently from the C++ STL version of the equivalent
code. Indeed, the C++ version returns true on a succesful swap and false
otherwise. The CUDA version always returns the old value. As such, if
the old value is false-like, e.g. 0, the `compare_exchange_strong`
function will always appear to fail, even if it succeeded. This commit
fixes the above issue. Also increases the robustness of other atomic
operations, adds new concepts, and adds new tests.

Author: stephenswat

core/include/vecmem/concepts/atomic_ref.hpp

@@ -0,0 +1,62 @@
+/*
+ * VecMem project, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+#pragma once
+
+#if __cpp_concepts >= 201907L
+#include <concepts>
+
+#include "vecmem/memory/device_atomic_ref.hpp"
+#endif
+
+namespace vecmem::concepts {
+#if __cpp_concepts >= 201907L
+/*
+ * Concept to verify that a type functions as an atomic reference.
+ */
+template <typename T>
+concept atomic_ref = requires {
+    typename T::value_type;
+
+    requires requires(const T& r, typename T::value_type v) {
+        { r = v }
+        ->std::same_as<typename T::value_type>;
+    };
+
+    requires requires(const T& r, memory_order o) {
+        { r.load(o) }
+        ->std::same_as<typename T::value_type>;
+    };
+
+    requires requires(const T& r, typename T::value_type v, memory_order o) {
+        { r.store(v, o) }
+        ->std::same_as<void>;
+        { r.exchange(v, o) }
+        ->std::same_as<typename T::value_type>;
+        { r.fetch_add(v, o) }
+        ->std::same_as<typename T::value_type>;
+        { r.fetch_sub(v, o) }
+        ->std::same_as<typename T::value_type>;
+        { r.fetch_and(v, o) }
+        ->std::same_as<typename T::value_type>;
+        { r.fetch_or(v, o) }
+        ->std::same_as<typename T::value_type>;
+        { r.fetch_xor(v, o) }
+        ->std::same_as<typename T::value_type>;
+    };
+
+    requires requires(const T& r, typename T::value_type& e,
+                      typename T::value_type d, memory_order o1,
+                      memory_order o2) {
+        { r.compare_exchange_strong(e, d, o1, o2) }
+        ->std::same_as<bool>;
+        { r.compare_exchange_strong(e, d, o1) }
+        ->std::same_as<bool>;
+    };
+};
+#endif
+}  // namespace vecmem::concepts

core/include/vecmem/memory/device_atomic_ref.hpp

@@ -213,4 +213,17 @@ class device_atomic_ref {
 // Include the implementation.
 #include "vecmem/memory/impl/device_atomic_ref.ipp"
 
+#if __cpp_concepts >= 201907L
+#include "vecmem/concepts/atomic_ref.hpp"
+static_assert(
+    vecmem::concepts::atomic_ref<vecmem::device_atomic_ref<uint32_t> >,
+    "Atomic reference on uint32_t is incompletely defined.");
+static_assert(
+    vecmem::concepts::atomic_ref<vecmem::device_atomic_ref<uint64_t> >,
+    "Atomic reference on uint64_t is incompletely defined.");
+static_assert(
+    vecmem::concepts::atomic_ref<vecmem::device_atomic_ref<std::size_t> >,
+    "Atomic reference on std::size_t is incompletely defined.");
+#endif
+
 #endif  // Platform selection