Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r56975 - in sandbox/stm/branches/vbe/boost: stm stm/detail synchro synchro/detail synchro/lockable synchro/lockers synchro/pthread synchro/thread
From: vicente.botet_at_[hidden]
Date: 2009-10-18 06:19:08


Author: viboes
Date: 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
New Revision: 56975
URL: http://svn.boost.org/trac/boost/changeset/56975

Log:
TBoost.STM vbe: Non transactional Synchro mechanism (following as far as possible the Boost names)
* Add a new directory synchro for synchronization specific features (boost/synchro)
* Add free functions to lock,unlock, try_lock, ... (boost/synchro/lock.hpp, boost/synchro/unlock.hpp,boost/synchro/try_lock.hpp ..)
* Add lockers lock_guard, lock_guard_if, unique_lock (boost/synchro/locks.hpp)
* Don't use var_auto_lock as it is not exception safe
* Create non transactional synchronization language-like macros (boost/synchro/language_like.hpp)

Added:
   sandbox/stm/branches/vbe/boost/synchro/
   sandbox/stm/branches/vbe/boost/synchro/detail/
   sandbox/stm/branches/vbe/boost/synchro/detail/config.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/exceptions.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/language_like.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/
   sandbox/stm/branches/vbe/boost/synchro/lockable.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/lock.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/lock_for.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/lock_until.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/try_lock.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockable/unlock.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockers/
   sandbox/stm/branches/vbe/boost/synchro/lockers/lock_guard.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/lockers/unique_lock.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/locks.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/pthread/
   sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/tags.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/thread/
   sandbox/stm/branches/vbe/boost/synchro/thread/mutex.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/synchro/time.hpp (contents, props changed)
Text files modified:
   sandbox/stm/branches/vbe/boost/stm/detail/auto_lock.hpp | 2
   sandbox/stm/branches/vbe/boost/stm/detail/config.hpp | 1
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp | 54 ++++++++++++++++++++++++---------------
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp | 26 ++++++++++--------
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp | 12 +++++--
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp | 45 +++++++++++++++++----------------
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp | 7 ++--
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp | 9 ++++--
   sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp | 4 ++
   sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp | 15 +++++-----
   sandbox/stm/branches/vbe/boost/stm/synchro.hpp | 11 ++++++-
   11 files changed, 110 insertions(+), 76 deletions(-)

Modified: sandbox/stm/branches/vbe/boost/stm/detail/auto_lock.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/auto_lock.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/auto_lock.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -102,7 +102,7 @@
 
       for (size_t i = 0; i < timeOut; ++i)
       {
- if (0 == synchro::try_lock(*lock_))
+ if (synchro::try_lock(*lock_))
          {
             hasLock_ = true;
             insert_into_threaded_lock_map(mutex);

Modified: sandbox/stm/branches/vbe/boost/stm/detail/config.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/config.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/config.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -101,6 +101,7 @@
 // Define BOOST_STM_ALLOWS_DELETERS when you want STM manage with others deleters than delete
 #define BOOST_STM_ALLOWS_DELETERS 1
 
+#define BOOST_STM_USE_BOOST_SYNCHRO 1
 #endif // BOOST_STM_DETAIL_CONFIG_H
 
 

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -58,8 +58,10 @@
    //--------------------------------------------------------------------------
    if (latmLockedLocks_.empty())
    {
- synchro::lock(*general_lock());
- synchro::lock(*inflight_lock());
+ synchro::lock_guard<Mutex> lock_g(*general_lock());
+ //synchro::lock(*general_lock());
+ synchro::lock_guard<Mutex> lock_i(*inflight_lock());
+ //synchro::lock(*inflight_lock());
 
       std::list<transaction*> txList;
       for (InflightTxes::iterator i = transactionsInFlight_.begin();
@@ -74,8 +76,8 @@
          }
          else
          {
- synchro::unlock(*general_lock());
- synchro::unlock(*inflight_lock());
+ //synchro::unlock(*general_lock());
+ //synchro::unlock(*inflight_lock());
             return false;
          }
       }
@@ -85,8 +87,8 @@
          (*it)->force_to_abort();
       }
 
- synchro::unlock(*general_lock());
- synchro::unlock(*inflight_lock());
+ //synchro::unlock(*general_lock());
+ //synchro::unlock(*inflight_lock());
    }
 
    try { latmLockedLocks_.insert(mutex); }
@@ -113,9 +115,11 @@
       t->add_to_obtained_locks(mutex);
 
       t->commit_deferred_update_tx();
- synchro::lock(*latm_lock());
+ { synchro::lock_guard<Mutex> lock_l(*latm_lock());
+ //synchro::lock(*latm_lock());
       latmLockedLocksOfThreadMap_[mutex] = THREAD_ID;
- synchro::unlock(*latm_lock());
+ //synchro::unlock(*latm_lock());
+ }
 
       // TBR if (hadLock) return 0;
       // TBR else return lock(mutex);
