[libcxx-commits] [libcxx] [libc++] Implement C++20 atomic_ref (PR #76647)

[Louis Dionne via libcxx-commits]

================
@@ -0,0 +1,276 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ATOMIC_ATOMIC_REF_H
+#define _LIBCPP___ATOMIC_ATOMIC_REF_H
+
+#include <__assert>
+#include <__atomic/atomic_sync.h>
+#include <__atomic/check_memory_order.h>
+#include <__atomic/to_gcc_order.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_trivially_copyable.h>
+#include <cstddef>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, bool = is_integral_v<_Tp> && !is_same_v<_Tp, bool>, bool = is_floating_point_v<_Tp>>
----------------
ldionne wrote:

I might suggest the following overall approach:

```c++
template <class _Tp>
struct __atomic_ref_base {
    _Tp* __ptr_;
    // ...

    // all the "base" methods
};

template <class T>
struct atomic_ref : __atomic_ref_base<T> {
    // nothing more here (maybe ctors?)
};

template <class T>
    requires (std::integral<T> && !std::same_as<bool, T>)
struct atomic_ref<T> : __atomic_ref_base<T> {
    // add only integral stuff
};

template <class T>
    requires std::floating_point<T>
struct atomic_ref<T> : __atomic_ref_base<T> {
    // add only floating-point stuff
};

template <class T>
struct atomic_ref<T*> : __atomic_ref_base<T*> {
    // add only pointer stuff
};
```

The benefit I see is that you don't need inheritance of `__atomic_ref_base` in multiple layers -- it seems a bit simpler to me, but it achieves the same thing.

https://github.com/llvm/llvm-project/pull/76647