Ticket #8797: 0001-thread-semaphore-implementation.patch

new file oost/thread/apple/semaphore_dispatch.hpp

@@ +1 @@
+// semaphore.hpp, osx/ios dispatch semaphores
+//
+// Copyright (C) 2013 Tim Blechmann
+//
+// 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)
+
+#ifndef BOOST_THREAD_APPLE_SEMAPHORE_DISPATCH_HPP
+#define BOOST_THREAD_APPLE_SEMAPHORE_DISPATCH_HPP
+
+#include <dispatch/dispatch.h>
+
+#include <boost/thread/exceptions.hpp>
+
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
+
+namespace boost {
+
+class semaphore
+{
+  BOOST_DELETED_FUNCTION(semaphore(semaphore const&))
+  BOOST_DELETED_FUNCTION(semaphore& operator=(semaphore const&))
+
+public:
+  semaphore(int i=0)
+  {
+    BOOST_ASSERT_MSG(i >= 0, "boost::semaphore constructor called with negative count");
+    sem = dispatch_semaphore_create(i);
+    if (sem == NULL)
+      boost::throw_exception(thread_resource_error(system::errc::not_enough_memory, "boost::semaphore constructor failed in dispatch_semaphore_create"));
+  }
+
+  ~semaphore()
+  {
+    dispatch_release(sem);
+  }
+
+  void post()
+  {
+    dispatch_semaphore_signal(sem);
+  }
+
+  void wait()
+  {
+    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  }
+
+  bool try_wait(void)
+  {
+    const long status = dispatch_semaphore_wait(sem, DISPATCH_TIME_NOW);
+    return status == 0;
+  }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+  template <class Rep, class Period>
+  bool try_wait_for(const chrono::duration<Rep, Period> & rel_time)
+  {
+    return try_wait_until(chrono::steady_clock::now() + rel_time);
+  }
+
+  template <class Clock, class Duration>
+  bool try_wait_until(const chrono::time_point<Clock, Duration> & timeout )
+  {
+    using namespace chrono;
+    system_clock::time_point    s_now = system_clock::now();
+    typename Clock::time_point  c_now = Clock::now();
+    return try_wait_until(s_now + ceil<nanoseconds>(timeout - c_now));
+  }
+
+  template <class Duration>
+  bool try_wait_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+  {
+    using namespace chrono;
+    typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+    return try_wait_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+  }
+
+  bool try_wait_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+  {
+    chrono::nanoseconds d = tp.time_since_epoch();
+    timespec ts = boost::detail::to_timespec(d);
+    return do_wait_lock_until(dispatch_walltime(&ts, 0));
+  }
+
+private:
+  bool do_wait_lock_until(const dispatch_time_t timeout)
+  {
+    const long status = dispatch_semaphore_wait(sem, timeout);
+    return status == 0;
+  }
+
+#endif // BOOST_THREAD_USES_CHRONO
+
+
+private:
+  dispatch_semaphore_t sem;
+};
+
+}
+
+#endif // BOOST_THREAD_APPLE_SEMAPHORE_DISPATCH_HPP

new file oost/thread/detail/semaphore_emulation.hpp

@@ +1 @@
+// semaphore.hpp, mutex/condition_varibale emulation
+//
+// Copyright (C) 2013 Tim Blechmann
+//
+// 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)
+
+#ifndef BOOST_THREAD_DETAIL_SEMAPHORE_EMULATION_HPP
+#define BOOST_THREAD_DETAIL_SEMAPHORE_EMULATION_HPP
+
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
+
+namespace boost {
+
+class semaphore
+{
+        BOOST_DELETED_FUNCTION(semaphore(semaphore const&))
+    BOOST_DELETED_FUNCTION(semaphore& operator=(semaphore const&))
+
+public:
+  semaphore(int i=0):
+    m_count(i)
+  {
+    BOOST_ASSERT_MSG(i >= 0, "boost::semaphore constructor called with negative count");
+  }
+
+  void post(void)
+  {
+    mutex::scoped_lock lock(m_mutex);
+    ++m_count;
+    m_cond.notify_one();
+  }
+
+  void wait(void)
+  {
+    mutex::scoped_lock lock(m_mutex);
+    m_cond.wait(lock, boost::bind(&semaphore::check_wakeup_condition, this));
+
+    --m_count;
+  }
+
+  bool try_wait(void)
+  {
+    mutex::scoped_lock lock(m_mutex);
+    if (!check_wakeup_condition())
+      return false;
+
+    --m_count;
+    return true;
+  }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+  template <class Rep, class Period>
+  bool try_wait_for(const chrono::duration<Rep, Period> & rel_time)
+  {
+    mutex::scoped_lock lock(m_mutex);
+    return m_cond.wait_for(lock, rel_time, boost::bind(&semaphore::check_wakeup_condition, this));
+  }
+
+  template <class Clock, class Duration>
+  bool try_wait_until(const chrono::time_point<Clock, Duration> & timeout )
+  {
+    mutex::scoped_lock lock(m_mutex);
+    return m_cond.wait_until(lock, timeout, boost::bind(&semaphore::check_wakeup_condition, this));
+  }
+#endif // BOOST_THREAD_USES_CHRONO
+
+private:
+  bool check_wakeup_condition()
+  {
+    return m_count > 0;
+  }
+
+  unsigned int m_count;
+  boost::mutex m_mutex;
+  boost::condition_variable m_cond;
+};
+
+}
+
+#endif // BOOST_THREAD_DETAIL_SEMAPHORE_EMULATION_HPP