@@ -129,10 +133,11 @@
    {
       // TBR int val = lock(mutex);
       // TBR if (0 != val) return val;
+ //{
       synchro::lock(*mutex);
-
+ //synchro::lock_guard<Mutex> lock_m(*mutex);
       synchro::lock(latmMutex_);
-
+ //synchro::lock_guard<Mutex> lock_l(latmMutex_);
       try
       {
          //--------------------------------------------------------------------
@@ -152,6 +157,7 @@
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
       synchro::unlock(latmMutex_);
+ //}
 
       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
@@ -177,18 +183,22 @@
       t->add_to_obtained_locks(mutex);
 
       t->commit_deferred_update_tx();
- synchro::lock(*latm_lock());
+ { synchro::lock_guard<Mutex> lock_l(*latm_lock());
+ //synchro::lock(*latm_lock());
       latmLockedLocksOfThreadMap_[mutex] = THREAD_ID;
- synchro::unlock(*latm_lock());
+ //synchro::unlock(*latm_lock());
+ }
 
       if (hadLock) return 0;
- else return synchro::try_lock(*mutex);
+ else return synchro::try_lock(*mutex)?0:1;
    }
 
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::trylock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
- synchro::lock(latmMutex_);
+ //synchro::lock(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latmMutex_);
 
    try
    {
@@ -198,19 +208,19 @@
       if (!def_do_core_full_pthread_lock_mutex(mutex, 0, 0))
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ //synchro::unlock(latmMutex_);
          return -1;
       }
    }
    catch (...)
    {
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ //synchro::unlock(latmMutex_);
       throw;
    }
 
    latmLockedLocksOfThreadMap_[mutex] = THREAD_ID;
- synchro::unlock(latmMutex_);
+ //synchro::unlock(latmMutex_);
    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
    return 0;
