boost/thread/win32/basic_timed_mutex.hpp
#ifndef BOOST_BASIC_TIMED_MUTEX_WIN32_HPP #define BOOST_BASIC_TIMED_MUTEX_WIN32_HPP // basic_timed_mutex_win32.hpp // // (C) Copyright 2006-8 Anthony Williams // (C) Copyright 2011-2012 Vicente J. Botet Escriba // // 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) #include <boost/assert.hpp> #include <boost/thread/win32/thread_primitives.hpp> #include <boost/thread/win32/interlocked_read.hpp> #include <boost/thread/thread_time.hpp> #if defined BOOST_THREAD_USES_DATETIME #include <boost/thread/xtime.hpp> #endif #include <boost/detail/interlocked.hpp> #ifdef BOOST_THREAD_USES_CHRONO #include <boost/chrono/system_clocks.hpp> #include <boost/chrono/ceil.hpp> #endif #include <boost/config/abi_prefix.hpp> namespace boost { namespace detail { struct basic_timed_mutex { BOOST_STATIC_CONSTANT(unsigned char,lock_flag_bit=31); BOOST_STATIC_CONSTANT(unsigned char,event_set_flag_bit=30); BOOST_STATIC_CONSTANT(long,lock_flag_value=1<<lock_flag_bit); BOOST_STATIC_CONSTANT(long,event_set_flag_value=1<<event_set_flag_bit); long active_count; void* event; void initialize() { active_count=0; event=0; } void destroy() { #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable:4312) #endif void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event,0); #ifdef BOOST_MSVC #pragma warning(pop) #endif if(old_event) { win32::CloseHandle(old_event); } } bool try_lock() BOOST_NOEXCEPT { return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit); } void lock() { if(try_lock()) { return; } long old_count=active_count; mark_waiting_and_try_lock(old_count); if(old_count&lock_flag_value) { bool lock_acquired=false; void* const sem=get_event(); do { unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0)); BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval); // BOOST_VERIFY(win32::WaitForSingleObject( // sem,::boost::detail::win32::infinite)==0); clear_waiting_and_try_lock(old_count); lock_acquired=!(old_count&lock_flag_value); } while(!lock_acquired); } } void mark_waiting_and_try_lock(long& old_count) { for(;;) { bool const was_locked=(old_count&lock_flag_value) ? true : false; long const new_count=was_locked?(old_count+1):(old_count|lock_flag_value); long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count); if(current==old_count) { if(was_locked) old_count=new_count; break; } old_count=current; } } void clear_waiting_and_try_lock(long& old_count) { old_count&=~lock_flag_value; old_count|=event_set_flag_value; for(;;) { long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value; long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count); if(current==old_count) { break; } old_count=current; } } #if defined BOOST_THREAD_USES_DATETIME bool timed_lock(::boost::system_time const& wait_until) { if(try_lock()) { return true; } long old_count=active_count; mark_waiting_and_try_lock(old_count); if(old_count&lock_flag_value) { bool lock_acquired=false; void* const sem=get_event(); do { if(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0) { BOOST_INTERLOCKED_DECREMENT(&active_count); return false; } clear_waiting_and_try_lock(old_count); lock_acquired=!(old_count&lock_flag_value); } while(!lock_acquired); } return true; } template<typename Duration> bool timed_lock(Duration const& timeout) { return timed_lock(get_system_time()+timeout); } bool timed_lock(boost::xtime const& timeout) { return timed_lock(system_time(timeout)); } #endif #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) { return try_lock_until(chrono::steady_clock::now() + rel_time); } template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& t) { using namespace chrono; system_clock::time_point s_now = system_clock::now(); typename Clock::time_point c_now = Clock::now(); return try_lock_until(s_now + ceil<system_clock::duration>(t - c_now)); } template <class Duration> bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t) { using namespace chrono; typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt; return try_lock_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch()))); } bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp) { if(try_lock()) { return true; } long old_count=active_count; mark_waiting_and_try_lock(old_count); if(old_count&lock_flag_value) { bool lock_acquired=false; void* const sem=get_event(); do { chrono::time_point<chrono::system_clock, chrono::system_clock::duration> now = chrono::system_clock::now(); if (tp<=now) { BOOST_INTERLOCKED_DECREMENT(&active_count); return false; } chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-now); if(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0) { BOOST_INTERLOCKED_DECREMENT(&active_count); return false; } clear_waiting_and_try_lock(old_count); lock_acquired=!(old_count&lock_flag_value); } while(!lock_acquired); } return true; } #endif void unlock() { long const offset=lock_flag_value; long const old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,lock_flag_value); if(!(old_count&event_set_flag_value) && (old_count>offset)) { if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit)) { win32::SetEvent(get_event()); } } } private: void* get_event() { void* current_event=::boost::detail::interlocked_read_acquire(&event); if(!current_event) { void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset); #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable:4311) #pragma warning(disable:4312) #endif void* const old_event=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&event,new_event,0); #ifdef BOOST_MSVC #pragma warning(pop) #endif if(old_event!=0) { win32::CloseHandle(new_event); return old_event; } else { return new_event; } } return current_event; } }; } } #define BOOST_BASIC_TIMED_MUTEX_INITIALIZER {0} #include <boost/config/abi_suffix.hpp> #endif