/*
|
* 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_
|