new file oost/thread/pthread/semaphore_posix.hpp

@@ +1 @@
+// semaphore.hpp, posix implementation
+//
+// Copyright (C) 2013 Tim Blechmann
+//
+// 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)
+
+
+#ifndef BOOST_THREAD_PTHREAD_SEMAPHORE_POSIX_HPP
+#define BOOST_THREAD_PTHREAD_SEMAPHORE_POSIX_HPP
+
+#include <semaphore.h>
+
+#include <boost/assert.hpp>
+#include <boost/thread/exceptions.hpp>
+
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
+
+namespace boost {
+
+class semaphore
+{
+  BOOST_DELETED_FUNCTION(semaphore(semaphore const&))
+  BOOST_DELETED_FUNCTION(semaphore& operator=(semaphore const&))
+
+public:
+  semaphore(int i=0)
+  {
+    BOOST_ASSERT_MSG(i >= 0, "boost::semaphore constructor called with negative count");
+
+    const int status = sem_init(&sem, 0, i);
+    if (status)
+      boost::throw_exception(thread_resource_error(status, "boost::semaphore constructor failed in sem_init"));
+  }
+
+  ~semaphore()
+  {
+    const int status = sem_destroy(&sem);
+    (void)status;
+    BOOST_ASSERT(!status);
+  }
+
+  void post()
+  {
+    const int status = sem_post(&sem);
+
+    switch (status)
+    {
+    case EOVERFLOW:
+      boost::throw_exception(thread_resource_error(status, "boost::semaphore post failed: Maximum allowable value would be exceeded"));
+      break;
+
+    case EINVAL:
+      BOOST_ASSERT(false);
+
+    default:
+      break;
+    }
+  }
+
+  void wait(void)
+  {
+    for (;;)
+    {
+      const int status = sem_wait(&sem);
+      if (status == 0)
+        return;
+
+      switch (errno)
+      {
+      case EINTR: // interrupted by a signal handler
+        continue;
+
+      case EINVAL:
+      default:
+        // we should not reach here
+        BOOST_ASSERT(false);
+        return;
+      }
+    }
+  }
+
+  bool try_wait(void)
+  {
+    const int status = sem_trywait(&sem);
+    if (status == 0)
+      return true;
+
+    switch (errno)
+    {
+    case EINVAL:
+      BOOST_ASSERT(false);
+
+    case EAGAIN:
+      return false;
+
+    default:
+      return false;
+    }
+  }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+  template <class Rep, class Period>
+  bool try_wait_for(const chrono::duration<Rep, Period> & rel_time)
+  {
+    return try_wait_until(chrono::steady_clock::now() + rel_time);
+  }
+
+  template <class Clock, class Duration>
+  bool try_wait_until(const chrono::time_point<Clock, Duration> & timeout )
+  {
+    using namespace chrono;
+    system_clock::time_point    s_now = system_clock::now();
+    typename Clock::time_point  c_now = Clock::now();
+    return try_wait_until(s_now + ceil<nanoseconds>(timeout - c_now));
+  }
+
+  template <class Duration>
+  bool try_wait_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+  {
+    using namespace chrono;
+    typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+    return try_wait_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+  }
+
+  bool try_wait_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+  {
+    chrono::nanoseconds d = tp.time_since_epoch();
+    timespec ts = boost::detail::to_timespec(d);
+    return do_wait_lock_until(ts);
+  }
+
+private:
+  bool do_wait_lock_until(struct timespec const & timeout)
+  {
+    for (;;) {
+      const int status = sem_timedwait(&sem, &timeout);
+      if (status == 0)
+        return true;
+
+      switch (errno)
+      {
+      case ETIMEDOUT:
+        return false;
+
+      case EINTR: // interrupted by a signal handler
+        continue;
+
+      case EINVAL:
+      case EAGAIN:
+      default:
+        BOOST_ASSERT(false);
+        return false;
+      }
+    }
+  }
+
+#endif // BOOST_THREAD_USES_CHRONO
+
+private:
+  sem_t sem;
+};
+
+}
+
+#endif /* BOOST_THREAD_PTHREAD_SEMAPHORE_POSIX_HPP */

