Compiler Explorer

Source code

// To try using subscript operator comment in macro below
// the header will by default also check for the feature macro, and enable it
// defining the macro to 0 will overwrite the automatic setting
// x86-64 clang (trunk) and x86-64 GCC 12.1 do support the automatic setting
//#define MDSPAN_USE_BRACKET_OPERATOR 1

// To force enable operator() comment in the macro below
// You can enable both at the same time. 
//#define MDSPAN_USE_PAREN_OPERATOR 0

#include <https://raw.githubusercontent.com/kokkos/mdspan/single-header/mdspan.hpp>
#include <iostream>
#include <execution>
#include <atomic>
#include <type_traits>

namespace std {

template<class T>
constexpr bool atomic_ref_non_generic_type() {
    return (is_arithmetic_v<T> || is_pointer_v<T>) && !is_same_v<T,bool>;
}

template <class T, memory_order MemoryOrder>
struct atomic_ref_bound {
   private:
    using atomic_ref_unbound = atomic_ref<T>;  // exposition only
    atomic_ref_unbound ref;                    // exposition only

static constexpr memory_order store_ordering =
        MemoryOrder == memory_order_acq_rel ? memory_order_release
                                            : MemoryOrder;  // exposition only

static constexpr memory_order load_ordering =
        MemoryOrder == memory_order_acq_rel ? memory_order_acquire
                                            : MemoryOrder;  // exposition only

public:
    using value_type = T;

static constexpr memory_order memory_ordering = MemoryOrder;
    static constexpr size_t required_alignment = atomic_ref_unbound::required_alignment;

static constexpr bool is_always_lock_free = atomic_ref_unbound::is_always_lock_free;
    bool is_lock_free() const noexcept { return ref.is_lock_free(); }

explicit atomic_ref_bound(T& t):ref(t) {}
    atomic_ref_bound(atomic_ref_bound const& a) noexcept = default;
    atomic_ref_bound& operator=(atomic_ref_bound const&) = delete;

void store(T desired) const noexcept { ref.store(desired, store_ordering); }
    T operator=(T desired) const noexcept { store(desired); return desired; }
    T load() const noexcept { return ref.load(load_ordering); }
    operator T() const noexcept { return load(); }

T exchange(T desired) const noexcept { return ref.exchange(desired, memory_ordering); }
    bool compare_exchange_weak(T& expected, T desired) const noexcept { return ref.compare_exchange_weak(expected, desired, memory_ordering, load_ordering); }
    bool compare_exchange_strong(T& expected, T desired) const noexcept { return ref.compare_exchange_strong(expected, desired, memory_ordering, load_ordering); }

void wait(T old) const noexcept { ref.wait(old, load_ordering); }
    void notify_one() const noexcept { ref.notify_one(); }
    void notify_all() const noexcept { ref.notify_all(); }
};

template <class T, memory_order MemoryOrder>
//requires( std::is_same_v<atomic_ref<T>::difference_type, T> ||
//          std::is_same_v<atomic_ref<T>::difference_type, ptrdiff_t> )
requires(atomic_ref_non_generic_type<T>())
struct atomic_ref_bound<T,MemoryOrder> {  // exposition only
   private:
    using atomic_ref_unbound = atomic_ref<T>;  // exposition only
    atomic_ref_unbound ref;                    // exposition only

static constexpr memory_order store_ordering =
        MemoryOrder == memory_order_acq_rel ? memory_order_release
                                            : MemoryOrder;  // exposition only

static constexpr memory_order load_ordering =
        MemoryOrder == memory_order_acq_rel ? memory_order_acquire
                                            : MemoryOrder;  // exposition only

static constexpr bool is_integral_value =
        is_integral_v<T> && !is_same_v<T, bool>;  // exposition only
    static constexpr bool is_floating_point_value =
        is_floating_point_v<T>;  // exposition only
    static constexpr bool is_pointer_value =
        is_pointer_v<T>;  // exposition only

public:
    using value_type = atomic_ref_unbound::value_type;
    using difference_type = atomic_ref_unbound::difference_type;
    static constexpr memory_order memory_ordering = MemoryOrder;
    static constexpr size_t required_alignment = atomic_ref_unbound::required_alignment;

static constexpr bool is_always_lock_free = atomic_ref_unbound::is_always_lock_free;
    bool is_lock_free() const noexcept { return ref.is_lock_free(); }

explicit atomic_ref_bound(T& t):ref(t) {}
    atomic_ref_bound(atomic_ref_bound const& a) noexcept = default;
    atomic_ref_bound& operator=(atomic_ref_bound const&) = delete;

T fetch_add(T operand) const noexcept requires(is_integral_value || is_floating_point_value) { return ref.fetch_add(operand, memory_ordering); }
    T fetch_add(difference_type operand) const noexcept requires(is_pointer_value) { return ref.fetch_add(operand, memory_ordering); }
    T fetch_sub(T operand) const noexcept requires(is_integral_value || is_floating_point_value) { return ref.fetch_sub(operand, memory_ordering); }
    T fetch_sub(difference_type operand) const noexcept requires(is_pointer_value) { return ref.fetch_sub(operand, memory_ordering); }

T fetch_and(T operand) const noexcept requires(is_integral_value) { return ref.fetch_and(operand, memory_ordering); }
    T fetch_or(T operand) const noexcept requires(is_integral_value) { return ref.fetch_or(operand, memory_ordering); }
    T fetch_xor(T operand) const noexcept requires(is_integral_value) { return ref.fetch_xor(operand, memory_ordering); }

T operator++(int) const noexcept requires(is_integral_value || is_pointer_value) { return ref.fetch_add(1); }
    T operator++() const noexcept requires(is_integral_value || is_pointer_value) { return ref.fetch_add(1) + 1; }
    T operator--(int) const noexcept requires(is_integral_value || is_pointer_value) { return ref.fetch_sub(1); }
    T operator--() const noexcept requires(is_integral_value || is_pointer_value) { return ref.fetch_sub(1) - 1; }

T operator+=(T operand) const noexcept requires(is_integral_value || is_floating_point_value) { return ref.fetch_add(operand) + operand; }
    T operator+=(difference_type operand) const noexcept requires(is_pointer_value) { return ref.fetch_add(operand) + operand; }
    T operator-=(T operand) const noexcept requires(is_integral_value || is_floating_point_value) { return ref.fetch_sub(operand) + operand; }
    T operator-=(difference_type operand) const noexcept requires(is_pointer_value) { return ref.fetch_sub(operand) + operand; }

T operator&=(T operand) const noexcept requires(is_integral_value) { return ref.fetch_and(operand) & operand; }
    T operator|=(T operand) const noexcept requires(is_integral_value) { return ref.fetch_or(operand) | operand; }
    T operator^=(T operand) const noexcept requires(is_integral_value) { return ref.fetch_xor(operand) ^ operand; }

void wait(T old) const noexcept { ref.wait(old, load_ordering); }
    void notify_one() const noexcept { ref.notify_one(); }
    void notify_all() const noexcept { ref.notify_all(); }
};

template<class T>
using atomic_ref_relaxed = atomic_ref_bound<T, memory_order_relaxed>;

template<class T>
using atomic_ref_acq_rel = atomic_ref_bound<T, memory_order_acq_rel>;

template<class T>
using atomic_ref_seq_cst = atomic_ref_bound<T, memory_order_seq_cst>;

template <class ElementType, class ReferenceType>
struct basic_atomic_accessor {

using offset_policy = basic_atomic_accessor;
  using element_type = ElementType;
  using reference = ReferenceType;
  using data_handle_type = ElementType*;

constexpr basic_atomic_accessor() noexcept = default;

template<class OtherElementType>
  requires (
    std::is_convertible_v<OtherElementType(*)[], element_type(*)[]>
  )
  constexpr basic_atomic_accessor(std::default_accessor<OtherElementType>) noexcept {}

template<class OtherElementType>
  requires (
    std::is_convertible_v<OtherElementType(*)[], element_type(*)[]>
  )
  constexpr basic_atomic_accessor(basic_atomic_accessor<OtherElementType, ReferenceType>) noexcept {}

constexpr data_handle_type
  offset(data_handle_type p, size_t i) const noexcept {
    return p + i;
  }

constexpr reference access(data_handle_type p, size_t i) const noexcept {
    return reference(p[i]);
  }

};

template <class ElementType>
using atomic_accessor = basic_atomic_accessor<ElementType, atomic_ref<ElementType>>;

template <class ElementType>
using atomic_accessor_relaxed = basic_atomic_accessor<ElementType, atomic_ref_relaxed<ElementType>>;

template <class ElementType>
using atomic_accessor_acq_rel = basic_atomic_accessor<ElementType, atomic_ref_acq_rel<ElementType>>;

template <class ElementType>
using atomic_accessor_seq_cst = basic_atomic_accessor<ElementType, atomic_ref_seq_cst<ElementType>>;

}

