update boost

linx64/include/boost/atomic/detail/lock_pool.hpp

@@ -0,0 +1,151 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2011 Helge Bahmann
+ * Copyright (c) 2013-2014, 2020 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/lock_pool.hpp
+ *
+ * This header contains declaration of the lock pool used to emulate atomic ops.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_LOCK_POOL_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_LOCK_POOL_HPP_INCLUDED_
+
+#include <cstddef>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/link.hpp>
+#include <boost/atomic/detail/intptr.hpp>
+#if defined(BOOST_WINDOWS)
+#include <boost/winapi/thread.hpp>
+#elif defined(BOOST_HAS_NANOSLEEP)
+#include <time.h>
+#else
+#include <unistd.h>
+#endif
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+BOOST_FORCEINLINE void wait_some() BOOST_NOEXCEPT
+{
+#if defined(BOOST_WINDOWS)
+    boost::winapi::SwitchToThread();
+#elif defined(BOOST_HAS_NANOSLEEP)
+    // Do not use sched_yield or pthread_yield as at least on Linux it doesn't block the thread if there are no other
+    // pending threads on the current CPU. Proper sleeping is guaranteed to block the thread, which allows other threads
+    // to potentially migrate to this CPU and complete the tasks we're waiting for.
+    struct ::timespec ts = {};
+    ts.tv_sec = 0;
+    ts.tv_nsec = 1000;
+    ::nanosleep(&ts, NULL);
+#else
+    ::usleep(1);
+#endif
+}
+
+namespace lock_pool {
+
+BOOST_ATOMIC_DECL void* short_lock(atomics::detail::uintptr_t h) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void* long_lock(atomics::detail::uintptr_t h) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void unlock(void* ls) BOOST_NOEXCEPT;
+
+BOOST_ATOMIC_DECL void* allocate_wait_state(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void free_wait_state(void* ls, void* ws) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void wait(void* ls, void* ws) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void notify_one(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void notify_all(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
+
+BOOST_ATOMIC_DECL void thread_fence() BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void signal_fence() BOOST_NOEXCEPT;
+
+template< std::size_t Alignment >
+BOOST_FORCEINLINE atomics::detail::uintptr_t hash_ptr(const volatile void* addr) BOOST_NOEXCEPT
+{
+    atomics::detail::uintptr_t ptr = (atomics::detail::uintptr_t)addr;
+    atomics::detail::uintptr_t h = ptr / Alignment;
+
+    // Since many malloc/new implementations return pointers with higher alignment
+    // than indicated by Alignment, it makes sense to mix higher bits
+    // into the lower ones. On 64-bit platforms, malloc typically aligns to 16 bytes,
+    // on 32-bit - to 8 bytes.
+    BOOST_CONSTEXPR_OR_CONST std::size_t malloc_alignment = sizeof(void*) >= 8u ? 16u : 8u;
+    BOOST_IF_CONSTEXPR (Alignment != malloc_alignment)
+        h ^= ptr / malloc_alignment;
+
+    return h;
+}
+
+template< std::size_t Alignment, bool LongLock = false >
+class scoped_lock
+{
+private:
+    void* m_lock;
+
+public:
+    explicit scoped_lock(const volatile void* addr) BOOST_NOEXCEPT
+    {
+        atomics::detail::uintptr_t h = lock_pool::hash_ptr< Alignment >(addr);
+        BOOST_IF_CONSTEXPR (!LongLock)
+            m_lock = lock_pool::short_lock(h);
+        else
+            m_lock = lock_pool::long_lock(h);
+    }
+    ~scoped_lock() BOOST_NOEXCEPT
+    {
+        lock_pool::unlock(m_lock);
+    }
+
+    void* get_lock_state() const BOOST_NOEXCEPT
+    {
+        return m_lock;
+    }
+
+    BOOST_DELETED_FUNCTION(scoped_lock(scoped_lock const&))
+    BOOST_DELETED_FUNCTION(scoped_lock& operator=(scoped_lock const&))
+};
+
+template< std::size_t Alignment >
+class scoped_wait_state :
+    public scoped_lock< Alignment, true >
+{
+private:
+    void* m_wait_state;
+
+public:
+    explicit scoped_wait_state(const volatile void* addr) BOOST_NOEXCEPT :
+        scoped_lock< Alignment, true >(addr)
+    {
+        m_wait_state = lock_pool::allocate_wait_state(this->get_lock_state(), addr);
+    }
+    ~scoped_wait_state() BOOST_NOEXCEPT
+    {
+        lock_pool::free_wait_state(this->get_lock_state(), m_wait_state);
+    }
+
+    void wait() BOOST_NOEXCEPT
+    {
+        lock_pool::wait(this->get_lock_state(), m_wait_state);
+    }
+
+    BOOST_DELETED_FUNCTION(scoped_wait_state(scoped_wait_state const&))
+    BOOST_DELETED_FUNCTION(scoped_wait_state& operator=(scoped_wait_state const&))
+};
+
+} // namespace lock_pool
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_LOCK_POOL_HPP_INCLUDED_