backoff.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_BACKOFF_HPP
#define JOIN_CORE_BACKOFF_HPP
 
// libjoin.
#include <join/clock.hpp>
 
// C++.
#include <thread>
#include <chrono>
 
// C.
#if defined(__x86_64__) || defined(__i386__)
#include <immintrin.h>
#endif
#include <cstddef>
 
namespace join
{
    class Backoff
    {
    public:
        explicit Backoff (std::chrono::nanoseconds spin = std::chrono::microseconds (10),
                          std::chrono::nanoseconds yield = std::chrono::microseconds (100),
                          std::chrono::nanoseconds sleep = std::chrono::microseconds (50)) noexcept
        : _spin (spin)
        , _yield (yield)
        , _sleep (sleep)
        {
        }
 
        void operator() () noexcept
        {
            if (_start == Rdtsc::TimePoint ())
            {
                _start = Rdtsc::now ();
            }
 
            if (_spinning)
            {
                if (Rdtsc::now () - _start < _spin)
                {
#if defined(__x86_64__) || defined(__i386__)
                    _mm_pause ();
#elif defined(__aarch64__) || defined(__arm__)
                    __asm__ __volatile__ ("isb" ::: "memory");
#endif
                    return;
                }
 
                _spinning = false;
            }
 
            const auto elapsed = Rdtsc::now () - _start;
 
            if ((_sleep == std::chrono::nanoseconds::zero ()) || (elapsed - _spin < _yield))
            {
                std::this_thread::yield ();
            }
            else
            {
                std::this_thread::sleep_for (_sleep);
            }
        }
 
        void reset () noexcept
        {
            _start = Rdtsc::TimePoint ();
            _spinning = true;
        }
 
        bool spinExhausted () const noexcept
        {
            return (_start != Rdtsc::TimePoint ()) && (Rdtsc::now () - _start >= _spin);
        }
 
    private:
        std::chrono::nanoseconds _spin;
 
        std::chrono::nanoseconds _yield;
 
        std::chrono::nanoseconds _sleep;
 
        Rdtsc::TimePoint _start = Rdtsc::TimePoint ();
 
        bool _spinning = true;
    };
}
 
#endif