[Boost-commit] svn:boost r85688 - in trunk: boost/interprocess/detail libs/interprocess/example libs/interprocess/proj/vc7ide libs/interprocess/test

Subject: [Boost-commit] svn:boost r85688 - in trunk: boost/interprocess/detail libs/interprocess/example libs/interprocess/proj/vc7ide libs/interprocess/test
From: igaztanaga_at_[hidden]
Date: 2013-09-15 15:50:54

Author: igaztanaga
Date: 2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)
New Revision: 85688
URL: http://svn.boost.org/trac/boost/changeset/85688

Log:
Remove boost/thread dependency in tests.

Text files modified: 
   trunk/boost/interprocess/detail/os_thread_functions.hpp       |   104 ++++++++++++++++++++++++++              
   trunk/libs/interprocess/example/Jamfile.v2                    |     4                                         
   trunk/libs/interprocess/proj/vc7ide/interprocesslib.vcproj    |     3                                         
   trunk/libs/interprocess/test/Jamfile.v2                       |     2                                         
   trunk/libs/interprocess/test/boost_interprocess_check.hpp     |     2                                         
   trunk/libs/interprocess/test/condition_test_template.hpp      |   157 +++++++++++++++++---------------------- 
   trunk/libs/interprocess/test/message_queue_test.cpp           |     9 +-                                      
   trunk/libs/interprocess/test/mutex_test_template.hpp          |   130 +++++++++++++++++---------------        
   trunk/libs/interprocess/test/named_creation_template.hpp      |     8 +-                                      
   trunk/libs/interprocess/test/named_semaphore_test.cpp         |    12 +-                                      
   trunk/libs/interprocess/test/sharable_mutex_test_template.hpp |   131 ++++++++++++++++++--------------        
   trunk/libs/interprocess/test/util.hpp                         |    24 +----                                   
   12 files changed, 341 insertions(+), 245 deletions(-)

Modified: trunk/boost/interprocess/detail/os_thread_functions.hpp
==============================================================================
--- trunk/boost/interprocess/detail/os_thread_functions.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/boost/interprocess/detail/os_thread_functions.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2013. 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)
 //
@@ -8,6 +8,17 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
+//Thread launching functions are adapted from boost/detail/lightweight_thread.hpp
+//
+//  boost/detail/lightweight_thread.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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_INTERPROCESS_DETAIL_OS_THREAD_FUNCTIONS_HPP
 #define BOOST_INTERPROCESS_DETAIL_OS_THREAD_FUNCTIONS_HPP
 
@@ -16,9 +27,11 @@
 #include <boost/interprocess/streams/bufferstream.hpp>
 #include <boost/interprocess/detail/posix_time_types_wrk.hpp>
 #include <cstddef>
+#include <memory>
 
 #if defined(BOOST_INTERPROCESS_WINDOWS)
 #  include <boost/interprocess/detail/win32_api.hpp>
+#  include <process.h>
 #else
 #  include <pthread.h>
 #  include <unistd.h>
@@ -56,6 +69,7 @@
 
 typedef unsigned long OS_process_id_t;
 typedef unsigned long OS_thread_id_t;
+typedef void*         OS_thread_t;
 typedef OS_thread_id_t OS_systemwide_thread_id_t;
 
 //process
@@ -198,6 +212,7 @@
 
 #else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
 
+typedef pthread_t OS_thread_t;
 typedef pthread_t OS_thread_id_t;
 typedef pid_t     OS_process_id_t;
 
@@ -446,6 +461,12 @@
    #endif
 }
 
+inline int thread_create(OS_thread_t * thread, void *(*start_routine)(void*), void* arg)
+{  return pthread_create(thread, 0, start_routine, arg); }
+
+inline void thread_join(OS_thread_t thread)
+{  (void)pthread_join(thread, 0);  }
+
 #endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
 
 typedef char pid_str_t[sizeof(OS_process_id_t)*3+1];
@@ -459,6 +480,87 @@
 inline void get_pid_str(pid_str_t &pid_str)
 {  get_pid_str(pid_str, get_current_process_id());  }
 
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+inline int thread_create( OS_thread_t * thread, unsigned (__stdcall * start_routine) (void*), void* arg )
+{
+   void* h = (void*)_beginthreadex( 0, 0, start_routine, arg, 0, 0 );
+
+   if( h != 0 ){
+      *thread = h;
+      return 0;
+   }
+   else{
+      return EAGAIN;
+   }
+}
+
+inline void thread_join( OS_thread_t thread)
+{
+   winapi::wait_for_single_object( thread, winapi::infinite_time );
+   winapi::close_handle( thread );
+}
+
+#endif
+
+class abstract_thread
+{
+   public:
+   virtual ~abstract_thread() {}
+   virtual void run() = 0;
+};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+inline unsigned __stdcall launch_thread_routine( void * pv )
+{
+   std::auto_ptr<abstract_thread> pt( static_cast<abstract_thread *>( pv ) );
+   pt->run();
+   return 0;
+}
+
+#else
+
+extern "C" void * launch_thread_routine( void * pv );
+
+inline void * launch_thread_routine( void * pv )
+{
+   std::auto_ptr<abstract_thread> pt( static_cast<abstract_thread *>( pv ) );
+   pt->run();
+   return 0;
+}
+
+#endif
+
+template<class F>
+class launch_thread_impl
+   : public abstract_thread
+{
+   public:
+   explicit launch_thread_impl( F f )
+      : f_( f )
+   {}
+
+   void run()
+   {  f_();  }
+
+   private:
+   F f_;
+};
+
+template<class F>
+inline int thread_launch( OS_thread_t & pt, F f )
+{
+   std::auto_ptr<abstract_thread> p( new launch_thread_impl<F>( f ) );
+
+   int r = thread_create(&pt, launch_thread_routine, p.get());
+   if( r == 0 ){
+      p.release();
+   }
+
+   return r;
+}
+
 }  //namespace ipcdetail{
 }  //namespace interprocess {
 }  //namespace boost {