@@ -221,8 +231,9 @@
 //----------------------------------------------------------------------------
 inline int transaction::def_full_pthread_unlock_mutex(Mutex *mutex)
 {
- synchro::lock(latmMutex_);
    bool hasLock = true;
+ { synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ //synchro::lock(latmMutex_);
 
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -243,7 +254,8 @@
    if (latmLockedLocks_.empty()) synchro::unlock(*inflight_lock());
 
    latmLockedLocksOfThreadMap_.erase(mutex);
- synchro::unlock(latmMutex_);
+ //synchro::unlock(latmMutex_);
+ }
 
    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -64,7 +64,8 @@
       // so we can abort all the in-flight transactions
       if (latmLockedLocks_.empty())
       {
- var_auto_lock<PLOCK> autlock(general_lock(), inflight_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
+ synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
 
          std::list<transaction*> txList;
 
@@ -127,11 +128,11 @@
    {
       // TRR int val = lock(mutex);
       // TRR if (0 != val) return val;
- {
- synchro::lock_guard<Mutex> lock_m(*latm_lock());
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
- //synchro::lock(*mutex);
- //synchro::lock(latmMutex_);
+ //{
+ //synchro::lock_guard<Mutex> lock_m(*latm_lock());
+ //synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock(*mutex);
+ synchro::lock(latmMutex_);
 
       try
       {
@@ -151,9 +152,9 @@
       //-----------------------------------------------------------------------
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
- //synchro::unlock(*mutex);
- //synchro::unlock(latmMutex_);
- }
+ synchro::unlock(*mutex);
+ synchro::unlock(latmMutex_);
+ //}
 
       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
@@ -188,14 +189,15 @@
       }
 
       if (hadLock) return 0;
- else return synchro::try_lock(*mutex);
+ else return synchro::try_lock(*mutex)?0:1;
    }
 
    //synchro::unique_lock<Mutex> lock_m(*mutex, synchro::try_to_lock);
    //if (lock_m) return true;
    
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::try_lock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
    //synchro::lock(latmMutex_);
    synchro::lock_guard<Mutex> lock_l(latmMutex_);

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -50,7 +50,8 @@
    // set. do not keep in-flight transactions blocked once the transactions have
    // been processed.
    //--------------------------------------------------------------------------
- var_auto_lock<PLOCK> autolock(general_lock(), inflight_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
+ synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
 
    std::list<transaction *> txList;
    std::set<size_t> txThreadId;
@@ -218,8 +219,9 @@
 
    bool txIsIrrevocable = false;
 
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::try_lock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
    synchro::lock(latmMutex_);
 
@@ -264,7 +266,9 @@
 //----------------------------------------------------------------------------
 inline int transaction::def_tx_conflicting_lock_pthread_unlock_mutex(Mutex *mutex)
 {
- var_auto_lock<PLOCK> autolock(latm_lock(), general_lock(), inflight_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_l(*latm_lock());
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
+ synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
    bool hasLock = true;
 
    if (transaction* t = get_inflight_tx_of_same_thread(true))

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -59,7 +59,7 @@
    if (latmLockedLocks_.empty())
    {
        
- {
+ //{
       //synchro::lock_guard<Mutex> lock_g(*general_lock());
       synchro::lock(*general_lock());
       //synchro::lock_guard<Mutex> lock_i(*inflight_lock());
@@ -96,7 +96,7 @@
 
       synchro::unlock(*general_lock());
       synchro::unlock(*inflight_lock());
- }
+ //}
 
       //-----------------------------------------------------------------------
       // now we must stall until all in-flight transactions are gone, otherwise
@@ -144,35 +144,35 @@
    int waitTime = 0, aborted = 0;
    for (;;)
    {
- {
+ //{
       // TBR int val = lock(mutex);
       // TBR if (0 != val) return val;
- //synchro::lock(*mutex);
- synchro::lock_guard<Mutex> lock_m(*mutex);
+ synchro::lock(*mutex);
+ //synchro::lock_guard<Mutex> lock_m(*mutex);
 
- //synchro::lock(latmMutex_);
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock(latmMutex_);
+ //synchro::lock_guard<Mutex> lock_l(latmMutex_);
 
- //try
- //{
+ try
+ {
          //--------------------------------------------------------------------
          // if we are able to do the core lock work, break
          //--------------------------------------------------------------------
          if (dir_do_core_full_pthread_lock_mutex(mutex, waitTime, aborted)) break;
- //}
- //catch (...)
- //{
- //synchro::unlock(*mutex);
- //synchro::unlock(latmMutex_);
- //throw;
- //}
+ }
+ catch (...)
+ {
+ synchro::unlock(*mutex);
+ synchro::unlock(latmMutex_);
+ throw;
+ }
 
       //-----------------------------------------------------------------------
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
- //synchro::unlock(*mutex);
- //synchro::unlock(latmMutex_);
- }
+ synchro::unlock(*mutex);
+ synchro::unlock(latmMutex_);
+ //}
 
       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
@@ -203,13 +203,14 @@
       synchro::unlock(*latm_lock());
 
       if (hadLock) return 0;
- else return synchro::try_lock(*mutex);
+ else return synchro::try_lock(*mutex)?0:1;
    }
 
    //synchro::unique_lock<Mutex> lock_m(*mutex, synchro::try_to_lock);
    //if (lock_m) return true;
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::try_lock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
    //synchro::lock(latmMutex_);
    synchro::lock_guard<Mutex> lock_l(latmMutex_);

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -184,11 +184,12 @@
       synchro::lock(*latm_lock());
       latmLockedLocksOfThreadMap_[mutex] = THREAD_ID;
       synchro::unlock(*latm_lock());
- return synchro::try_lock(*mutex);
+ return synchro::try_lock(*mutex)?0:1;
    }
 
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::try_lock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
    synchro::lock(latmMutex_);
 

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -252,8 +252,9 @@
 
    bool txIsIrrevocable = false;
 
- int val = synchro::try_lock(*mutex);
- if (0 != val) return val;
+ //int val = synchro::try_lock(*mutex);
+ //if (0 != val) return val;
+ if (!synchro::try_lock(*mutex)) return 1;
 
    synchro::lock(latmMutex_);
 
@@ -297,7 +298,9 @@
 //----------------------------------------------------------------------------
 inline int transaction::dir_tx_conflicting_lock_pthread_unlock_mutex(Mutex *mutex)
 {
- var_auto_lock<PLOCK> autolock(latm_lock(), general_lock(), inflight_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_l(*latm_lock());
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
+ synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
    bool hasLock = true;
 
    if (transaction* t = get_inflight_tx_of_same_thread(true))

Modified: sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -325,7 +325,9 @@
    if (!doing_tx_lock_protection()) return;
 
    {
- var_auto_lock<PLOCK> autol(latm_lock(), general_lock(), inflight_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_l(*latm_lock());
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
+ synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
 
       if (get_tx_conflicting_locks().find(inLock) != get_tx_conflicting_locks().end()) return;
       get_tx_conflicting_locks().insert(inLock);

Modified: sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -230,7 +230,7 @@
    // otherwise, force the tx to commit its writes/reads
    //--------------------------------------------------------------------------
    #if 0
- while (0 != synchro::try_lock(&transactionMutex_))
+ while (!synchro::try_lock(&transactionMutex_))
    {
       bookkeeping_.inc_lock_convoy_ms(1);
       SLEEP(1);
@@ -281,7 +281,7 @@
 //-----------------------------------------------------------------------------
 inline void transaction::lock_tx()
 {
- while (0 != synchro::try_lock(*mutex()))
+ while (!synchro::try_lock(*mutex()))
    {
       SLEEP(1);
    }
@@ -573,7 +573,8 @@
 #ifdef LOGGING_BLOCKS
       if (++iterations > 100)
       {
- var_auto_lock<PLOCK> autolock(latm_lock(), general_lock(), 0);
+ synchro::lock_guard<Mutex> autolock_l(*latm_lock());
+ synchro::lock_guard<Mutex> autolock_g(*general_lock());
          //unblock_threads_if_locks_are_empty();
          logFile_ << outputBlockedThreadsAndLockedLocks().c_str();
          SLEEP(10000);
@@ -904,7 +905,7 @@
       return;
    }
 
- while (0 != synchro::try_lock(transactionMutex_)) {
+ while (!synchro::try_lock(transactionMutex_)) {
     //std::cout << __LINE__ << " invalidating_deferred_end_transaction" << std::endl;
     }
 
@@ -1849,7 +1850,7 @@
 //----------------------------------------------------------------------------
 inline size_t transaction::earliest_start_time_of_inflight_txes()
 {
- var_auto_lock<PLOCK> a(inflight_lock(), 0);
+ synchro::lock_guard<Mutex> a(*inflight_lock());
 
    size_t secs = 0xffffffff;
 
@@ -1874,7 +1875,7 @@
 
    size_t earliestInFlightTx = earliest_start_time_of_inflight_txes();
 
- var_auto_lock<PLOCK> a(&deletionBufferMutex_, 0);
+ synchro::lock_guard<Mutex> a(deletionBufferMutex_);
 
    for (DeletionBuffer::iterator i = deletionBuffer_.begin(); i != deletionBuffer_.end();)
    {
@@ -1902,7 +1903,7 @@
 
    if (!deletedMemoryList().empty())
    {
- var_auto_lock<PLOCK> a(&deletionBufferMutex_, 0);
+ synchro::lock_guard<Mutex> a(deletionBufferMutex_);
       deletionBuffer_.insert( std::pair<size_t, MemoryContainerList>
          (time(0), deletedMemoryList()) );
       deletedMemoryList().clear();

Modified: sandbox/stm/branches/vbe/boost/stm/synchro.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/synchro.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/synchro.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -16,6 +16,10 @@
 
 #include <boost/stm/detail/config.hpp>
 
+#ifdef BOOST_STM_USE_BOOST_SYNCHRO
+#include <boost/synchro.hpp>
+#endif
+
 //-----------------------------------------------------------------------------
 #include <stdarg.h>
 #include <pthread.h>
@@ -42,7 +46,9 @@
 #endif
 
 //-----------------------------------------------------------------------------
+
 namespace boost {
+#ifndef BOOST_STM_USE_BOOST_SYNCHRO
 namespace synchro {
 
     class lock_error : public std::exception
@@ -116,7 +122,8 @@
         return !res;
     }
 #endif
-
+
+
     template<typename Mutex>
     class lock_guard
     {
@@ -166,7 +173,6 @@
         }
     };
     
-
     template<typename Mutex>
     class unique_lock
     {
@@ -396,6 +402,7 @@
 
     
 }
+#endif
 namespace stm {
 
 //-----------------------------------------------------------------------------

Added: sandbox/stm/branches/vbe/boost/synchro/detail/config.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/detail/config.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_DETAIL_CONFIG_HPP
+#define BOOST_SYNCHO_DETAIL_CONFIG_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/config.hpp>
+#include <boost/thread/detail/platform.hpp>
+//-----------------------------------------------------------------------------
+
+#endif // BOOST_SYNCHO_DETAIL_CONFIG_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/exceptions.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/exceptions.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,36 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_EXCEPTIONS_HPP
+#define BOOST_SYNCHO_EXCEPTIONS_HPP
+
+//-----------------------------------------------------------------------------
+#include <stdexcept>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ class lock_error : public std::logic_error {
+ public:
+ lock_error() : std::logic_error("synchro::lock_error") {}
+ };
+
+ class timeout_exception : public std::logic_error {
+ public:
+ timeout_exception() : std::logic_error("synchro::timeout_exception") {}
+ };
+
+}}
+#endif // BOOST_SYNCHO_EXCEPTIONS_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/language_like.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/language_like.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,87 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHRO_SYNCHRONIZED__HPP
+#define BOOST_SYNCHRO_SYNCHRONIZED__HPP
+
+namespace boost { namespace synchro { namespace detail {
+ inline bool no_opt_false() {return false;}
+}}}
+
+#define BOOST_SYNCHRO_SYNCHRONIZE_EXT(VAR_DECL) \
+ if (bool __stop = boost::synchro::detail::no_opt_false()) {} else \
+ for (VAR_DECL;!__stop; __stop= true)
+
+#define BOOST_SYNCHRO_SYNCHRONIZE_TYPE(TYPE, VAR, LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(LOCKABLE))
+
+#define BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_TYPE(TYPE, VAR, LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(LOCKABLE, boost::synchro::adopt_lock))
+#define BOOST_SYNCHRO_DEFER_SYNCHRONIZE_TYPE(TYPE, VAR, LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(LOCKABLE, boost::synchro::defer_lock))
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_TYPE(TYPE, VAR, LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(LOCKABLE, boost::synchro::try_to_lock))
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_TYPE_UNTIL(TYPE, VAR, LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(LOCKABLE, ABS_TIME))
+#define BOOST_SYNCHRO_SYNCHRONIZE_TYPE_UNTIL(TYPE, VAR, LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_SYNCHRONIZE_EXT(boost::synchro::unique_lock<TYPE> VAR(ABS_TIME, LOCKABLE))
+
+#define BOOST_SYNCHRO_SYNCHRONIZE_VAR(VAR, LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_TYPE(boost::mutex, VAR, LOCKABLE)
+#define BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_VAR(VAR, LOCKABLE) \
+ BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_TYPE(boost::mutex, VAR, LOCKABLE)
+#define BOOST_SYNCHRO_DEFER_SYNCHRONIZE_VAR(VAR, LOCKABLE) \
+ BOOST_SYNCHRO_DEFER_SYNCHRONIZE_TYPE(boost::mutex, VAR, LOCKABLE)
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR(VAR, LOCKABLE) \
+ BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_TYPE(boost::mutex, VAR, LOCKABLE)
+#define BOOST_SYNCHRO_SYNCHRONIZE_VAR_UNTIL(VAR, LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_SYNCHRONIZE_TYPE_UNTIL(boost::mutex, VAR, LOCKABLE, ABS_TIME)
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR_UNTIL(VAR, LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_TYPE_UNTIL(boost::mutex, VAR, LOCKABLE, ABS_TIME)
+
+#define BOOST_SYNCHRO_SYNCHRONIZE(LOCKABLE) \
+ BOOST_SYNCHRO_SYNCHRONIZE_VAR(_, LOCKABLE)
+#define BOOST_SYNCHRO_ADOPT_SYNCHRONIZE(LOCKABLE) \
+ BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_VAR(_, LOCKABLE)
+#define BOOST_SYNCHRO_DEFER_SYNCHRONIZE(LOCKABLE) \
+ BOOST_SYNCHRO_DEFER_SYNCHRONIZE_VAR(_, LOCKABLE)
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE(LOCKABLE) \
+ BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR(_, LOCKABLE)
+#define BOOST_SYNCHRO_SYNCHRONIZE_UNTIL(LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_SYNCHRONIZE_VAR_UNTIL(_, LOCKABLE, ABS_TIME)
+#define BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_UNTIL(LOCKABLE, ABS_TIME) \
+ BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR_UNTIL(_, LOCKABLE, ABS_TIME)
+
+#define synchronize(LOCKABLE) BOOST_SYNCHRO_SYNCHRONIZE(LOCKABLE)
+#define adopt_synchronize(LOCKABLE) BOOST_SYNCHRO_ADOPT_SYNCHRONIZE(LOCKABLE)
+#define defer_synchronize(LOCKABLE) BOOST_SYNCHRO_DEFER_SYNCHRONIZE(LOCKABLE)
+#define try_to_synchronize(LOCKABLE) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE(LOCKABLE)
+#define try_to_synchronize_until(LOCKABLE, ABS_TIME) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_UNTIL(LOCKABLE, ABS_TIME)
+#define synchronize_until(LOCKABLE, ABS_TIME) BOOST_SYNCHRO_SYNCHRONIZE_UNTIL(LOCKABLE, ABS_TIME)
+
+#define synchronize_var(VAR, LOCKABLE) BOOST_SYNCHRO_SYNCHRONIZE_VAR(VAR, LOCKABLE)
+#define adopt_synchronize_var(VAR, LOCKABLE) BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_VAR(VAR, LOCKABLE)
+#define defer_synchronize_var(VAR, LOCKABLE) BOOST_SYNCHRO_DEFER_SYNCHRONIZE_VAR(VAR, LOCKABLE)
+#define try_to_synchronize_var(VAR, LOCKABLE) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR(VAR, LOCKABLE)
+#define try_to_synchronize_var_until(VAR, LOCKABLE, ABS_TIME) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR_UNTIL(VAR, LOCKABLE, ABS_TIME)
+#define synchronize_var_until(VAR, LOCKABLE, ABS_TIME) BOOST_SYNCHRO_SYNCHRONIZE_VAR_UNTIL(VAR, ABS_TIME, LOCKABLE)
+
+#define synchronize_type(TYPE, VAR, LOCKABLE) BOOST_SYNCHRO_SYNCHRONIZE_TYPE(TYPE, VAR, LOCKABLE)
+#define adopt_synchronize_type(TYPE, VAR, LOCKABLE) BOOST_SYNCHRO_ADOPT_SYNCHRONIZE_VAR(TYPE, VAR, LOCKABLE)
+#define defer_synchronize_type(TYPE, VAR, LOCKABLE) BOOST_SYNCHRO_DEFER_SYNCHRONIZE_VAR(TYPE, VAR, LOCKABLE)
+#define try_to_synchronize_type(TYPE, VAR, LOCKABLE) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR(TYPE, VAR, LOCKABLE)
+#define try_to_synchronize_type_until(TYPE, VAR, LOCKABLE, ABS_TIME) BOOST_SYNCHRO_TRY_TO_SYNCHRONIZE_VAR_UNTIL(TYPE, VAR, LOCKABLE, ABS_TIME)
+#define synchronize_type_until(TYPE, VAR, LOCKABLE, ABS_TIME) BOOST_SYNCHRO_SYNCHRONIZE_VAR_UNTIL(TYPE, VAR, ABS_TIME, LOCKABLE)
+
+
+#endif

Added: sandbox/stm/branches/vbe/boost/synchro/lockable.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,25 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE__HPP
+#define BOOST_SYNCHO_LOCKABLE__HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/lockable/lock.hpp>
+#include <boost/synchro/lockable/unlock.hpp>
+#include <boost/synchro/lockable/try_lock.hpp>
+#include <boost/synchro/lockable/lock_until.hpp>
+#include <boost/synchro/lockable/lock_for.hpp>
+//-----------------------------------------------------------------------------
+
+#endif // BOOST_SYNCHO_UNIQUE_LOCK__HPP

Added: sandbox/stm/branches/vbe/boost/synchro/lockable/lock.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable/lock.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE_LOCK_HPP
+#define BOOST_SYNCHO_LOCKABLE_LOCK_HPP
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template< typename Lockable >
+ inline void lock(Lockable& lockable) {
+ lockable.lock();
+ }
+
+}}
+#endif // BOOST_SYNCHO_LOCKABLE_LOCK_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockable/lock_for.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable/lock_for.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE_LOCK_FOR_HPP
+#define BOOST_SYNCHO_LOCKABLE_LOCK_FOR_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/time.hpp>
+#include <boost/synchro/lockable/lock_until.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template <typename Lockable, typename TimeDuration >
+ bool lock_for(Lockable& lockable, const TimeDuration& rel_time) {
+ return lock_until(&lockable, get_system_time()+rel_time);
+ }
+
+}}
+#endif // BOOST_SYNCHO_LOCKABLE_LOCK_FOR_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockable/lock_until.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable/lock_until.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE_LOCK_UNTIL_HPP
+#define BOOST_SYNCHO_LOCKABLE_LOCK_UNTIL_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/time.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template< typename Lockable>
+ inline bool lock_until(Lockable& lockable, system_time const& target_time) {
+ return lockable.lock_until(target_time);
+ }
+
+}}
+#endif // BOOST_SYNCHO_LOCKABLE_LOCK_UNTIL_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockable/try_lock.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable/try_lock.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE_TRY_LOCK_HPP
+#define BOOST_SYNCHO_LOCKABLE_TRY_LOCK_HPP
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template< typename Lockable >
+ inline bool try_lock(Lockable& lockable) {
+ return lockable.try_lock();
+ }
+
+}}
+#endif // BOOST_SYNCHO_TRY_LOCK_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockable/unlock.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockable/unlock.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKABLE_UNLOCK_HPP
+#define BOOST_SYNCHO_LOCKABLE_UNLOCK_HPP
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template< typename Lockable >
+ inline void unlock(Lockable& lockable) {
+ lockable.unlock();
+ }
+
+}}
+#endif // BOOST_SYNCHO_LOCKABLE_UNLOCK_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockers/lock_guard.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockers/lock_guard.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,113 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKER_LOCK_GUARD_HPP
+#define BOOST_SYNCHO_LOCKER_LOCK_GUARD_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/tags.hpp>
+#include <boost/synchro/exceptions.hpp>
+#include <boost/synchro/lockable/lock.hpp>
+#include <boost/synchro/lockable/unlock.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost {
+namespace synchro {
+
+ template<typename Mutex, Mutex& m>
+ class static_lock_guard {
+ private:
+
+ explicit static_lock_guard(static_lock_guard&);
+ static_lock_guard& operator=(static_lock_guard&);
+ public:
+ static_lock_guard()
+ {
+ lock(m);
+ }
+ explicit static_lock_guard(adopt_lock_t)
+ {}
+ ~static_lock_guard() {
+ unlock(m);
+ }
+ };
+
+ template<typename Mutex>
+ class lock_guard {
+ private:
+ Mutex& m;
+
+ explicit lock_guard(lock_guard&);
+ lock_guard& operator=(lock_guard&);
+ public:
+ explicit lock_guard(Mutex& m_)
+ : m(m_)
+ {
+ lock(m);
+ }
+ lock_guard(Mutex& m_, bool cnd, adopt_lock_t)
+ : m(m_)
+ {}
+ ~lock_guard() {
+ unlock(m);
+ }
+ };
+
+ template<typename Mutex, Mutex& m>
+ class static_lock_guard_if {
+ private:
+ bool cnd_;
+
+ explicit static_lock_guard_if(static_lock_guard_if&);
+ static_lock_guard_if& operator=(static_lock_guard_if&);
+ public:
+ explicit static_lock_guard_if(bool cnd)
+ : cnd_(cnd)
+ {
+ if (cnd_) lock(m);
+ }
+ static_lock_guard_if(bool cnd,adopt_lock_t)
+ : cnd_(cnd)
+ {}
+ ~static_lock_guard_if() {
+ if (cnd_) unlock(m);
+ }
+ };
+
+ template<typename Mutex>
+ class lock_guard_if {
+ private:
+ Mutex& m;
+ bool cnd_;
+
+ explicit lock_guard_if(lock_guard_if&);
+ lock_guard_if& operator=(lock_guard_if&);
+ public:
+ lock_guard_if(Mutex& m_, bool cnd)
+ : m(m_)
+ , cnd_(cnd)
+ {
+ if (cnd_) lock(m);
+ }
+ lock_guard_if(Mutex& m_, bool cnd, adopt_lock_t)
+ : m(m_)
+ , cnd_(cnd)
+ {}
+ ~lock_guard_if() {
+ if (cnd_) unlock(m);
+ }
+ };
+
+}}
+#endif // BOOST_SYNCHO_LOCKER_LOCK_GUARD_HPP
+

Added: sandbox/stm/branches/vbe/boost/synchro/lockers/unique_lock.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/lockers/unique_lock.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,233 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKER_UNIQUE_LOCK__HPP
+#define BOOST_SYNCHO_LOCKER_UNIQUE_LOCK__HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/detail/config.hpp>
+//-----------------------------------------------------------------------------
+#include <boost/synchro/tags.hpp>
+#include <boost/synchro/exceptions.hpp>
+#include <boost/synchro/lockable.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost {
+namespace synchro {
+
+ template<typename Mutex>
+ class unique_lock
+ {
+ private:
+ Mutex* m;
+ bool is_locked;
+ unique_lock(unique_lock&);
+ unique_lock& operator=(unique_lock&);
+ public:
+ unique_lock():
+ m(0),is_locked(false)
+ {}
+
+ explicit unique_lock(Mutex& m_):
+ m(&m_),is_locked(false)
+ {
+ lock();
+ }
+
+ unique_lock(Mutex& m_,adopt_lock_t):
+ m(&m_),is_locked(true)
+ {}
+ unique_lock(Mutex& m_,defer_lock_t):
+ m(&m_),is_locked(false)
+ {}
+ unique_lock(Mutex& m_,try_to_lock_t):
+ m(&m_),is_locked(false)
+ {
+ try_lock();
+ }
+ template<typename TimeDuration>
+ unique_lock(Mutex& m_,TimeDuration const& target_time):
+ m(&m_),is_locked(false)
+ {
+ lock_for(target_time);
+ }
+ unique_lock(Mutex& m_,system_time const& target_time):
+ m(&m_),is_locked(false)
+ {
+ lock_until(target_time);
+ }
+#ifdef BOOST_HAS_RVALUE_REFS
+ unique_lock(unique_lock&& other):
+ m(other.m),is_locked(other.is_locked)
+ {
+ other.is_locked=false;
+ other.m=0;
+ }
+ unique_lock<Mutex>&& move()
+ {
+ return static_cast<unique_lock<Mutex>&&>(*this);
+ }
+
+
+ unique_lock& operator=(unique_lock<Mutex>&& other)
+ {
+ unique_lock temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ void swap(unique_lock&& other)
+ {
+ std::swap(m,other.m);
+ std::swap(is_locked,other.is_locked);
+ }
+#else
+#if 0
+ unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
+ m(other->m),is_locked(other->is_locked)
+ {
+ other->is_locked=false;
+ other->m=0;
+ }
+
+ operator detail::thread_move_t<unique_lock<Mutex> >()
+ {
+ return move();
+ }
+
+ detail::thread_move_t<unique_lock<Mutex> > move()
+ {
+ return detail::thread_move_t<unique_lock<Mutex> >(*this);
+ }
+
+ unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
+ {
+ unique_lock temp(other);
+ swap(temp);
+ return *this;
+ }
+
+ void swap(detail::thread_move_t<unique_lock<Mutex> > other)
+ {
+ std::swap(m,other->m);
+ std::swap(is_locked,other->is_locked);
+ }
+#endif
+ void swap(unique_lock& other)
+ {
+ std::swap(m,other.m);
+ std::swap(is_locked,other.is_locked);
+ }
+
+#endif
+ ~unique_lock()
+ {
+ if(owns_lock())
+ {
+ synchro::unlock(*m);
+ }
+ }
+ void lock()
+ {
+ if(owns_lock())
+ {
+ throw lock_error();
+ }
+ synchro::lock(*m);
+ is_locked=true;
+ }
+ bool try_lock()
+ {
+ if(owns_lock())
+ {
+ throw lock_error();
+ }
+ is_locked=synchro::try_lock(*m);
+ return is_locked;
+ }
+ template<typename TimeDuration>
+ bool lock_for(TimeDuration const& relative_time)
+ {
+ is_locked=synchro::lock_for(*m, relative_time);
+ return is_locked;
+ }
+
+ bool lock_until(system_time const& absolute_time)
+ {
+ is_locked=synchro::lock_until(*m, absolute_time);
+ return is_locked;
+ }
+ void unlock()
+ {
+ if(!owns_lock())
+ {
+ throw lock_error();
+ }
+ synchro::unlock(*m);
+ is_locked=false;
+ }
+
+ typedef void (unique_lock::*bool_type)();
+ operator bool_type() const
+ {
+ return is_locked?&unique_lock::lock:0;
+ }
+ bool operator!() const
+ {
+ return !owns_lock();
+ }
+ bool owns_lock() const
+ {
+ return is_locked;
+ }
+
+ Mutex* mutex() const
+ {
+ return m;
+ }
+
+ Mutex* release()
+ {
+ Mutex* const res=m;
+ m=0;
+ is_locked=false;
+ return res;
+ }
+ };
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex>
+ void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#else
+ template<typename Mutex>
+ void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
+ {
+ lhs.swap(rhs);
+ }
+#endif
+
+#ifdef BOOST_HAS_RVALUE_REFS
+ template<typename Mutex>
+ inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)
+ {
+ return ul;
+ }
+#endif
+
+}}
+#endif // BOOST_SYNCHO_LOCKER_UNIQUE_LOCK__HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/locks.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/locks.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,25 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_LOCKS__HPP
+#define BOOST_SYNCHO_LOCKS__HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/synchro/lockers/lock_guard.hpp>
+//#include <boost/synchro/lockers/var_lock_guard.hpp>
+#include <boost/synchro/lockers/unique_lock.hpp>
+//-----------------------------------------------------------------------------
+
+#endif // BOOST_SYNCHO_UNIQUE_LOCK__HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,65 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_PTHREAD_MUTEX_HPP
+#define BOOST_SYNCHO_PTHREAD_MUTEX_HPP
+
+//-----------------------------------------------------------------------------
+#include <pthread.h>
+//-----------------------------------------------------------------------------
+#include <boost/synchro/detail/config.hpp>
+//-----------------------------------------------------------------------------
+#include <boost/synchro/exceptions.hpp>
+#include <boost/synchro/time.hpp>
+#include <boost/synchro/lockable.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ template<>
+ inline void lock<pthread_mutex_t>(pthread_mutex_t& lockable) {
+ //int const res=
+ pthread_mutex_lock(&lockable);
+ //if (res!=0) throw lock_error();
+ }
+
+ template<>
+ inline void unlock<pthread_mutex_t>(pthread_mutex_t& lockable) {
+ //int const res=
+ pthread_mutex_unlock(&lockable);
+ //if (res!=0) throw lock_error();
+ }
+
+ template<>
+ inline bool try_lock<pthread_mutex_t>(pthread_mutex_t& lockable) {
+ int const res=pthread_mutex_trylock(&lockable);
+ //BOOST_ASSERT(!res || res==EBUSY);
+ return (!res);
+ }
+
+#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+ template<>
+ inline bool lock_until<pthread_mutex_t>(
+ pthread_mutex_t& lockable, system_time const& abs_time) {
+ struct timespec const timeout=detail::get_timespec(abs_time);
+ int const res=pthread_mutex_timedlock(&lockable,&timeout);
+ //BOOST_ASSERT(!res || res==ETIMEDOUT);
+ return !res;
+ }
+#endif
+
+
+}}
+#endif // BOOST_SYNCHO_TRY_LOCK_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/tags.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/tags.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,35 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_TAGS_HPP
+#define BOOST_SYNCHO_TAGS_HPP
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ struct defer_lock_t
+ {};
+ struct try_to_lock_t
+ {};
+ struct adopt_lock_t
+ {};
+
+ const defer_lock_t defer_lock={};
+ const try_to_lock_t try_to_lock={};
+ const adopt_lock_t adopt_lock={};
+
+}}
+#endif // BOOST_SYNCHO_TAGS_HPP
+