template<class T, class Extents, class LayoutPolicy>
auto add_atomic_accessor_if_needed(
    std::execution::sequenced_policy,
    std::mdspan<T, Extents, LayoutPolicy> m) {
        return m;
    }

template<class ExecT, class T, class Extents, class LayoutPolicy>
auto add_atomic_accessor_if_needed(
    ExecT,
    std::mdspan<T, Extents, LayoutPolicy> m) {
        return std::mdspan(m.data_handle(),m.mapping(),std::atomic_accessor<T>());
    }

template<class ExecT>
void compute_histogram(ExecT exec, float bin_size,
               std::mdspan<int, std::dextents<size_t,1>> output,
               std::mdspan<float, std::dextents<size_t,1>> data) {
  static_assert(std::is_execution_policy_v<ExecT>);
  auto accumulator = add_atomic_accessor_if_needed(exec, output);

std::for_each(exec, data.data_handle(), data.data_handle()+data.extent(0), [=](float val) {
    int bin = std::abs(val)/bin_size;
    if(bin > output.extent(0)) bin = output.extent(0)-1;
    accumulator[bin]++;
  });
}

int main() {
  // Set up some random data
  std::vector<float> data(100);
  srand(234);
  std::for_each(std::begin(data),std::end(data),[=](float& val) {
    val = rand()%100;
  });

// output histogram
  std::vector<int> histo_data(10);

// get mdspans
  std::mdspan m{data.data(), data.size()};
  std::mdspan histogram{histo_data.data(), histo_data.size()};

// call compute_histogram with sequential execution
  compute_histogram(std::execution::seq, 10.0, histogram, m);
  for(int i=0; i<histo_data.size(); i++) printf("%i ", histo_data[i]);
  printf("\n");

// call compute histogram with parallel execution
  compute_histogram(std::execution::par, 10.0, histogram, m);
  for(int i=0; i<histo_data.size(); i++) printf("%i ", histo_data[i]);
  printf("\n");

{
  int* ptr;
  std::atomic_ref a{ptr};
  std::atomic_ref_relaxed b{ptr};
  std::atomic_ref_seq_cst c{ptr};
  std::atomic_ref_acq_rel d{ptr};
  static_assert(std::is_same_v<decltype(d)::difference_type,ptrdiff_t>);
  }
  {
  int ptr;
  std::atomic_ref a{ptr};
  std::atomic_ref_relaxed b{ptr};
  std::atomic_ref_seq_cst c{ptr};
  std::atomic_ref_acq_rel d{ptr};
  static_assert(std::is_same_v<decltype(d)::difference_type,int>);
  }
  {
  float ptr;
  std::atomic_ref a{ptr};
  std::atomic_ref_relaxed b{ptr};
  std::atomic_ref_seq_cst c{ptr};
  std::atomic_ref_acq_rel d{ptr};
  static_assert(std::is_same_v<decltype(b)::difference_type,float>);
  }
  {
  std::array<int,8> ptr;
  std::atomic_ref a{ptr};
  std::atomic_ref_relaxed b{ptr};
  std::atomic_ref_seq_cst c{ptr};
  std::atomic_ref_acq_rel d{ptr};
  //static_assert(std::is_same_v<decltype(d)::difference_type,int>);
  }

return 0;
}