Compiler Explorer

Source code

#include <algorithm>
#include <array>
#include <atomic>
#include <barrier>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <new>
#include <vector>
#include <thread>
#include <type_traits>

// P2835R2 proposes adding an atomic_ref::address member function to obtain the object 
// address. Emulated here using the following API:
template <typename T>
using address_return_t 
  = std::conditional_t<std::is_const_v<T> && std::is_volatile_v<T>, void const volatile*, 
    std::conditional_t<std::is_const_v<T>, void const*, 
    std::conditional_t<std::is_volatile_v<T>, void volatile*, 
    void*>>>;
template <typename T>
T* atomic_ref_get(std::atomic_ref<T> r) { 
    static_assert(sizeof(r) == sizeof(uintptr_t));
    union U {
        std::atomic_ref<T> a;
        T* b;
    };
    return U { .a = r }.b; // don't do this at home:
}

// Tony Table example
int data;
const int cdata = 42;
volatile int vdata = 42;
const volatile int cvdata = 42;
template <typename T>
T* fn(T& data, std::atomic_ref<T> ref) {
    T* addr = atomic_ref_get(ref);
    assert( &data == atomic_ref_get(ref) );
    return addr;
}

uintptr_t api_atomic_ref_this_paper(std::atomic_ref<int> ref) {
    // With this proposal, one can get the underlying object's address
    uintptr_t addr = reinterpret_cast<uintptr_t>(atomic_ref_get(ref));
    return addr;
}

int arr[2];
const int carr[2] = {13, 42};
volatile int varr[2] = {13, 42};
const volatile int cvarr[2] = {13, 42};
template <typename T>
T load_idx(std::atomic_ref<T> base, size_t i) {
    auto* p = atomic_ref_get(base);
    return std::atomic_ref{*(p+i)}.load();
}

int thread(std::atomic_ref<int> data, std::atomic_ref<int> counter, int nthreads) {
    data.fetch_add(42, std::memory_order_relaxed);
    int pos = counter.fetch_add(1);
    if (pos != (nthreads - 1)) return -1;
    // last thread: does not need to use atomic accesses
    int* d = atomic_ref_get(data);
    int last_data = *d; // non-atomic access
    // ...
    return last_data;
}

template <typename T>
constexpr T test_constexpr() {
    T value = 42;
    auto vptr = &value;
    auto p = vptr;
    return *p;
}

int main() {
    fn(data, std::atomic_ref{data});
    fn(cdata, std::atomic_ref{cdata});
    fn(vdata, std::atomic_ref{vdata});
    fn(cvdata, std::atomic_ref{cvdata});

api_atomic_ref_this_paper(std::atomic_ref{data});

int r0 = load_idx(std::atomic_ref{arr[0]}, 1);
    int r1 = load_idx(std::atomic_ref{carr[0]}, 1);
    int r2 = load_idx(std::atomic_ref{varr[0]}, 1);
    int r3 = load_idx(std::atomic_ref{cvarr[0]}, 1);
    int r = r0 + r1 + r2 + r3;

constexpr int s0 = test_constexpr<int>();
    constexpr int s1 = test_constexpr<const int>();
    //constexpr int s2 = test_constexpr<volatile int>();
    //constexpr int s3 = test_constexpr<const volatile int>();
    //constexpr int s = s0 + s1 + s2 + s3;
    constexpr int s = s0 + s1;

return r + s;
}