new file oost/thread/semaphore.hpp

@@ +1 @@
+// semaphore.hpp
+//
+// Copyright (C) 2013 Tim Blechmann
+//
+// 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)
+
+#ifndef BOOST_THREAD_SEMAPHORE_HPP
+#define BOOST_THREAD_SEMAPHORE_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+
+// configuration helpers
+
+#ifdef BOOST_HAS_UNISTD_H
+#include <unistd.h>
+
+#if (_POSIX_SEMAPHORES - 0) >= 200112L
+#define BOOST_THREAD_POSIX_SEMAPHORES
+#endif
+
+#endif // BOOST_HAS_UNISTD_H
+
+#if defined(__APPLE__)
+#include <Availability.h>
+
+// OSX
+#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
+
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_6
+#define BOOST_THREAD_DISPATCH_SEMAPHORES
+#endif
+
+#endif
+
+// iOS
+#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
+
+// untested!
+#if __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_4_0
+#define BOOST_THREAD_DISPATCH_SEMAPHORES
+#endif
+
+#endif
+
+
+#endif // __APPLE__
+
+
+// implementation
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/semaphore_win32.hpp>
+
+#elif defined(BOOST_THREAD_POSIX_SEMAPHORES)
+#include <boost/thread/pthread/semaphore_posix.hpp>
+
+#elif defined(BOOST_THREAD_DISPATCH_SEMAPHORES)
+#include <boost/thread/apple/semaphore_dispatch.hpp>
+
+#else
+#include <boost/thread/detail/semaphore_emulation.hpp>
+
+#endif
+
+
+#endif // BOOST_THREAD_SEMAPHORE_HPP

new file oost/thread/win32/semaphore_win32.hpp

@@ +1 @@
+// semaphore.hpp, win32 semaphores
+//
+// Copyright (C) 2013 Tim Blechmann
+//
+// 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)
+
+#ifndef BOOST_THREAD_WIN32_SEMAPHORE_WIN32_HPP
+#define BOOST_THREAD_WIN32_SEMAPHORE_WIN32_HPP
+
+#include <boost/thread/win32/thread_primitives.hpp>
+
+namespace boost {
+
+class semaphore
+{
+  BOOST_DELETED_FUNCTION(semaphore(semaphore const&))
+  BOOST_DELETED_FUNCTION(semaphore& operator=(semaphore const&))
+
+public:
+  semaphore(int i=0);
+
+  ~semaphore();
+
+  void post();
+
+  bool wait();
+
+  bool try_wait(void);
+
+private:
+  detail::win32::HANDLE sem_;
+};
+
+}
+
+#endif // BOOST_THREAD_WIN32_SEMAPHORE_WIN32_HPP

new file libs/thread/doc/semaphore.qbk

