Subject: [Boost-commit] svn:boost r76168 - in trunk/boost/interprocess: . detail sync sync/posix sync/shm sync/spin sync/windows
From: igaztanaga_at_[hidden]
Date: 2011-12-26 06:08:46
Author: igaztanaga
Date: 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
New Revision: 76168
URL: http://svn.boost.org/trac/boost/changeset/76168
Log:
Updated timed functions to fulfill posix requirements.
Text files modified:
trunk/boost/interprocess/detail/os_file_functions.hpp | 11 ++-
trunk/boost/interprocess/shared_memory_object.hpp | 4
trunk/boost/interprocess/sync/named_mutex.hpp | 7 ++
trunk/boost/interprocess/sync/posix/mutex.hpp | 2
trunk/boost/interprocess/sync/posix/recursive_mutex.hpp | 2
trunk/boost/interprocess/sync/posix/semaphore_wrapper.hpp | 4
trunk/boost/interprocess/sync/shm/named_condition.hpp | 114 ++++++++++++++++++++++++++-------------
trunk/boost/interprocess/sync/shm/named_mutex.hpp | 6 +-
trunk/boost/interprocess/sync/shm/named_upgradable_mutex.hpp | 6 +-
trunk/boost/interprocess/sync/spin/condition.hpp | 32 +++++-----
trunk/boost/interprocess/sync/spin/mutex.hpp | 2
trunk/boost/interprocess/sync/spin/recursive_mutex.hpp | 3
trunk/boost/interprocess/sync/spin/semaphore.hpp | 2
trunk/boost/interprocess/sync/windows/mutex.hpp | 25 +++-----
trunk/boost/interprocess/sync/windows/semaphore.hpp | 25 +++-----
15 files changed, 136 insertions(+), 109 deletions(-)
Modified: trunk/boost/interprocess/detail/os_file_functions.hpp
==============================================================================
--- trunk/boost/interprocess/detail/os_file_functions.hpp (original)
+++ trunk/boost/interprocess/detail/os_file_functions.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -18,6 +18,7 @@
#include <string>
#include <limits>
+#include <climits>
#if (defined BOOST_INTERPROCESS_WINDOWS)
# include <boost/interprocess/detail/win32_api.hpp>
@@ -448,11 +449,13 @@
inline bool truncate_file (file_handle_t hnd, std::size_t size)
{
- if(off_t(size) < 0){
- errno = EINVAL;
- return false;
+ if(sizeof(off_t) == sizeof(std::size_t)){
+ if(size > ((~std::size_t(0)) >> 1)){
+ errno = EINVAL;
+ return false;
+ }
}
- return 0 == ::ftruncate(hnd, size);
+ return 0 == ::ftruncate(hnd, off_t(size));
}
inline bool get_file_size(file_handle_t hnd, offset_t &size)
Modified: trunk/boost/interprocess/shared_memory_object.hpp
==============================================================================
--- trunk/boost/interprocess/shared_memory_object.hpp (original)
+++ trunk/boost/interprocess/shared_memory_object.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -275,7 +275,7 @@
#if defined(BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
const bool add_leading_slash = false;
#elif defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
- const bool add_leading_slash = !shared_memory_object_ipcdetail::use_filesystem_based_posix();
+ const bool add_leading_slash = !shared_memory_object_detail::use_filesystem_based_posix();
#else
const bool add_leading_slash = true;
#endif
@@ -361,7 +361,7 @@
#if defined(BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
const bool add_leading_slash = false;
#elif defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
- const bool add_leading_slash = !shared_memory_object_ipcdetail::use_filesystem_based_posix();
+ const bool add_leading_slash = !shared_memory_object_detail::use_filesystem_based_posix();
#else
const bool add_leading_slash = true;
#endif
Modified: trunk/boost/interprocess/sync/named_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/named_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/named_mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -106,10 +106,15 @@
#if defined(BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
typedef ipcdetail::posix_named_mutex impl_t;
+ impl_t m_mut;
#else
typedef ipcdetail::shm_named_mutex impl_t;
- #endif
impl_t m_mut;
+ public:
+ interprocess_mutex *mutex() const
+ { return m_mut.mutex(); }
+ #endif
+
/// @endcond
};
Modified: trunk/boost/interprocess/sync/posix/mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/posix/mutex.hpp (original)
+++ trunk/boost/interprocess/sync/posix/mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -119,8 +119,6 @@
//Obtain current count and target time
boost::posix_time::ptime now = microsec_clock::universal_time();
- if(now >= abs_time) return false;
-
do{
if(this->try_lock()){
break;
Modified: trunk/boost/interprocess/sync/posix/recursive_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/posix/recursive_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/posix/recursive_mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -109,8 +109,6 @@
//Obtain current count and target time
boost::posix_time::ptime now = microsec_clock::universal_time();
- if(now >= abs_time) return false;
-
do{
if(this->try_lock()){
break;
Modified: trunk/boost/interprocess/sync/posix/semaphore_wrapper.hpp
==============================================================================
--- trunk/boost/interprocess/sync/posix/semaphore_wrapper.hpp (original)
+++ trunk/boost/interprocess/sync/posix/semaphore_wrapper.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -195,11 +195,11 @@
return false;
#else //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
boost::posix_time::ptime now;
- while((now = microsec_clock::universal_time()) < abs_time){
+ do{
if(semaphore_try_wait(handle))
return true;
thread_yield();
- }
+ }while((now = microsec_clock::universal_time()) < abs_time);
return false;
#endif //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
}
Modified: trunk/boost/interprocess/sync/shm/named_condition.hpp
==============================================================================
--- trunk/boost/interprocess/sync/shm/named_condition.hpp (original)
+++ trunk/boost/interprocess/sync/shm/named_condition.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -148,42 +148,68 @@
};
#if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
- interprocess_mutex *mutex() const
- { return &static_cast<condition_holder*>(m_shmem.get_user_address())->mutex_; }
+ interprocess_mutex *mutex() const
+ { return &static_cast<condition_holder*>(m_shmem.get_user_address())->mutex_; }
- template <class Lock>
- void do_wait(Lock& lock)
- {
- //shm_named_condition only works with named_mutex
- BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
-
- //lock internal before unlocking external to avoid race with a notifier
- scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
- lock_inverter<Lock> inverted_lock(lock);
- scoped_lock<lock_inverter<Lock> > external_unlock(inverted_lock);
-
- //unlock internal first to avoid deadlock with near simultaneous waits
- scoped_lock<interprocess_mutex> internal_unlock;
- internal_lock.swap(internal_unlock);
- this->condition()->wait(internal_unlock);
- }
+ template <class Lock>
+ void do_wait(Lock& lock)
+ {
+ //shm_named_condition only works with named_mutex
+ BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
+
+ //lock internal before unlocking external to avoid race with a notifier
+ scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
+ lock_inverter<Lock> inverted_lock(lock);
+ scoped_lock<lock_inverter<Lock> > external_unlock(inverted_lock);
+
+ //unlock internal first to avoid deadlock with near simultaneous waits
+ scoped_lock<interprocess_mutex> internal_unlock;
+ internal_lock.swap(internal_unlock);
+ this->condition()->wait(internal_unlock);
+ }
- template <class Lock>
- bool do_timed_wait(Lock& lock, const boost::posix_time::ptime &abs_time)
- {
- //shm_named_condition only works with named_mutex
- BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
- //lock internal before unlocking external to avoid race with a notifier
- scoped_lock<interprocess_mutex> internal_lock(*this->mutex(), abs_time);
- if(!internal_lock) return false;
- lock_inverter<Lock> inverted_lock(lock);
- scoped_lock<lock_inverter<Lock> > external_unlock(inverted_lock);
-
- //unlock internal first to avoid deadlock with near simultaneous waits
- scoped_lock<interprocess_mutex> internal_unlock;
- internal_lock.swap(internal_unlock);
- return this->condition()->timed_wait(internal_unlock, abs_time);
- }
+ template <class Lock>
+ bool do_timed_wait(Lock& lock, const boost::posix_time::ptime &abs_time)
+ {
+ //shm_named_condition only works with named_mutex
+ BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
+ //lock internal before unlocking external to avoid race with a notifier
+ scoped_lock<interprocess_mutex> internal_lock(*this->mutex(), abs_time);
+ if(!internal_lock) return false;
+ lock_inverter<Lock> inverted_lock(lock);
+ scoped_lock<lock_inverter<Lock> > external_unlock(inverted_lock);
+
+ //unlock internal first to avoid deadlock with near simultaneous waits
+ scoped_lock<interprocess_mutex> internal_unlock;
+ internal_lock.swap(internal_unlock);
+ return this->condition()->timed_wait(internal_unlock, abs_time);
+ }
+ #else
+ template<class Lock>
+ class lock_wrapper
+ {
+ typedef void (lock_wrapper::*unspecified_bool_type)();
+ public:
+
+ typedef interprocess_mutex mutex_type;
+
+ lock_wrapper(Lock &l)
+ : l_(l)
+ {}
+
+ mutex_type* mutex() const
+ { return l_.mutex()->mutex(); }
+
+ void lock() { l_.lock(); }
+
+ void unlock() { l_.unlock(); }
+
+ operator unspecified_bool_type() const
+ { return l_ ? &lock_wrapper::lock : 0; }
+
+ private:
+ Lock &l_;
+ };
#endif
friend class boost::interprocess::ipcdetail::interprocess_tester;
@@ -309,21 +335,33 @@
template <typename L>
inline void shm_named_condition::wait(L& lock)
-{ this->condition()->wait(lock); }
+{
+ lock_wrapper<L> newlock(lock);
+ this->condition()->wait(newlock);
+}
template <typename L, typename Pr>
inline void shm_named_condition::wait(L& lock, Pr pred)
-{ this->condition()->wait(lock, pred); }
+{
+ lock_wrapper<L> newlock(lock);
+ this->condition()->wait(newlock, pred);
+}
template <typename L>
inline bool shm_named_condition::timed_wait
(L& lock, const boost::posix_time::ptime &abs_time)
-{ return this->condition()->timed_wait(lock, abs_time); }
+{
+ lock_wrapper<L> newlock(lock);
+ return this->condition()->timed_wait(newlock, abs_time);
+}
template <typename L, typename Pr>
inline bool shm_named_condition::timed_wait
(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
-{ return this->condition()->timed_wait(lock, abs_time, pred); }
+{
+ lock_wrapper<L> newlock(lock);
+ return this->condition()->timed_wait(newlock, abs_time, pred);
+}
#endif
Modified: trunk/boost/interprocess/sync/shm/named_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/shm/named_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/shm/named_mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -100,13 +100,13 @@
static bool remove(const char *name);
/// @cond
+ interprocess_mutex *mutex() const
+ { return static_cast<interprocess_mutex*>(m_shmem.get_user_address()); }
+
private:
friend class ipcdetail::interprocess_tester;
void dont_close_on_destruction();
- interprocess_mutex *mutex() const
- { return static_cast<interprocess_mutex*>(m_shmem.get_user_address()); }
-
ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
typedef ipcdetail::named_creation_functor<interprocess_mutex> construct_func_t;
/// @endcond
Modified: trunk/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/shm/named_upgradable_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/shm/named_upgradable_mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -8,8 +8,8 @@
//
//////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_INTERPROCESS_named_upgradable_mutex_HPP
-#define BOOST_INTERPROCESS_named_upgradable_mutex_HPP
+#ifndef BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
+#define BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
# pragma once
@@ -369,4 +369,4 @@
#include <boost/interprocess/detail/config_end.hpp>
-#endif //BOOST_INTERPROCESS_named_upgradable_mutex_HPP
+#endif //BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
Modified: trunk/boost/interprocess/sync/spin/condition.hpp
==============================================================================
--- trunk/boost/interprocess/sync/spin/condition.hpp (original)
+++ trunk/boost/interprocess/sync/spin/condition.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -13,9 +13,9 @@
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/sync/spin/mutex.hpp>
#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
#include <boost/interprocess/detail/atomic.hpp>
-#include <boost/interprocess/sync/spin/mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/exceptions.hpp>
#include <boost/interprocess/detail/os_thread_functions.hpp>
@@ -94,7 +94,7 @@
bool do_timed_wait(bool tout_enabled, const boost::posix_time::ptime &abs_time, InterprocessMutex &mut);
enum { SLEEP = 0, NOTIFY_ONE, NOTIFY_ALL };
- ipcdetail::spin_mutex m_enter_mut;
+ spin_mutex m_enter_mut;
volatile boost::uint32_t m_command;
volatile boost::uint32_t m_num_waiters;
void notify(boost::uint32_t command);
@@ -134,19 +134,19 @@
m_enter_mut.lock();
//Return if there are no waiters
- if(!ipcdetail::atomic_read32(&m_num_waiters)) {
+ if(!atomic_read32(&m_num_waiters)) {
m_enter_mut.unlock();
return;
}
//Notify that all threads should execute wait logic
- while(SLEEP != ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_command), command, SLEEP)){
- ipcdetail::thread_yield();
+ while(SLEEP != atomic_cas32(const_cast<boost::uint32_t*>(&m_command), command, SLEEP)){
+ thread_yield();
}
/*
//Wait until the threads are woken
- while(SLEEP != ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_command), 0)){
- ipcdetail::thread_yield();
+ while(SLEEP != atomic_cas32(const_cast<boost::uint32_t*>(&m_command), 0)){
+ thread_yield();
}
*/
//The enter mutex will rest locked until the last waiting thread unlocks it
@@ -176,7 +176,7 @@
if(now >= abs_time) return false;
}
- typedef boost::interprocess::scoped_lock<ipcdetail::spin_mutex> InternalLock;
+ typedef boost::interprocess::scoped_lock<spin_mutex> InternalLock;
//The enter mutex guarantees that while executing a notification,
//no other thread can execute the do_timed_wait method.
{
@@ -197,7 +197,7 @@
//We increment the waiting thread count protected so that it will be
//always constant when another thread enters the notification logic.
//The increment marks this thread as "waiting on spin_condition"
- ipcdetail::atomic_inc32(const_cast<boost::uint32_t*>(&m_num_waiters));
+ atomic_inc32(const_cast<boost::uint32_t*>(&m_num_waiters));
//We unlock the external mutex atomically with the increment
mut.unlock();
@@ -211,8 +211,8 @@
while(1){
//The thread sleeps/spins until a spin_condition commands a notification
//Notification occurred, we will lock the checking mutex so that
- while(ipcdetail::atomic_read32(&m_command) == SLEEP){
- ipcdetail::thread_yield();
+ while(atomic_read32(&m_command) == SLEEP){
+ thread_yield();
//Check for timeout
if(tout_enabled){
@@ -240,12 +240,12 @@
//If a timeout occurred, the mutex will not execute checking logic
if(tout_enabled && timed_out){
//Decrement wait count
- ipcdetail::atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+ atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
unlock_enter_mut = true;
break;
}
else{
- boost::uint32_t result = ipcdetail::atomic_cas32
+ boost::uint32_t result = atomic_cas32
(const_cast<boost::uint32_t*>(&m_command), SLEEP, NOTIFY_ONE);
if(result == SLEEP){
//Other thread has been notified and since it was a NOTIFY one
@@ -258,17 +258,17 @@
//so no other thread will exit.
//Decrement wait count.
unlock_enter_mut = true;
- ipcdetail::atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+ atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
break;
}
else{
//If it is a NOTIFY_ALL command, all threads should return
//from do_timed_wait function. Decrement wait count.
- unlock_enter_mut = 1 == ipcdetail::atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+ unlock_enter_mut = 1 == atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
//Check if this is the last thread of notify_all waiters
//Only the last thread will release the mutex
if(unlock_enter_mut){
- ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_command), SLEEP, NOTIFY_ALL);
+ atomic_cas32(const_cast<boost::uint32_t*>(&m_command), SLEEP, NOTIFY_ALL);
}
break;
}
Modified: trunk/boost/interprocess/sync/spin/mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/spin/mutex.hpp (original)
+++ trunk/boost/interprocess/sync/spin/mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -86,8 +86,6 @@
//Obtain current count and target time
boost::posix_time::ptime now = microsec_clock::universal_time();
- if(now >= abs_time) return false;
-
do{
if(this->try_lock()){
break;
Modified: trunk/boost/interprocess/sync/spin/recursive_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/spin/recursive_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/spin/recursive_mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -163,8 +163,7 @@
typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
this->m_nLockCount = 1;
const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
- ipcdetail::systemwide_thread_id_copy
- (thr_id, m_nOwner);
+ ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
}
} //namespace ipcdetail {
Modified: trunk/boost/interprocess/sync/spin/semaphore.hpp
==============================================================================
--- trunk/boost/interprocess/sync/spin/semaphore.hpp (original)
+++ trunk/boost/interprocess/sync/spin/semaphore.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -79,8 +79,6 @@
}
//Obtain current count and target time
boost::posix_time::ptime now(microsec_clock::universal_time());
- if(now >= abs_time)
- return false;
do{
if(this->try_wait()){
Modified: trunk/boost/interprocess/sync/windows/mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/windows/mutex.hpp (original)
+++ trunk/boost/interprocess/sync/windows/mutex.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -104,22 +104,17 @@
boost::posix_time::ptime now
= boost::posix_time::microsec_clock::universal_time();
- if(abs_time < now){
- return false;
- }
- else{
- unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
- sync_handles &handles =
- intermodule_singleton<sync_handles>::get();
- //This can throw
- void *hnd = handles.obtain_mutex(this->id_);
- unsigned long ret = winapi::wait_for_single_object(hnd, ms);
- if(ret == winapi::wait_failed){
- error_info err(winapi::get_last_error());
- throw interprocess_exception(err);
- }
- return ret != winapi::wait_timeout;
+ unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
+ sync_handles &handles =
+ intermodule_singleton<sync_handles>::get();
+ //This can throw
+ void *hnd = handles.obtain_mutex(this->id_);
+ unsigned long ret = winapi::wait_for_single_object(hnd, ms);
+ if(ret == winapi::wait_failed){
+ error_info err(winapi::get_last_error());
+ throw interprocess_exception(err);
}
+ return ret != winapi::wait_timeout;
}
inline void windows_mutex::unlock(void)
Modified: trunk/boost/interprocess/sync/windows/semaphore.hpp
==============================================================================
--- trunk/boost/interprocess/sync/windows/semaphore.hpp (original)
+++ trunk/boost/interprocess/sync/windows/semaphore.hpp 2011-12-26 06:08:44 EST (Mon, 26 Dec 2011)
@@ -103,22 +103,17 @@
boost::posix_time::ptime now
= boost::posix_time::microsec_clock::universal_time();
- if(abs_time < now){
- return false;
- }
- else{
- unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
- sync_handles &handles =
- intermodule_singleton<sync_handles>::get();
- //This can throw
- void *hnd = handles.obtain_semaphore(this->id_, 0);
- unsigned long ret = winapi::wait_for_single_object(hnd, ms);
- if(ret == winapi::wait_failed){
- error_info err(winapi::get_last_error());
- throw interprocess_exception(err);
- }
- return ret != winapi::wait_timeout;
+ unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
+ sync_handles &handles =
+ intermodule_singleton<sync_handles>::get();
+ //This can throw
+ void *hnd = handles.obtain_semaphore(this->id_, 0);
+ unsigned long ret = winapi::wait_for_single_object(hnd, ms);
+ if(ret == winapi::wait_failed){
+ error_info err(winapi::get_last_error());
+ throw interprocess_exception(err);
}
+ return ret != winapi::wait_timeout;
}
inline void windows_semaphore::post(long release_count)