Modified: trunk/libs/interprocess/example/Jamfile.v2
==============================================================================
--- trunk/libs/interprocess/example/Jamfile.v2	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/example/Jamfile.v2	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -21,7 +21,7 @@
 
    for local fileb in [ glob comp*.cpp ]
    {
-      all_rules += [ link $(fileb) /boost/thread//boost_thread
+      all_rules += [ link $(fileb)
       :  # additional args
         <toolset>acc:<linkflags>-lrt
         <toolset>acc-pa_risc:<linkflags>-lrt
@@ -35,7 +35,7 @@
 
    for local fileb in [ glob doc_*.cpp ]
    {
-      all_rules += [ run $(fileb) /boost/thread//boost_thread
+      all_rules += [ run $(fileb)
       :  # additional args
       :  # test-files
       :  # requirements

Modified: trunk/libs/interprocess/proj/vc7ide/interprocesslib.vcproj
==============================================================================
--- trunk/libs/interprocess/proj/vc7ide/interprocesslib.vcproj	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/proj/vc7ide/interprocesslib.vcproj	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -297,6 +297,9 @@
                                 <File
                                         RelativePath="..\..\..\..\boost\interprocess\sync\spin\semaphore.hpp">
                                 </File>
+				<File
+					RelativePath="..\..\..\..\boost\interprocess\sync\spin\wait.hpp">
+				</File>
                         </Filter>
                         <Filter
                                 Name="xsi"

Modified: trunk/libs/interprocess/test/Jamfile.v2
==============================================================================
--- trunk/libs/interprocess/test/Jamfile.v2	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/Jamfile.v2	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -21,7 +21,7 @@
 
    for local fileb in [ glob *.cpp ]
    {
-      all_rules += [ run $(fileb) /boost/thread//boost_thread
+      all_rules += [ run $(fileb)
       :  # additional args
       :  # test-files
       :  # requirements

Modified: trunk/libs/interprocess/test/boost_interprocess_check.hpp
==============================================================================
--- trunk/libs/interprocess/test/boost_interprocess_check.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/boost_interprocess_check.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -17,7 +17,7 @@
 
 namespace boost { namespace interprocess { namespace test {
 
-#define BOOST_INTERPROCES_CHECK( P )  \
+#define BOOST_INTERPROCESS_CHECK( P )  \
    if(!(P)) do{  assert(P); std::cout << "Failed: " << #P << " file: " << __FILE__ << " line : " << __LINE__ << std::endl; throw boost::interprocess::interprocess_exception(#P);}while(0)
 
 }}}   //namespace boost { namespace interprocess { namespace test {

Modified: trunk/libs/interprocess/test/condition_test_template.hpp
==============================================================================
--- trunk/libs/interprocess/test/condition_test_template.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/condition_test_template.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -22,13 +22,10 @@
 
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
 #include "boost_interprocess_check.hpp"
-#include <boost/thread/detail/config.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
-#include <boost/thread/thread.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/version.hpp>
 #include <iostream>
 
 namespace boost{
@@ -41,31 +38,6 @@
             boost::posix_time::time_duration(0, 0, secs);
 }
 
-inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
-{
-    const int MILLISECONDS_PER_SECOND = 1000;
-    const int NANOSECONDS_PER_SECOND = 1000000000;
-    const int NANOSECONDS_PER_MILLISECOND = 1000000;
-
-    boost::xtime xt;
-
-    #if BOOST_VERSION >= 105100 //TIME_UTC is a macro in C11, breaking change in Boost.Thread
-    int ret = boost::xtime_get(&xt, boost::TIME_UTC_);
-    BOOST_INTERPROCES_CHECK(ret == static_cast<int>(boost::TIME_UTC_));(void)ret;
-    #else
-    int ret = boost::xtime_get(&xt, boost::TIME_UTC);
-    BOOST_INTERPROCES_CHECK(ret == static_cast<int>(boost::TIME_UTC));(void)ret;
-    #endif
-    nsecs += xt.nsec;
-    msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
-    secs += msecs / MILLISECONDS_PER_SECOND;
-    nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
-    xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
-    xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
-
-    return xt;
-}
-
 template <typename F, typename T>
 class binder
 {
@@ -104,10 +76,10 @@
 {
     boost::interprocess::scoped_lock<Mutex>
       lock(data->mutex);
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
     while (!(data->notified > 0))
         data->condition.wait(lock);
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
     data->awoken++;
 }
 
@@ -126,38 +98,38 @@
 {
     boost::interprocess::scoped_lock<Mutex>
       lock(data->mutex);
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
 
     // Test wait.
     while (data->notified != 1)
         data->condition.wait(lock);
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
-    BOOST_INTERPROCES_CHECK(data->notified == 1);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(data->notified == 1);
     data->awoken++;
     data->condition.notify_one();
 
     // Test predicate wait.
     data->condition.wait(lock, cond_predicate(data->notified, 2));
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
-    BOOST_INTERPROCES_CHECK(data->notified == 2);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(data->notified == 2);
     data->awoken++;
     data->condition.notify_one();
 
     // Test timed_wait.
     while (data->notified != 3)
         data->condition.timed_wait(lock, ptime_delay(5));
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
-    BOOST_INTERPROCES_CHECK(data->notified == 3);
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(data->notified == 3);
     data->awoken++;
     data->condition.notify_one();
 
     // Test predicate timed_wait.
     cond_predicate pred(data->notified, 4);
     bool ret = data->condition.timed_wait(lock, ptime_delay(5), pred);
-    BOOST_INTERPROCES_CHECK(ret);(void)ret;
-    BOOST_INTERPROCES_CHECK(lock ? true : false);
-    BOOST_INTERPROCES_CHECK(pred());
-    BOOST_INTERPROCES_CHECK(data->notified == 4);
+    BOOST_INTERPROCESS_CHECK(ret);(void)ret;
+    BOOST_INTERPROCESS_CHECK(lock ? true : false);
+    BOOST_INTERPROCESS_CHECK(pred());
+    BOOST_INTERPROCESS_CHECK(data->notified == 4);
     data->awoken++;
     data->condition.notify_one();
 }
@@ -167,92 +139,97 @@
 {
    condition_test_data<Condition, Mutex> data;
 
-   boost::thread thread(bind_function(&condition_test_thread<Condition, Mutex>, &data));
+   boost::interprocess::ipcdetail::OS_thread_t thread;
+   boost::interprocess::ipcdetail::thread_launch(thread, bind_function(&condition_test_thread<Condition, Mutex>, &data));
    //Make sure thread is blocked
-   boost::thread::sleep(delay(1));
+   boost::interprocess::ipcdetail::thread_sleep(1000);
    {
       boost::interprocess::scoped_lock<Mutex>
          lock(data.mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
       data.notified++;
       data.condition.notify_one();
    }
 
-   thread.join();
-   BOOST_INTERPROCES_CHECK(data.awoken == 1);
+   boost::interprocess::ipcdetail::thread_join(thread);
+   BOOST_INTERPROCESS_CHECK(data.awoken == 1);
 }
 
 template <class Condition, class Mutex>
 void do_test_condition_notify_all()
 {
    const int NUMTHREADS = 3;
-   boost::thread_group threads;
+
+   boost::interprocess::ipcdetail::OS_thread_t thgroup[NUMTHREADS];
    condition_test_data<Condition, Mutex> data;
 
-   for (int i = 0; i < NUMTHREADS; ++i){
-       threads.create_thread(bind_function(&condition_test_thread<Condition, Mutex>, &data));
+   for(int i = 0; i< NUMTHREADS; ++i){
+      boost::interprocess::ipcdetail::thread_launch(thgroup[i], bind_function(&condition_test_thread<Condition, Mutex>, &data));
    }
+
    //Make sure all threads are blocked
-   boost::thread::sleep(delay(1));
+   boost::interprocess::ipcdetail::thread_sleep(1000);
    {
       boost::interprocess::scoped_lock<Mutex>
          lock(data.mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
       data.notified++;
    }
    data.condition.notify_all();
 
-   threads.join_all();
-   BOOST_INTERPROCES_CHECK(data.awoken == NUMTHREADS);
+   for(int i = 0; i< NUMTHREADS; ++i){
+      boost::interprocess::ipcdetail::thread_join(thgroup[i]);
+   }
+   BOOST_INTERPROCESS_CHECK(data.awoken == NUMTHREADS);
 }
 
 template <class Condition, class Mutex>
 void do_test_condition_waits()
 {
    condition_test_data<Condition, Mutex> data;
-
-   boost::thread thread(bind_function(&condition_test_waits<Condition, Mutex>, &data));
+   boost::interprocess::ipcdetail::OS_thread_t thread;
+   boost::interprocess::ipcdetail::thread_launch(thread, bind_function(&condition_test_waits<Condition, Mutex>, &data));
 
    {
       boost::interprocess::scoped_lock<Mutex>
          lock(data.mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
 
-      boost::thread::sleep(delay(1));
+      boost::interprocess::ipcdetail::thread_sleep(1000);
       data.notified++;
       data.condition.notify_one();
       while (data.awoken != 1)
          data.condition.wait(lock);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
-      BOOST_INTERPROCES_CHECK(data.awoken == 1);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(data.awoken == 1);
 
-      boost::thread::sleep(delay(1));
+      boost::interprocess::ipcdetail::thread_sleep(1000);
       data.notified++;
       data.condition.notify_one();
       while (data.awoken != 2)
          data.condition.wait(lock);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
-      BOOST_INTERPROCES_CHECK(data.awoken == 2);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(data.awoken == 2);
 
-      boost::thread::sleep(delay(1));
+      boost::interprocess::ipcdetail::thread_sleep(1000);
       data.notified++;
       data.condition.notify_one();
       while (data.awoken != 3)
          data.condition.wait(lock);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
-      BOOST_INTERPROCES_CHECK(data.awoken == 3);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(data.awoken == 3);
 
-      boost::thread::sleep(delay(1));
+      boost::interprocess::ipcdetail::thread_sleep(1000);
       data.notified++;
       data.condition.notify_one();
       while (data.awoken != 4)
          data.condition.wait(lock);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
-      BOOST_INTERPROCES_CHECK(data.awoken == 4);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(data.awoken == 4);
    }
 
-   thread.join();
-   BOOST_INTERPROCES_CHECK(data.awoken == 4);
+   boost::interprocess::ipcdetail::thread_join(thread);
+   BOOST_INTERPROCESS_CHECK(data.awoken == 4);
 }
 /*
 //Message queue simulation test
@@ -326,16 +303,15 @@
       waiting_readers = 0;
       waiting_writer  = 0;
 
-      boost::thread_group thgroup;
-      int i;
-      for(i = 0; i< NumThreads; ++i){
+      boost::interprocess::ipcdetail::OS_thread_t thgroup[NumThreads];
+      for(int i = 0; i< NumThreads; ++i){
          condition_func<Condition, Mutex> func(cond_full, cond_empty, mutex);
-         thgroup.create_thread(func);
+         boost::interprocess::ipcdetail::thread_launch(thgroup[i], func);
       }
 
       //Add 20 elements one by one in the queue simulation
       //The sender will block if it fills the queue
-      for(i = 0; i < NumThreads; ++i){
+      for(int i = 0; i < NumThreads; ++i){
          boost::interprocess::scoped_lock<Mutex> lock(mutex);
          while(count == queue_size){
             ++waiting_writer;
@@ -347,10 +323,12 @@
          if(waiting_readers)
             cond_empty.notify_one();
       }
-      thgroup.join_all();
-      BOOST_INTERPROCES_CHECK(count == 0);
-      BOOST_INTERPROCES_CHECK(waiting_readers == 0);
-      BOOST_INTERPROCES_CHECK(waiting_writer  == 0);
+      for(int i = 0; i< NumThreads; ++i){
+         boost::interprocess::ipcdetail::thread_join(thgroup[i]);
+      }
+      BOOST_INTERPROCESS_CHECK(count == 0);
+      BOOST_INTERPROCESS_CHECK(waiting_readers == 0);
+      BOOST_INTERPROCESS_CHECK(waiting_writer  == 0);
    }
 }
 
@@ -370,15 +348,14 @@
       waiting_readers = 0;
       waiting_writer  = 0;
 
-      boost::thread_group thgroup;
-      int i;
-      for(i = 0; i< NumThreads; ++i){
+      boost::interprocess::ipcdetail::OS_thread_t thgroup[NumThreads];
+      for(int i = 0; i< NumThreads; ++i){
          condition_func<Condition, Mutex> func(cond_full, cond_empty, mutex);
-         thgroup.create_thread(func);
+         boost::interprocess::ipcdetail::thread_launch(thgroup[i], func);
       }
 
       //Fill queue to the max size and notify all several times
-      for(i = 0; i < NumThreads; ++i){
+      for(int i = 0; i < NumThreads; ++i){
          boost::interprocess::scoped_lock<Mutex>lock(mutex);
          while(count == queue_size){
             ++waiting_writer;
@@ -390,10 +367,12 @@
          if(waiting_readers)
             cond_empty.notify_all();
       }
-      thgroup.join_all();
-      BOOST_INTERPROCES_CHECK(count == 0);
-      BOOST_INTERPROCES_CHECK(waiting_readers == 0);
-      BOOST_INTERPROCES_CHECK(waiting_writer  == 0);
+      for(int i = 0; i< NumThreads; ++i){
+         boost::interprocess::ipcdetail::thread_join(thgroup[i]);
+      }
+      BOOST_INTERPROCESS_CHECK(count == 0);
+      BOOST_INTERPROCESS_CHECK(waiting_readers == 0);
+      BOOST_INTERPROCESS_CHECK(waiting_writer  == 0);
    }
 }
 

Modified: trunk/libs/interprocess/test/message_queue_test.cpp
==============================================================================
--- trunk/libs/interprocess/test/message_queue_test.cpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/message_queue_test.cpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -15,10 +15,10 @@
 #include <boost/interprocess/containers/map.hpp>
 #include <boost/interprocess/containers/set.hpp>
 #include <boost/interprocess/allocators/node_allocator.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
 #include <vector>
 #include <cstddef>
 #include <limits>
-#include <boost/thread.hpp>
 #include <memory>
 #include <string>
 #include "get_process_id_name.hpp"
@@ -251,8 +251,9 @@
       pmessage_queue = ptr.get();
 
       //Launch the receiver thread
-      boost::thread thread(&receiver);
-      boost::thread::yield();
+      boost::interprocess::ipcdetail::OS_thread_t thread;
+      boost::interprocess::ipcdetail::thread_launch(thread, &receiver);
+      boost::interprocess::ipcdetail::thread_yield();
 
       int nummsg = NumMsg;
 
@@ -260,7 +261,7 @@
          pmessage_queue->send(msgsend, MsgSize, 0);
       }
 
-      thread.join();
+      boost::interprocess::ipcdetail::thread_join(thread);
    }
    boost::interprocess::message_queue::remove(test::get_process_id_name());
    return true;

Modified: trunk/libs/interprocess/test/mutex_test_template.hpp
==============================================================================
--- trunk/libs/interprocess/test/mutex_test_template.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/mutex_test_template.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -25,7 +25,7 @@
 #include <boost/interprocess/exceptions.hpp>
 #include "boost_interprocess_check.hpp"
 #include "util.hpp"
-#include <boost/thread/thread.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <iostream>
@@ -46,16 +46,16 @@
       // Test the lock's constructors.
       {
          lock_type lock(interprocess_mutex, boost::interprocess::defer_lock);
-         BOOST_INTERPROCES_CHECK(!lock);
+         BOOST_INTERPROCESS_CHECK(!lock);
       }
       lock_type lock(interprocess_mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
 
       // Test the lock and unlock methods.
       lock.unlock();
-      BOOST_INTERPROCES_CHECK(!lock);
+      BOOST_INTERPROCESS_CHECK(!lock);
       lock.lock();
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
    }
 };
 
@@ -72,24 +72,24 @@
       // Test the lock's constructors.
       {
          try_to_lock_type lock(interprocess_mutex, boost::interprocess::try_to_lock);
-         BOOST_INTERPROCES_CHECK(lock ? true : false);
+         BOOST_INTERPROCESS_CHECK(lock ? true : false);
       }
       {
          try_to_lock_type lock(interprocess_mutex, boost::interprocess::defer_lock);
-         BOOST_INTERPROCES_CHECK(!lock);
+         BOOST_INTERPROCESS_CHECK(!lock);
       }
       try_to_lock_type lock(interprocess_mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
 
       // Test the lock, unlock and trylock methods.
       lock.unlock();
-      BOOST_INTERPROCES_CHECK(!lock);
+      BOOST_INTERPROCESS_CHECK(!lock);
       lock.lock();
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
       lock.unlock();
-      BOOST_INTERPROCES_CHECK(!lock);
-      BOOST_INTERPROCES_CHECK(lock.try_lock());
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(!lock);
+      BOOST_INTERPROCESS_CHECK(lock.try_lock());
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
    }
 };
 
@@ -109,25 +109,25 @@
          boost::posix_time::ptime pt = delay(1*BaseSeconds, 0);
 
          timed_lock_type lock(interprocess_mutex, pt);
-         BOOST_INTERPROCES_CHECK(lock ? true : false);
+         BOOST_INTERPROCESS_CHECK(lock ? true : false);
       }
       {
          timed_lock_type lock(interprocess_mutex, boost::interprocess::defer_lock);
-         BOOST_INTERPROCES_CHECK(!lock);
+         BOOST_INTERPROCESS_CHECK(!lock);
       }
       timed_lock_type lock(interprocess_mutex);
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
 
       // Test the lock, unlock and timedlock methods.
       lock.unlock();
-      BOOST_INTERPROCES_CHECK(!lock);
+      BOOST_INTERPROCESS_CHECK(!lock);
       lock.lock();
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
       lock.unlock();
-      BOOST_INTERPROCES_CHECK(!lock);
+      BOOST_INTERPROCESS_CHECK(!lock);
       boost::posix_time::ptime pt = delay(3*BaseSeconds, 0);
-      BOOST_INTERPROCES_CHECK(lock.timed_lock(pt));
-      BOOST_INTERPROCES_CHECK(lock ? true : false);
+      BOOST_INTERPROCESS_CHECK(lock.timed_lock(pt));
+      BOOST_INTERPROCESS_CHECK(lock ? true : false);
    }
 };
 
@@ -170,10 +170,10 @@
    data<M> *pdata = static_cast<data<M>*>(arg);
    boost::interprocess::scoped_lock<M> l(sm);
    if(pdata->m_secs){
-      boost::thread::sleep(xsecs(pdata->m_secs));
+      boost::interprocess::ipcdetail::thread_sleep((1000*pdata->m_secs));
    }
    else{
-      boost::thread::sleep(xsecs(2*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*2*BaseSeconds));
    }
 
    ++shared_val;
@@ -188,10 +188,10 @@
    {
       boost::interprocess::scoped_lock<M> l(sm);
       if(pdata->m_secs){
-         boost::thread::sleep(xsecs(pdata->m_secs));
+         boost::interprocess::ipcdetail::thread_sleep((1000*pdata->m_secs));
       }
       else{
-         boost::thread::sleep(xsecs(2*BaseSeconds));
+         boost::interprocess::ipcdetail::thread_sleep((1000*2*BaseSeconds));
       }
       ++shared_val;
       pdata->m_value = shared_val;
@@ -208,7 +208,7 @@
    data<M> *pdata = static_cast<data<M>*>(arg);
    boost::interprocess::scoped_lock<M> l(sm, boost::interprocess::defer_lock);
    if (l.try_lock()){
-      boost::thread::sleep(xsecs(2*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*2*BaseSeconds));
       ++shared_val;
       pdata->m_value = shared_val;
    }
@@ -222,7 +222,7 @@
    boost::interprocess::scoped_lock<M>
       l (sm, boost::interprocess::defer_lock);
    if (l.timed_lock(pt)){
-      boost::thread::sleep(xsecs(2*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*2*BaseSeconds));
       ++shared_val;
       pdata->m_value = shared_val;
    }
@@ -239,21 +239,24 @@
    data<M> d2(2);
 
    // Locker one launches, holds the lock for 2*BaseSeconds seconds.
-   boost::thread tm1(thread_adapter<M>(&lock_and_sleep, &d1, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm1;
+   boost::interprocess::ipcdetail::thread_launch(tm1, thread_adapter<M>(&lock_and_sleep, &d1, mtx));
 
    //Wait 1*BaseSeconds
-   boost::thread::sleep(xsecs(1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
 
    // Locker two launches, but it won't hold the lock for 2*BaseSeconds seconds.
-   boost::thread tm2(thread_adapter<M>(&lock_and_sleep, &d2, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm2;
+   boost::interprocess::ipcdetail::thread_launch(tm2, thread_adapter<M>(&lock_and_sleep, &d2, mtx));
 
    //Wait completion
-   tm1.join();
-   boost::thread::sleep(xsecs(1*BaseSeconds));
-   tm2.join();
+   
+   boost::interprocess::ipcdetail::thread_join(tm1);
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_join(tm2);
 
-   BOOST_INTERPROCES_CHECK(d1.m_value == 1);
-   BOOST_INTERPROCES_CHECK(d2.m_value == 2);
+   BOOST_INTERPROCESS_CHECK(d1.m_value == 1);
+   BOOST_INTERPROCESS_CHECK(d2.m_value == 2);
 }
 
 template<typename M>
@@ -271,23 +274,25 @@
    data<M> d2(2, wait_time_s * 2);
 
    // Locker one launches, and holds the lock for wait_time_s * 2 seconds.
-   boost::thread tm1(thread_adapter<M>(&lock_and_sleep, &d1, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm1;
+   boost::interprocess::ipcdetail::thread_launch(tm1, thread_adapter<M>(&lock_and_sleep, &d1, mtx));
 
    //Wait 1*BaseSeconds
-   boost::thread::sleep(xsecs(wait_time_s));
+   boost::interprocess::ipcdetail::thread_sleep((1000*wait_time_s));
 
    // Locker two launches, and attempts to hold the lock for wait_time_s * 2 seconds.
-   boost::thread tm2(thread_adapter<M>(&lock_and_catch_errors, &d2, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm2;
+   boost::interprocess::ipcdetail::thread_launch(tm2, thread_adapter<M>(&lock_and_catch_errors, &d2, mtx));
 
    //Wait completion
-   tm1.join();
-   boost::thread::sleep(xsecs(1*BaseSeconds));
-   tm2.join();
-
-   BOOST_INTERPROCES_CHECK(d1.m_value == 1);
-   BOOST_INTERPROCES_CHECK(d2.m_value == -1);
-   BOOST_INTERPROCES_CHECK(d1.m_error == no_error);
-   BOOST_INTERPROCES_CHECK(d2.m_error == boost::interprocess::timeout_when_locking_error);
+   boost::interprocess::ipcdetail::thread_join(tm1);
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_join(tm2);
+
+   BOOST_INTERPROCESS_CHECK(d1.m_value == 1);
+   BOOST_INTERPROCESS_CHECK(d2.m_value == -1);
+   BOOST_INTERPROCESS_CHECK(d1.m_error == no_error);
+   BOOST_INTERPROCESS_CHECK(d2.m_error == boost::interprocess::timeout_when_locking_error);
 }
 
 template<typename M>
@@ -301,20 +306,23 @@
    data<M> d2(2);
 
    // Locker one launches, holds the lock for 2*BaseSeconds seconds.
-   boost::thread tm1(thread_adapter<M>(&try_lock_and_sleep, &d1, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm1;
+   boost::interprocess::ipcdetail::thread_launch(tm1, thread_adapter<M>(&try_lock_and_sleep, &d1, mtx));
 
    //Wait 1*BaseSeconds
-   boost::thread::sleep(xsecs(1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
 
    // Locker two launches, but it should fail acquiring the lock
-   boost::thread tm2(thread_adapter<M>(&try_lock_and_sleep, &d2, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm2;
+   boost::interprocess::ipcdetail::thread_launch(tm2, thread_adapter<M>(&try_lock_and_sleep, &d2, mtx));
 
    //Wait completion
-   tm1.join();
-   tm2.join();
+   boost::interprocess::ipcdetail::thread_join(tm1);
+   boost::interprocess::ipcdetail::thread_join(tm2);
+
    //Only the first should succeed locking
-   BOOST_INTERPROCES_CHECK(d1.m_value == 1);
-   BOOST_INTERPROCES_CHECK(d2.m_value == -1);
+   BOOST_INTERPROCESS_CHECK(d1.m_value == 1);
+   BOOST_INTERPROCESS_CHECK(d2.m_value == -1);
 }
 
 template<typename M>
@@ -329,21 +337,23 @@
    data<M> d2(2, 2*BaseSeconds);
 
    // Locker one launches, holds the lock for 2*BaseSeconds seconds.
-   boost::thread tm1(thread_adapter<M>(&timed_lock_and_sleep, &d1, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm1;
+   boost::interprocess::ipcdetail::thread_launch(tm1, thread_adapter<M>(&timed_lock_and_sleep, &d1, mtx));
 
    //Wait 1*BaseSeconds
-   boost::thread::sleep(xsecs(1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
 
    // Locker two launches, holds the lock for 2*BaseSeconds seconds.
-   boost::thread tm2(thread_adapter<M>(&timed_lock_and_sleep, &d2, mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tm2;
+   boost::interprocess::ipcdetail::thread_launch(tm2, thread_adapter<M>(&timed_lock_and_sleep, &d2, mtx));
 
    //Wait completion
-   tm1.join();
-   tm2.join();
+   boost::interprocess::ipcdetail::thread_join(tm1);
+   boost::interprocess::ipcdetail::thread_join(tm2);
 
    //Both should succeed locking
-   BOOST_INTERPROCES_CHECK(d1.m_value == 1);
-   BOOST_INTERPROCES_CHECK(d2.m_value == 2);
+   BOOST_INTERPROCESS_CHECK(d1.m_value == 1);
+   BOOST_INTERPROCESS_CHECK(d2.m_value == 2);
 }
 
 template <typename M>

Modified: trunk/libs/interprocess/test/named_creation_template.hpp
==============================================================================
--- trunk/libs/interprocess/test/named_creation_template.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/named_creation_template.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -32,7 +32,7 @@
    }
    catch(...){
       //This shouldn't throw so show the error
-      BOOST_INTERPROCES_CHECK( false );
+      BOOST_INTERPROCESS_CHECK( false );
    }
 }
 
@@ -45,7 +45,7 @@
       NamedResource nresource2(create_only);
    }
    catch(interprocess_exception &err){
-      BOOST_INTERPROCES_CHECK(err.get_error_code() == already_exists_error);
+      BOOST_INTERPROCESS_CHECK(err.get_error_code() == already_exists_error);
    }
 }
 
@@ -57,11 +57,11 @@
       NamedResource nresource1(open_only);
    }
    catch(interprocess_exception &err){
-      BOOST_INTERPROCES_CHECK(err.get_error_code() == not_found_error);
+      BOOST_INTERPROCESS_CHECK(err.get_error_code() == not_found_error);
       return;
    }
    //The mutex should not exist
-   BOOST_INTERPROCES_CHECK(false);
+   BOOST_INTERPROCESS_CHECK(false);
 }
 
 template <class NamedResource>

Modified: trunk/libs/interprocess/test/named_semaphore_test.cpp
==============================================================================
--- trunk/libs/interprocess/test/named_semaphore_test.cpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/named_semaphore_test.cpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -86,16 +86,16 @@
    }
    {
       named_semaphore sem(open_only, SemName);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == true);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == true);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == true);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == false);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == true);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == true);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == true);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == false);
       sem.post();
    }
    {
       named_semaphore sem(open_only, SemName);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == true);
-      BOOST_INTERPROCES_CHECK(sem.try_wait() == false);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == true);
+      BOOST_INTERPROCESS_CHECK(sem.try_wait() == false);
    }
 
    named_semaphore::remove(SemName);

Modified: trunk/libs/interprocess/test/sharable_mutex_test_template.hpp
==============================================================================
--- trunk/libs/interprocess/test/sharable_mutex_test_template.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/sharable_mutex_test_template.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -24,8 +24,7 @@
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
 
-#include <boost/thread/thread.hpp>
-#include <boost/thread/xtime.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
 #include "boost_interprocess_check.hpp"
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/interprocess/sync/sharable_lock.hpp>
@@ -41,7 +40,7 @@
 {
    data<SM> *pdata = static_cast<data<SM>*>(arg);
    boost::interprocess::scoped_lock<SM> l(sm);
-   boost::thread::sleep(xsecs(3*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_sleep((1000*3*BaseSeconds));
    shared_val += 10;
    pdata->m_value = shared_val;
 }
@@ -52,7 +51,7 @@
    data<SM> *pdata = static_cast<data<SM>*>(arg);
    boost::interprocess::sharable_lock<SM> l(sm);
    if(pdata->m_secs){
-      boost::thread::sleep(xsecs(pdata->m_secs*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*pdata->m_secs*BaseSeconds));
    }
    pdata->m_value = shared_val;
 }
@@ -63,7 +62,7 @@
    data<SM> *pdata = static_cast<data<SM>*>(arg);
    boost::interprocess::scoped_lock<SM> l(sm, boost::interprocess::defer_lock);
    if (l.try_lock()){
-      boost::thread::sleep(xsecs(3*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*3*BaseSeconds));
       shared_val += 10;
       pdata->m_value = shared_val;
    }
@@ -76,7 +75,7 @@
    boost::interprocess::sharable_lock<SM> l(sm, boost::interprocess::defer_lock);
    if (l.try_lock()){
       if(pdata->m_secs){
-         boost::thread::sleep(xsecs(pdata->m_secs*BaseSeconds));
+         boost::interprocess::ipcdetail::thread_sleep((1000*pdata->m_secs*BaseSeconds));
       }
       pdata->m_value = shared_val;
    }
@@ -90,7 +89,7 @@
    boost::interprocess::scoped_lock<SM>
       l (sm, boost::interprocess::defer_lock);
    if (l.timed_lock(pt)){
-      boost::thread::sleep(xsecs(3*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*3*BaseSeconds));
       shared_val += 10;
       pdata->m_value = shared_val;
    }
@@ -105,7 +104,7 @@
       l(sm, boost::interprocess::defer_lock);
    if (l.timed_lock(pt)){
       if(pdata->m_secs){
-         boost::thread::sleep(xsecs(pdata->m_secs*BaseSeconds));
+         boost::interprocess::ipcdetail::thread_sleep((1000*pdata->m_secs*BaseSeconds));
       }
       pdata->m_value = shared_val;
    }
@@ -123,28 +122,32 @@
       data<SM> e2(2);
 
       // Writer one launches, holds the lock for 3*BaseSeconds seconds.
-      boost::thread tw1(thread_adapter<SM>(plain_exclusive, &e1, mtx));
+      boost::interprocess::ipcdetail::OS_thread_t tw1;
+      boost::interprocess::ipcdetail::thread_launch(tw1, thread_adapter<SM>(plain_exclusive, &e1, mtx));
 
       // Writer two launches, tries to grab the lock, "clearly"
       //  after Writer one will already be holding it.
-      boost::thread::sleep(xsecs(1*BaseSeconds));
-      boost::thread tw2(thread_adapter<SM>(plain_exclusive, &e2, mtx));
+      boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
+      boost::interprocess::ipcdetail::OS_thread_t tw2;
+      boost::interprocess::ipcdetail::thread_launch(tw2, thread_adapter<SM>(plain_exclusive, &e2, mtx));
 
       // Reader one launches, "clearly" after writer two, and "clearly"
       //   while writer 1 still holds the lock
-      boost::thread::sleep(xsecs(1*BaseSeconds));
-      boost::thread thr1(thread_adapter<SM>(plain_shared,&s1, mtx));
-      boost::thread thr2(thread_adapter<SM>(plain_shared,&s2, mtx));
-
-      thr2.join();
-      thr1.join();
-      tw2.join();
-      tw1.join();
+      boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
+      boost::interprocess::ipcdetail::OS_thread_t thr1;
+      boost::interprocess::ipcdetail::thread_launch(thr1, thread_adapter<SM>(plain_shared,&s1, mtx));
+      boost::interprocess::ipcdetail::OS_thread_t thr2;
+      boost::interprocess::ipcdetail::thread_launch(thr2, thread_adapter<SM>(plain_shared,&s2, mtx));
+
+      boost::interprocess::ipcdetail::thread_join(thr2);
+      boost::interprocess::ipcdetail::thread_join(thr1);
+      boost::interprocess::ipcdetail::thread_join(tw2);
+      boost::interprocess::ipcdetail::thread_join(tw1);
 
       //We can only assure that the writer will be first
-      BOOST_INTERPROCES_CHECK(e1.m_value == 10);
+      BOOST_INTERPROCESS_CHECK(e1.m_value == 10);
       //A that we will execute all
-      BOOST_INTERPROCES_CHECK(s1.m_value == 20 || s2.m_value == 20 || e2.m_value == 20);
+      BOOST_INTERPROCESS_CHECK(s1.m_value == 20 || s2.m_value == 20 || e2.m_value == 20);
    }
 
    {
@@ -157,25 +160,30 @@
       data<SM> e2(2);
 
       //We launch 2 readers, that will block for 3*BaseTime seconds
-      boost::thread thr1(thread_adapter<SM>(plain_shared,&s1, mtx));
-      boost::thread thr2(thread_adapter<SM>(plain_shared,&s2, mtx));
+      boost::interprocess::ipcdetail::OS_thread_t thr1;
+      boost::interprocess::ipcdetail::thread_launch(thr1, thread_adapter<SM>(plain_shared,&s1, mtx));
+      boost::interprocess::ipcdetail::OS_thread_t thr2;
+      boost::interprocess::ipcdetail::thread_launch(thr2, thread_adapter<SM>(plain_shared,&s2, mtx));
 
       //Make sure they try to hold the sharable lock
-      boost::thread::sleep(xsecs(1*BaseSeconds));
+      boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
 
       // We launch two writers, that should block until the readers end
-      boost::thread tw1(thread_adapter<SM>(plain_exclusive,&e1, mtx));
-      boost::thread tw2(thread_adapter<SM>(plain_exclusive,&e2, mtx));
+      boost::interprocess::ipcdetail::OS_thread_t tw1;
+      boost::interprocess::ipcdetail::thread_launch(tw1, thread_adapter<SM>(plain_exclusive,&e1, mtx));
 
-      thr2.join();
-      thr1.join();
-      tw2.join();
-      tw1.join();
+      boost::interprocess::ipcdetail::OS_thread_t tw2;
+      boost::interprocess::ipcdetail::thread_launch(tw2, thread_adapter<SM>(plain_exclusive,&e2, mtx));
+
+      boost::interprocess::ipcdetail::thread_join(thr2);
+      boost::interprocess::ipcdetail::thread_join(thr1);
+      boost::interprocess::ipcdetail::thread_join(tw2);
+      boost::interprocess::ipcdetail::thread_join(tw1);
 
       //We can only assure that the shared will finish first...
-      BOOST_INTERPROCES_CHECK(s1.m_value == 0 || s2.m_value == 0);
+      BOOST_INTERPROCESS_CHECK(s1.m_value == 0 || s2.m_value == 0);
       //...and writers will be mutually excluded after readers
-      BOOST_INTERPROCES_CHECK((e1.m_value == 10 && e2.m_value == 20) ||
+      BOOST_INTERPROCESS_CHECK((e1.m_value == 10 && e2.m_value == 20) ||
              (e1.m_value == 20 && e2.m_value == 10) );
    }
 }
@@ -194,24 +202,26 @@
    shared_val = 0;
 
    // Writer one launches, holds the lock for 3*BaseSeconds seconds.
-
-   boost::thread tw1(thread_adapter<SM>(try_exclusive,&e1,mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tw1;
+   boost::interprocess::ipcdetail::thread_launch(tw1, thread_adapter<SM>(try_exclusive,&e1,mtx));
 
    // Reader one launches, "clearly" after writer #1 holds the lock
    //   and before it releases the lock.
-   boost::thread::sleep(xsecs(1*BaseSeconds));
-   boost::thread thr1(thread_adapter<SM>(try_shared,&s1,mtx));
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
+   boost::interprocess::ipcdetail::OS_thread_t thr1;
+   boost::interprocess::ipcdetail::thread_launch(thr1, thread_adapter<SM>(try_shared,&s1,mtx));
 
    // Writer two launches in the same timeframe.
-   boost::thread tw2(thread_adapter<SM>(try_exclusive,&e2,mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tw2;
+   boost::interprocess::ipcdetail::thread_launch(tw2, thread_adapter<SM>(try_exclusive,&e2,mtx));
 
-   tw2.join();
-   thr1.join();
-   tw1.join();
-
-   BOOST_INTERPROCES_CHECK(e1.m_value == 10);
-   BOOST_INTERPROCES_CHECK(s1.m_value == -1);        // Try would return w/o waiting
-   BOOST_INTERPROCES_CHECK(e2.m_value == -1);        // Try would return w/o waiting
+   boost::interprocess::ipcdetail::thread_join(tw2);
+   boost::interprocess::ipcdetail::thread_join(thr1);
+   boost::interprocess::ipcdetail::thread_join(tw1);
+
+   BOOST_INTERPROCESS_CHECK(e1.m_value == 10);
+   BOOST_INTERPROCESS_CHECK(s1.m_value == -1);        // Try would return w/o waiting
+   BOOST_INTERPROCESS_CHECK(e2.m_value == -1);        // Try would return w/o waiting
 }
 
 template<typename SM>
@@ -228,31 +238,36 @@
    shared_val = 0;
 
    // Writer one will hold the lock for 3*BaseSeconds seconds.
-   boost::thread tw1(thread_adapter<SM>(timed_exclusive,&e1,mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tw1;
+   boost::interprocess::ipcdetail::thread_launch(tw1, thread_adapter<SM>(timed_exclusive,&e1,mtx));
 
-   boost::thread::sleep(xsecs(1*BaseSeconds));
+   boost::interprocess::ipcdetail::thread_sleep((1000*1*BaseSeconds));
    // Writer two will "clearly" try for the lock after the readers
    //  have tried for it.  Writer will wait up 1*BaseSeconds seconds for the lock.
    //  This write will fail.
-   boost::thread tw2(thread_adapter<SM>(timed_exclusive,&e2,mtx));
+   boost::interprocess::ipcdetail::OS_thread_t tw2;
+   boost::interprocess::ipcdetail::thread_launch(tw2, thread_adapter<SM>(timed_exclusive,&e2,mtx));
 
    // Readers one and two will "clearly" try for the lock after writer
    //   one already holds it.  1st reader will wait 1*BaseSeconds seconds, and will fail
    //   to get the lock.  2nd reader will wait 3*BaseSeconds seconds, and will get
    //   the lock.
 
-   boost::thread thr1(thread_adapter<SM>(timed_shared,&s1,mtx));
-   boost::thread thr2(thread_adapter<SM>(timed_shared,&s2,mtx));
+   boost::interprocess::ipcdetail::OS_thread_t thr1;
+   boost::interprocess::ipcdetail::thread_launch(thr1, thread_adapter<SM>(timed_shared,&s1,mtx));
+
+   boost::interprocess::ipcdetail::OS_thread_t thr2;
+   boost::interprocess::ipcdetail::thread_launch(thr2, thread_adapter<SM>(timed_shared,&s2,mtx));
 
-   tw1.join();
-   thr1.join();
-   thr2.join();
-   tw2.join();
-
-   BOOST_INTERPROCES_CHECK(e1.m_value == 10);
-   BOOST_INTERPROCES_CHECK(s1.m_value == -1);
-   BOOST_INTERPROCES_CHECK(s2.m_value == 10);
-   BOOST_INTERPROCES_CHECK(e2.m_value == -1);
+   boost::interprocess::ipcdetail::thread_join(tw1);
+   boost::interprocess::ipcdetail::thread_join(thr1);
+   boost::interprocess::ipcdetail::thread_join(thr2);
+   boost::interprocess::ipcdetail::thread_join(tw2);
+
+   BOOST_INTERPROCESS_CHECK(e1.m_value == 10);
+   BOOST_INTERPROCESS_CHECK(s1.m_value == -1);
+   BOOST_INTERPROCESS_CHECK(s2.m_value == 10);
+   BOOST_INTERPROCESS_CHECK(e2.m_value == -1);
 }
 
 template<typename SM>

Modified: trunk/libs/interprocess/test/util.hpp
==============================================================================
--- trunk/libs/interprocess/test/util.hpp	Sun Sep 15 15:47:36 2013	(r85687)
+++ trunk/libs/interprocess/test/util.hpp	2013-09-15 15:50:54 EDT (Sun, 15 Sep 2013)	(r85688)
@@ -24,8 +24,6 @@
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
 #include <boost/interprocess/detail/os_thread_functions.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/xtime.hpp>
 
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <algorithm>
@@ -61,30 +59,18 @@
     return (xt > min) && (max > xt);
 }
 
-boost::xtime xsecs(int secs)
-{
-   boost::xtime ret;
-   #if BOOST_VERSION >= 105100 //TIME_UTC is a macro in C11, breaking change in Boost.Thread
-   boost::xtime_get(&ret, boost::TIME_UTC_);
-   #else
-   boost::xtime_get(&ret, boost::TIME_UTC);
-   #endif
-   ret.sec += secs;
-   return ret;
-}
-
 template <typename P>
 class thread_adapter
 {
    public:
    thread_adapter(void (*func)(void*, P &), void* param1, P &param2)
-      : _func(func), _param1(param1) ,_param2(param2){ }
-   void operator()() const { _func(_param1, _param2); }
+      : func_(func), param1_(param1) ,param2_(param2){ }
+   void operator()() const { func_(param1_, param2_); }
 
    private:
-   void (*_func)(void*, P &);
-   void* _param1;
-   P& _param2;
+   void (*func_)(void*, P &);
+   void* param1_;
+   P& param2_;
 };
 
 template <typename P>