summaryrefslogtreecommitdiff
path: root/boost/fiber/detail/spinlock_ttas.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/fiber/detail/spinlock_ttas.hpp')
-rw-r--r--boost/fiber/detail/spinlock_ttas.hpp43
1 files changed, 22 insertions, 21 deletions
diff --git a/boost/fiber/detail/spinlock_ttas.hpp b/boost/fiber/detail/spinlock_ttas.hpp
index 380773ad6d..f3302ed17e 100644
--- a/boost/fiber/detail/spinlock_ttas.hpp
+++ b/boost/fiber/detail/spinlock_ttas.hpp
@@ -9,41 +9,37 @@
#include <atomic>
#include <chrono>
+#include <cmath>
#include <random>
#include <thread>
#include <boost/fiber/detail/config.hpp>
#include <boost/fiber/detail/cpu_relax.hpp>
+#include <boost/fiber/detail/spinlock_status.hpp>
// based on informations from:
// https://software.intel.com/en-us/articles/benefitting-power-and-performance-sleep-loops
// https://software.intel.com/en-us/articles/long-duration-spin-wait-loops-on-hyper-threading-technology-enabled-intel-processors
-#if BOOST_COMP_CLANG
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-private-field"
-#endif
-
namespace boost {
namespace fibers {
namespace detail {
class spinlock_ttas {
private:
- enum class spinlock_status {
- locked = 0,
- unlocked
- };
+ template< typename FBSplk >
+ friend class spinlock_rtm;
- std::atomic< spinlock_status > state_{ spinlock_status::unlocked };
+ std::atomic< spinlock_status > state_{ spinlock_status::unlocked };
public:
- spinlock_ttas() noexcept = default;
+ spinlock_ttas() = default;
spinlock_ttas( spinlock_ttas const&) = delete;
spinlock_ttas & operator=( spinlock_ttas const&) = delete;
void lock() noexcept {
+ static thread_local std::minstd_rand generator{ std::random_device{}() };
std::size_t collisions = 0 ;
for (;;) {
// avoid using multiple pause instructions for a delay of a specific cycle count
@@ -51,7 +47,7 @@ public:
// the cycle count can not guaranteed from one system to the next
// -> check the shared variable 'state_' in between each cpu_relax() to prevent
// unnecessarily long delays on some systems
- std::size_t tests = 0;
+ std::size_t retries = 0;
// test shared variable 'status_'
// first access to 'state_' -> chache miss
// sucessive acccess to 'state_' -> cache hit
@@ -59,21 +55,26 @@ public:
// cached 'state_' is invalidated -> cache miss
while ( spinlock_status::locked == state_.load( std::memory_order_relaxed) ) {
#if !defined(BOOST_FIBERS_SPIN_SINGLE_CORE)
- if ( BOOST_FIBERS_SPIN_MAX_TESTS > tests) {
- ++tests;
+ if ( BOOST_FIBERS_SPIN_BEFORE_SLEEP0 > retries) {
+ ++retries;
// give CPU a hint that this thread is in a "spin-wait" loop
// delays the next instruction's execution for a finite period of time (depends on processor family)
// the CPU is not under demand, parts of the pipeline are no longer being used
// -> reduces the power consumed by the CPU
// -> prevent pipeline stalls
cpu_relax();
- } else {
+ } else if ( BOOST_FIBERS_SPIN_BEFORE_YIELD > retries) {
// std::this_thread::sleep_for( 0us) has a fairly long instruction path length,
// combined with an expensive ring3 to ring 0 transition costing about 1000 cycles
// std::this_thread::sleep_for( 0us) lets give up this_thread the remaining part of its time slice
// if and only if a thread of equal or greater priority is ready to run
static constexpr std::chrono::microseconds us0{ 0 };
std::this_thread::sleep_for( us0);
+ } else {
+ // std::this_thread::yield() allows this_thread to give up the remaining part of its time slice,
+ // but only to another thread on the same processor
+ // instead of constant checking, a thread only checks if no other useful work is pending
+ std::this_thread::yield();
}
#else
std::this_thread::yield();
@@ -85,8 +86,8 @@ public:
// spinlock now contended
// utilize 'Binary Exponential Backoff' algorithm
// linear_congruential_engine is a random number engine based on Linear congruential generator (LCG)
- static thread_local std::minstd_rand generator;
- static std::uniform_int_distribution< std::size_t > distribution{ 0, static_cast< std::size_t >( 1) << collisions };
+ std::uniform_int_distribution< std::size_t > distribution{
+ 0, static_cast< std::size_t >( 1) << (std::min)(collisions, static_cast< std::size_t >( BOOST_FIBERS_CONTENTION_WINDOW_THRESHOLD)) };
const std::size_t z = distribution( generator);
++collisions;
for ( std::size_t i = 0; i < z; ++i) {
@@ -101,6 +102,10 @@ public:
}
}
+ bool try_lock() noexcept {
+ return spinlock_status::unlocked == state_.exchange( spinlock_status::locked, std::memory_order_acquire);
+ }
+
void unlock() noexcept {
state_.store( spinlock_status::unlocked, std::memory_order_release);
}
@@ -108,8 +113,4 @@ public:
}}}
-#if BOOST_COMP_CLANG
-#pragma clang diagnostic pop
-#endif
-
#endif // BOOST_FIBERS_SPINLOCK_TTAS_H