@@ +1 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  (C) Copyright 2013 Tim Blechmann.
+  (C) Copyright 2005-2012 Ion Gaztanaga
+  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).
+]
+
+[section:semaphore semaphores]
+
+[section:semaphores_whats_a_semaphores What's A Semaphore?]
+
+A semaphore is a synchronization mechanism between processes based in an internal
+count that offers two basic operations:
+
+*  [*Wait]: Tests the value of the semaphore count, and waits if the value is less than or
+   equal than 0. Otherwise, decrements the semaphore count.
+
+*  [*Post]: Increments the semaphore count. If any process is blocked, one of those processes
+   is awoken.
+
+If the initial semaphore count is initialized to 1, a [*Wait] operation is equivalent to a
+mutex locking and [*Post] is equivalent to a mutex unlocking. This type of semaphore is known
+as a [*binary semaphore].
+
+Although semaphores can be used like mutexes, they have a unique feature: unlike mutexes,
+a [*Post] operation need not be executed by the same thread/process that executed the
+[*Wait] operation.
+
+[endsect]
+
+[section:semaphore_class Class `semaphore`]
+
+  #include <boost/thread/semaphore.hpp>
+
+  namespace boost
+  {
+    class semaphore
+    {
+    public:
+      semaphore(int initial_count = 0);
+
+      semaphore(semaphore const&) = delete;
+      semaphore& operator=(semaphore const&) = delete;
+
+      void post();
+      void wait();
+      bool try_wait();
+
+  #ifdef BOOST_THREAD_USES_CHRONO
+      template <class Rep, class Period>
+      bool try_wait_for(const chrono::duration<Rep, Period> & duration);
+
+      template <class Clock, class Duration>
+      bool try_wait_until(const chrono::time_point<Clock, Duration> & timeout);
+  #endif
+    };
+  }
+
+
+[section:constructor `semaphore()`]
+
+[variablelist
+
+[[Effects:] [Constructs an object of class `semaphore`. The semaphore is initialized to `initial_count`, 
+which is expected to be non-negative.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+
+[section:destructor `~semaphore()`]
+
+[variablelist
+
+[[Precondition:] [No thread is waiting on `*this`]]
+
+[[Effects:] [Destroys the object.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[section:post `post()`]
+
+[variablelist
+
+[[Effects:] [Increments the semaphore count. If a thread is waiting for `*this`, it will be unblocked.]]
+
+[[Throws:] [__thread_resource_error__ if an error (e.g. counter overflow) occurs.]]
+
+]
+
+[endsect]
+
+
+[section:wait `wait()`]
+
+[variablelist
+
+[[Effects:] [If the semaphore count is positive, it atomically decrements it and returns. Otherwise blocks
+the current thread, until it can successfully decrement a positive semaphore count.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+
+[section:try_wait `try_wait()`]
+
+[variablelist
+
+[[Effects:] [If the semaphore count is positive, it atomically decrements it and returns `true`. Otherwise `false`.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+
+[section:try_wait `template <class Rep, class Period> bool try_wait_for(const chrono::duration<Rep, Period> & duration)`]
+
+[variablelist
+
+[[Effects:] [If the semaphore count is positive, it atomically decrements it and returns `true`. Otherwise it waits for the semaphore
+for `duration`.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+
+[section:try_wait `template <class Clock, class Duration> bool try_wait_until(const chrono::time_point<Clock, Duration> & timeout)`]
+
+[variablelist
+
+[[Effects:] [If the semaphore count is positive, it atomically decrements it and returns `true`. Otherwise it waits for the semaphore
+until `timeout`.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+
+[endsect]
+
+[endsect]
+
+[endsect]

libs/thread/doc/thread.qbk

@@ -241 +241 @@
 [include barrier.qbk]
 [/include latch.qbk]
 [include futures.qbk]
+[include semaphore.qbk]
 [/include async_executors.qbk]
 [endsect]
 

libs/thread/src/win32/thread.cpp

@@ -20 +20 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/detail/tss_hooks.hpp>
 #include <boost/thread/future.hpp>
+#include <boost/thread/semaphore.hpp>
 
 #include <boost/assert.hpp>
 #if defined BOOST_THREAD_USES_DATETIME
@@ -747 +748 @@
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+
+    semaphore::semaphore(int i)
+    {
+      BOOST_ASSERT_MSG(i >= 0, "boost::semaphore constructor called with negative count");
+
+      sem_ = CreateSemaphore(NULL, i, (std::numeric_limits<LONG>::max)(), NULL);
+      if (!sem_)
+        boost::throw_exception(thread_resource_error(GetLastError(), "boost::semaphore constructor failed in CreateSemaphore"));
+    }
+
+    semaphore::~semaphore()
+    {
+      CloseHandle(sem_);
+    }
+
+    void semaphore::post()
+    {
+      const BOOL status = ReleaseSemaphore(sem_, 1, NULL);
+      if (status == 0)
+        boost::throw_exception(thread_resource_error(GetLastError(), "boost::semaphore::post failed in ReleaseSemaphore"));
+    }
+
+    bool semaphore::wait()
+    {
+      const DWORD status = WaitForSingleObject(sem_, INFINITE);
+
+      switch (status)
+      {
+      case WAIT_OBJECT_0:
+        return true;
+
+      case WAIT_FAILED:
+        boost::throw_exception(thread_resource_error(GetLastError(), "boost::semaphore::wait failed in ReleaseSemaphore"));
+
+      default:
+        BOOST_ASSERT(false);
+        return false;
+      }
+    }
+
+    bool semaphore::try_wait()
+    {
+      const DWORD status = WaitForSingleObject(sem_, 0L);
+
+      switch (status)
+      {
+      case WAIT_OBJECT_0:
+        return true;
+
+      case WAIT_TIMEOUT:
+        return false;
+
+      case WAIT_FAILED:
+        boost::throw_exception(thread_resource_error(GetLastError(), "boost::semaphore::wait failed in ReleaseSemaphore"));
+
+      default:
+        BOOST_ASSERT(false);
+        return false;
+      }
+      return true;
+    }
+
 }
 

libs/thread/test/Jamfile.v2

@@ -639 +639 @@
     test-suite ts_sync_bounded_queue
     :
           [ thread-run2-noit ./sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp : sync_bounded_queue__single_thread_p ]
-          [ thread-run2-noit ./sync/mutual_exclusion/sync_bounded_queue/multi_thread_pass.cpp : sync_bounded_queue__multi_thread_p ]
     ;
 
     #explicit ts_this_thread ;

new file libs/thread/test/test_semaphore.cpp

@@ +1 @@
+// Copyright (C) 2013 Tim Blechmann
+//
+//  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/test/unit_test.hpp>
+
+#include <boost/thread.hpp>
+#include <boost/thread/semaphore.hpp>
+
+#include <boost/typeof/typeof.hpp>
+
+static void test_semaphore_post_wait()
+{
+  boost::semaphore sem(0);
+
+  sem.post();
+  sem.wait();
+}
+
+
+static void test_semaphore_try_wait()
+{
+  boost::semaphore sem(0);
+
+  BOOST_REQUIRE(!sem.try_wait());
+  sem.post();
+  BOOST_REQUIRE(sem.try_wait());
+}
+
+
+struct semaphore_wait_and_post_test
+{
+  void run()
+  {
+    boost::thread post_thread(boost::bind(&semaphore_wait_and_post_test::wait_and_post, this));
+    sem_.wait();
+  }
+
+  void wait_and_post()
+  {
+    boost::this_thread::sleep_for(boost::chrono::seconds(1));
+    sem_.post();
+  }
+
+  static void run_test()
+  {
+    semaphore_wait_and_post_test test;
+    test.run();
+  }
+
+  boost::semaphore sem_;
+  boost::thread thread_;
+};
+
+static void test_semaphore_wait_for()
+{
+  using namespace boost;
+
+  semaphore sem(0);
+
+  BOOST_AUTO(start, chrono::system_clock::now());
+
+  BOOST_REQUIRE(!sem.try_wait_for(chrono::milliseconds(500)));
+
+  BOOST_AUTO(end, chrono::system_clock::now());
+  BOOST_AUTO(wait_time, end - start);
+
+  // guessing!
+  BOOST_REQUIRE( wait_time > chrono::milliseconds(450) );
+  BOOST_REQUIRE( wait_time < chrono::milliseconds(1000) );
+
+  sem.post();
+
+  BOOST_REQUIRE(sem.try_wait_for(chrono::milliseconds(500)));
+}
+
+static void test_semaphore_wait_until()
+{
+  using namespace boost;
+
+  semaphore sem(0);
+  {
+    BOOST_AUTO(now, chrono::system_clock::now());
+    BOOST_AUTO(timeout, now + chrono::milliseconds(500));
+
+    BOOST_REQUIRE(!sem.try_wait_until(timeout));
+
+    BOOST_AUTO(end, chrono::system_clock::now());
+    BOOST_AUTO(timeout_delta, end - timeout);
+
+    // guessing!
+    BOOST_REQUIRE( timeout_delta > chrono::milliseconds(-400) );
+    BOOST_REQUIRE( timeout_delta < chrono::milliseconds(400) );
+  }
+
+  sem.post();
+
+  {
+    BOOST_AUTO(start,   chrono::system_clock::now());
+    BOOST_AUTO(timeout, start + chrono::milliseconds(500));
+
+    BOOST_REQUIRE(sem.try_wait_until(timeout));
+
+    BOOST_AUTO(end, chrono::system_clock::now());
+
+    // guessing!
+    BOOST_REQUIRE( (end - start) < chrono::milliseconds(100) );
+  }
+}
+
+
+boost::unit_test::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: semaphore test suite");
+
+    test->add(BOOST_TEST_CASE(test_semaphore_post_wait));
+    test->add(BOOST_TEST_CASE(test_semaphore_try_wait));
+    test->add(BOOST_TEST_CASE(semaphore_wait_and_post_test::run_test));
+
+    test->add(BOOST_TEST_CASE(test_semaphore_wait_for));
+    test->add(BOOST_TEST_CASE(test_semaphore_wait_until));
+    return test;
+}