atomic.hpp

// Copyright Take Vos 2019-2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "counters.hpp"
#include "os_detect.hpp"
#include <atomic>
#include <thread>
#include <chrono>
 
namespace tt {
 
template<basic_fixed_string CounterTag, typename T>
tt_no_inline void
contended_wait_for_transition(std::atomic<T> const &state, T to, std::memory_order order = std::memory_order_seq_cst)
{
    using namespace std::literals::chrono_literals;
 
    increment_counter<CounterTag>();
 
    auto backoff = 10ms;
    while (true) {
        if (state.load(order) == to) {
            return;
        }
 
        std::this_thread::sleep_for(backoff);
        if ((backoff *= 2) > 1s) {
            backoff = 1s;
        }
    }
}
 
template<basic_fixed_string CounterTag, typename T>
void wait_for_transition(std::atomic<T> const &state, T to, std::memory_order order = std::memory_order_seq_cst)
{
    if (state.load(order) != to) {
        [[unlikely]] contended_wait_for_transition<CounterTag>(state, to, order);
    }
}
 
template<basic_fixed_string BlockCounterTag = "", typename T>
tt_no_inline void contended_transition(std::atomic<T> &state, T from, T to, std::memory_order order = std::memory_order_seq_cst)
{
    using namespace std::literals::chrono_literals;
 
    if constexpr (BlockCounterTag != "") {
        increment_counter<BlockCounterTag>();
    }
 
    auto backoff = 10ms;
    while (true) {
        auto expect = from;
        if (state.compare_exchange_weak(expect, to, order)) {
            return;
        }
 
        std::this_thread::sleep_for(backoff);
        if ((backoff *= 2) > 1s) {
            backoff = 1s;
        }
    }
}
 
template<basic_fixed_string BlockCounterTag = "", typename T>
void transition(std::atomic<T> &state, T from, T to, std::memory_order order = std::memory_order_seq_cst)
{
    auto expect = from;
    if (state.compare_exchange_strong(expect, to, order)) {
        [[likely]] return;
    } else {
        return contended_transition<BlockCounterTag>(state, from, to, order);
    }
}
 
} // namespace tt