spin_lock.h

Go to the documentation of this file.

 
#pragma once
 
#if defined(_MSC_VER)
 
#  ifndef WIN32_LEAN_AND_MEAN
#    define WIN32_LEAN_AND_MEAN
#  endif
 
#  include <Windows.h>  // YieldProcessor
 
#  include <Processthreadsapi.h>
#  include <Synchapi.h>  // Windows server
#  include <intrin.h>
#elif defined(__i386__) || defined(__x86_64__)
#  if defined(__clang__)
#    include <emmintrin.h>
#  elif defined(__INTEL_COMPILER)
#    include <immintrin.h>
#  endif
#endif
 
#include <libcopp/utils/config/libcopp_build_features.h>
 
#include <libcopp/utils/atomic_int_type.h>
 
#if defined(_MSC_VER)
 
/*
 * See: http://msdn.microsoft.com/en-us/library/windows/desktop/ms687419(v=vs.85).aspx
 * Not for intel c++ compiler, so ignore http://software.intel.com/en-us/forums/topic/296168
 */
 
#  ifdef YieldProcessor
#    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() YieldProcessor()
#  endif
 
#elif defined(__GNUC__) || defined(__clang__)
#  if defined(__i386__) || defined(__x86_64__)
// #    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() __asm__ __volatile__("pause")
#    if defined(__clang__) || defined(__INTEL_COMPILER)
#      define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() _mm_pause()
#    else
#      define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() __builtin_ia32_pause()
#    endif
 
#  elif defined(__ia64__) || defined(__ia64)
#    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() __asm__ __volatile__("hint @pause")
#  elif defined(__arm__) && !defined(__ANDROID__)
#    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE() __asm__ __volatile__("yield")
#  endif
 
#endif /*compilers*/
 
// set pause do nothing
#if !defined(__LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE)
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE()
#endif 
#if 0 && defined(_MSC_VER)
 
// SwitchToThread only can be used in desktop system
 
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD() SwitchToThread()
 
#elif defined(__linux__) || defined(__unix__)
#  include <sched.h>
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD() sched_yield()
#endif
 
#ifndef __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD() __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE()
#endif
 
#if defined(__LIBCOPP_UTIL_LOCK_ATOMIC_INT_TYPE_ATOMIC_STD)
// clang-format off
#include <libcopp/utils/config/stl_include_prefix.h>  // NOLINT(build/include_order)
// clang-format on
#  include <chrono>
#  include <thread>
// clang-format off
#include <libcopp/utils/config/stl_include_suffix.h>  // NOLINT(build/include_order)
// clang-format on
 
#  if defined(__GNUC__) && !defined(__clang__)
#    if (__GNUC__ * 100 + __GNUC_MINOR__) <= 407
#      define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD() __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD()
#      define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP() __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD()
#    endif
#  endif
 
#  ifndef __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD
#    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD() ::std::this_thread::yield()
#  endif
#  ifndef __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP
#    define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP() ::std::this_thread::sleep_for(::std::chrono::milliseconds(1))
#  endif
 
#elif defined(_MSC_VER)
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD() Sleep(0)
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP() Sleep(1)
#endif
 
#ifndef __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD()
#  define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP() __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD()
#endif
 
#define __LIBCOPP_UTIL_LOCK_SPIN_LOCK_WAIT(x)                     \
  {                                                               \
    unsigned char try_lock_times = static_cast<unsigned char>(x); \
    if (try_lock_times < 4) {                                     \
    } else if (try_lock_times < 16) {                             \
      __LIBCOPP_UTIL_LOCK_SPIN_LOCK_PAUSE();                      \
    } else if (try_lock_times < 32) {                             \
      __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_YIELD();               \
    } else if (try_lock_times < 64) {                             \
      __LIBCOPP_UTIL_LOCK_SPIN_LOCK_CPU_YIELD();                  \
    } else {                                                      \
      __LIBCOPP_UTIL_LOCK_SPIN_LOCK_THREAD_SLEEP();               \
    }                                                             \
  }
 
LIBCOPP_COPP_NAMESPACE_BEGIN
namespace util {
namespace lock {
class LIBCOPP_COPP_API_HEAD_ONLY spin_lock {
 private:
  typedef enum { UNLOCKED = 0, LOCKED = 1 } lock_state_t;
  LIBCOPP_COPP_NAMESPACE_ID::util::lock::atomic_int_type<
#if defined(LIBCOPP_LOCK_DISABLE_MT) && LIBCOPP_LOCK_DISABLE_MT
      LIBCOPP_COPP_NAMESPACE_ID::util::lock::unsafe_int_type<unsigned int>
#else
      unsigned int
#endif
      >
      lock_status_;
 
 public:
  inline spin_lock() noexcept { lock_status_.store(UNLOCKED); }
 
  inline void lock() noexcept {
    unsigned char try_times = 0;
    while (lock_status_.exchange(static_cast<unsigned int>(LOCKED),
                                 LIBCOPP_COPP_NAMESPACE_ID::util::lock::memory_order_acq_rel) == LOCKED)
      __LIBCOPP_UTIL_LOCK_SPIN_LOCK_WAIT(try_times++); /* busy-wait */
  }
 
  inline void unlock() noexcept {
    lock_status_.store(static_cast<unsigned int>(UNLOCKED),
                       LIBCOPP_COPP_NAMESPACE_ID::util::lock::memory_order_release);
  }
 
  inline bool is_locked() noexcept {
    return lock_status_.load(LIBCOPP_COPP_NAMESPACE_ID::util::lock::memory_order_acquire) == LOCKED;
  }
 
  inline bool try_lock() noexcept {
    return lock_status_.exchange(static_cast<unsigned int>(LOCKED),
                                 LIBCOPP_COPP_NAMESPACE_ID::util::lock::memory_order_acq_rel) == UNLOCKED;
  }
 
  inline bool try_unlock() noexcept {
    return lock_status_.exchange(static_cast<unsigned int>(UNLOCKED),
                                 LIBCOPP_COPP_NAMESPACE_ID::util::lock::memory_order_acq_rel) == LOCKED;
  }
};
}  // namespace lock
}  // namespace util
LIBCOPP_COPP_NAMESPACE_END