Added: sandbox/stm/branches/vbe/boost/synchro/thread/mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/thread/mutex.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,38 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_THREAD_MUTEX_HPP
+#define BOOST_SYNCHO_THREAD_MUTEX_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/thread/mutex.hpp>
+//-----------------------------------------------------------------------------
+#include <boost/synchro/exceptions.hpp>
+#include <boost/synchro/time.hpp>
+#include <boost/synchro/lockable.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+ template<>
+ inline bool lock_until<boost::timed_mutex>(
+ boost::timed_mutex& lockable, system_time const& abs_time) {
+ return lockable.timed_lock(abs_time);
+ }
+#endif
+
+}}
+#endif // BOOST_SYNCHO_THREAD_MUTEX_HPP
+
+

Added: sandbox/stm/branches/vbe/boost/synchro/time.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/time.hpp 2009-10-18 06:19:05 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,39 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// 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)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_TIME_HPP
+#define BOOST_SYNCHO_TIME_HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/pthread/timespec.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+ using boost::system_time;
+
+ inline system_time get_system_time() {
+ return boost::get_system_time();
+ }
+
+ namespace detail {
+ inline struct timespec const get_timespec(system_time& t) {
+ return boost::detail::get_timespec(t);
+ }
+ }
+
+}}
+#endif // BOOST_SYNCHO_TRY_LOCK_HPP
+
+


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk