Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r57221 - in sandbox/stm/branches/vbe: boost/stm boost/stm/detail boost/stm/latm libs/stm/src libs/stm/test
From: vicente.botet_at_[hidden]
Date: 2009-10-29 05:27:29

Author: viboes
Date: 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
New Revision: 57221
URL: http://svn.boost.org/trac/boost/changeset/57221

Log:
TBoost.STM vbe:
* Continue moving LATM specificities to latm directory and namespace
* changing the prototype of pthread_lock/unlock to a void function to conform with the lockable concept
Added:
   sandbox/stm/branches/vbe/boost/stm/latm/dynamic_mode.hpp
      - copied, changed from r57154, /sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp
   sandbox/stm/branches/vbe/boost/stm/latm/full_mode.hpp
      - copied, changed from r57154, /sandbox/stm/branches/vbe/boost/stm/latm/full.hpp
Removed:
   sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp
   sandbox/stm/branches/vbe/boost/stm/latm/full.hpp
Text files modified:
   sandbox/stm/branches/vbe/boost/stm/detail/config.hpp | 16 ++
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp | 42 +++---
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp | 50 ++++----
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp | 42 +++---
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp | 46 ++++----
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp | 56 +++++-----
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp | 44 ++++----
   sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp | 63 ++++++-----
   sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp | 9
   sandbox/stm/branches/vbe/boost/stm/latm/base_mode.hpp | 52 ++++++---
   sandbox/stm/branches/vbe/boost/stm/latm/datatypes.hpp | 1
   sandbox/stm/branches/vbe/boost/stm/latm/dynamic_mode.hpp | 97 +++--------------
   sandbox/stm/branches/vbe/boost/stm/latm/full_mode.hpp | 96 ++++++++++++-----
   sandbox/stm/branches/vbe/boost/stm/latm/selector.hpp | 12 +
   sandbox/stm/branches/vbe/boost/stm/transaction.hpp | 88 ++++++---------
   sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp | 36 +++++-
   sandbox/stm/branches/vbe/libs/stm/test/Jamfile.v2 | 214 +++++++++++++++++++++++++++++++--------
   sandbox/stm/branches/vbe/libs/stm/test/isolatedComposedIntLockInTx2.cpp | 114 ++++++++++++--------
   sandbox/stm/branches/vbe/libs/stm/test/litExample.cpp | 8
   sandbox/stm/branches/vbe/libs/stm/test/lotExample.cpp | 4
   sandbox/stm/branches/vbe/libs/stm/test/nestedTxs.cpp | 6
   sandbox/stm/branches/vbe/libs/stm/test/testHT_latm.cpp | 2
   sandbox/stm/branches/vbe/libs/stm/test/testHashMapAndLinkedListsWithLocks.cpp | 3
   sandbox/stm/branches/vbe/libs/stm/test/testHashMapWithLocks.cpp | 2
   sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.cpp | 2
   sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.h | 7 -
   sandbox/stm/branches/vbe/libs/stm/test/txLinearLock.cpp | 4
   sandbox/stm/branches/vbe/libs/stm/test/usingLockTx.h | 4
   28 files changed, 642 insertions(+), 478 deletions(-)

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -116,6 +116,22 @@

#define BOOST_STM_USE_BOOST_SYNCHRO 1

+///////////////////////////////////////////////////////////////////////////////
+// BOOST_STM_LATM_STATIC_MODE
+// BOOST_STM_LATM_STATIC_FULL_MODE
+// BOOST_STM_LATM_STATIC_TM_MODE
+// BOOST_STM_LATM_STATIC_TX_MODE
+// BOOST_STM_LATM_DYNAMIC_MODE
+
+//#define BOOST_STM_LATM_STATIC_FULL_MODE 1
+//#define BOOST_STM_LATM_STATIC_TM_MODE 1
+//#define BOOST_STM_LATM_STATIC_TX_MODE 1
+//#define BOOST_STM_LATM_DYNAMIC_MODE 1
+
+#if defined(BOOST_STM_LATM_STATIC_FULL_MODE) || defined(BOOST_STM_LATM_STATIC_TM_MODE) || defined(BOOST_STM_LATM_STATIC_TX_MODE)
+#define BOOST_STM_LATM_STATIC_MODE 1
+#endif
+
#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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -56,7 +56,7 @@
    // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
    // so we can abort all the in-flight transactions
    //--------------------------------------------------------------------------
- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
    {
       synchro::lock_guard<Mutex> lock_g(*general_lock());
       //synchro::lock(*general_lock());
@@ -91,7 +91,7 @@
       //synchro::unlock(*inflight_lock());
    }

- try { latmLockedLocks_.insert(mutex); }
+ try { latm::instance().latmLockedLocks_.insert(mutex); }
    catch (...)
    {
       synchro::unlock(*inflight_lock());
@@ -104,7 +104,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_full_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_full_pthread_lock_mutex(latm::mutex_type* mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -117,15 +117,15 @@
       t->commit_deferred_update_tx();
        { synchro::lock_guard<Mutex> lock_l(*latm_lock());
       //synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       //synchro::unlock(*latm_lock());
        }

       // TBR if (hadLock) return 0;
       // TBR else return lock(mutex);
- if (hadLock) return 0;
+ if (hadLock) return;
       else synchro::lock(*mutex);
- return 0;
+ return;
    }

    int waitTime = 0, aborted = 0;
@@ -136,7 +136,7 @@
       //{
       synchro::lock(*mutex);
       //synchro::lock_guard<Mutex> lock_m(*mutex);
- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);
       //synchro::lock_guard<Mutex> lock_l(latmMutex_);
       try
       {
@@ -148,7 +148,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -156,7 +156,7 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       //}

       SLEEP(cm_lock_sleep_time());
@@ -164,9 +164,9 @@
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
- return 0;
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);
+ return;
}

//----------------------------------------------------------------------------
@@ -185,7 +185,7 @@
       t->commit_deferred_update_tx();
        { synchro::lock_guard<Mutex> lock_l(*latm_lock());
       //synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       //synchro::unlock(*latm_lock());
        }

@@ -198,7 +198,7 @@
    if (!synchro::try_lock(*mutex)) return 1;

    //synchro::lock(latmMutex_);
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);

    try
    {
@@ -219,7 +219,7 @@
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
    //synchro::unlock(latmMutex_);
    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
@@ -229,10 +229,10 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_full_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_full_pthread_unlock_mutex(latm::mutex_type* mutex)
{
    bool hasLock = true;
- { synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ { synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);
     //synchro::lock(latmMutex_);

    if (transaction* t = get_inflight_tx_of_same_thread(false))
@@ -249,18 +249,18 @@
       t->remove_from_currently_locked_locks(mutex);
    }

- latmLockedLocks_.erase(mutex);
+ latm::instance().latmLockedLocks_.erase(mutex);

- if (latmLockedLocks_.empty()) synchro::unlock(*inflight_lock());
+ if (latm::instance().latmLockedLocks_.empty()) synchro::unlock(*inflight_lock());

- latmLockedLocksOfThreadMap_.erase(mutex);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
    //synchro::unlock(latmMutex_);
    }

    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}

}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -58,11 +58,11 @@
    //
    // if it isn't we don't interrupt any in-flight transactions
    //--------------------------------------------------------------------------
- if (tmConflictingLocks_.find(mutex) != tmConflictingLocks_.end())
+ if (latm::instance().tmConflictingLocks_.find(mutex) != latm::instance().tmConflictingLocks_.end())
    {
       // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
       // so we can abort all the in-flight transactions
- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
       {
          synchro::lock_guard<Mutex> autolock_g(*general_lock());
          synchro::lock_guard<Mutex> autolock_i(*inflight_lock());
@@ -88,7 +88,7 @@
          }
       }

- latmLockedLocks_.insert(mutex);
+ latm::instance().latmLockedLocks_.insert(mutex);
    }

    return true;
@@ -97,11 +97,11 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
- transaction::must_be_in_tm_conflicting_lock_set(mutex);
+ latm::instance().must_be_in_tm_conflicting_lock_set(mutex);
       t->make_isolated();
       t->commit_deferred_update_tx();

@@ -111,15 +111,15 @@
       {
           synchro::lock_guard<Mutex> lock_l(*latm_lock());
       //synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       //synchro::unlock(*latm_lock());
       }

       // TBR if (hadLock) return 0;
       // TBR else return lock(mutex);
- if (hadLock) return 0;
+ if (hadLock) return;
       else synchro::lock(*mutex);
- return 0;
+ return;
    }

    int waitTime = 0, aborted = 0;
@@ -132,7 +132,7 @@
        //synchro::lock_guard<Mutex> lock_m(*latm_lock());
        //synchro::lock_guard<Mutex> lock_l(latmMutex_);
        synchro::lock(*mutex);
- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

       try
       {
@@ -145,7 +145,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -153,7 +153,7 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       //}

       SLEEP(cm_lock_sleep_time());
@@ -161,10 +161,10 @@
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

- return 0;
+ return;
}

//----------------------------------------------------------------------------
@@ -174,7 +174,7 @@
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
- transaction::must_be_in_tm_conflicting_lock_set(mutex);
+ latm::instance().must_be_in_tm_conflicting_lock_set(mutex);
       t->make_isolated();
       t->commit_deferred_update_tx();

@@ -184,7 +184,7 @@
       {
       synchro::lock_guard<Mutex> lock_l(*latm_lock());
       //synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       //synchro::unlock(*latm_lock());
       }

@@ -200,7 +200,7 @@
    if (!synchro::try_lock(*mutex)) return 1;

    //synchro::lock(latmMutex_);
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);

    try
    {
@@ -221,7 +221,7 @@
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
    //synchro::unlock(latmMutex_);
    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
@@ -231,11 +231,11 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
{
    bool hasLock = true;
    {
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);
    //synchro::lock(latmMutex_);

    if (transaction* t = get_inflight_tx_of_same_thread(false))
@@ -257,21 +257,21 @@
    // it from the latmLocks and check to see if we allow transactions to
    // continue.
    //--------------------------------------------------------------------------
- if (tmConflictingLocks_.find(mutex) != tmConflictingLocks_.end())
+ if (latm::instance().tmConflictingLocks_.find(mutex) != latm::instance().tmConflictingLocks_.end())
    {
- latmLockedLocks_.erase(mutex);
+ latm::instance().latmLockedLocks_.erase(mutex);

- if (latmLockedLocks_.empty()) synchro::unlock(*inflight_lock());
+ if (latm::instance().latmLockedLocks_.empty()) synchro::unlock(*inflight_lock());
    }

- latmLockedLocksOfThreadMap_.erase(mutex);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
    //synchro::unlock(latmMutex_);
    }

    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}

}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -93,7 +93,7 @@
       }

       try {
- latmLockedLocksAndThreadIdsMap_.insert
+ latm::instance().latmLockedLocksAndThreadIdsMap_.insert
          (std::make_pair<latm::mutex_type*, ThreadIdSet>(mutex, txThreadId));
       }
       catch (...)
@@ -121,7 +121,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
{
    int waitTime = 0, aborted = 0;

@@ -159,12 +159,12 @@
       t->add_to_obtained_locks(mutex);
       t->commit_deferred_update_tx();

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);
       def_do_core_tx_conflicting_lock_pthread_lock_mutex
          (mutex, 0, 0, true);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);

- return 0;
+ return;
    }

    for (;;)
@@ -172,7 +172,7 @@
       synchro::lock(*mutex); // TBR int val = lock(mutex);
       // TBR if (0 != val) return val;

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

       try
       {
@@ -185,7 +185,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -193,19 +193,19 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);

       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
- return 0;
+ return;
}

//----------------------------------------------------------------------------
@@ -223,7 +223,7 @@
    //if (0 != val) return val;
    if (!synchro::try_lock(*mutex)) return 1;

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -242,19 +242,19 @@
       if (!def_do_core_tx_conflicting_lock_pthread_lock_mutex(mutex, 0, 0, txIsIrrevocable))
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          return -1;
       }
    }
    catch (...)
    {
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
@@ -264,7 +264,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::def_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
{
    synchro::lock_guard<Mutex> autolock_l(*latm_lock());
    synchro::lock_guard<Mutex> autolock_g(*general_lock());
@@ -290,13 +290,13 @@
    // it from the latmLocks and any txs on the full thread list that are
    // blocked because of this lock being locked should be unblocked
    //--------------------------------------------------------------------------
- if (latmLockedLocksAndThreadIdsMap_.find(mutex) != latmLockedLocksAndThreadIdsMap_.end())
+ if (latm::instance().latmLockedLocksAndThreadIdsMap_.find(mutex) != latm::instance().latmLockedLocksAndThreadIdsMap_.end())
    {
#if LOGGING_BLOCKS
       logFile_ << "----------------------\nbefore unlocked mutex: " << mutex << endl << endl;
       logFile_ << outputBlockedThreadsAndLockedLocks() << endl;
#endif
- latmLockedLocksAndThreadIdsMap_.erase(mutex);
+ latm::instance().latmLockedLocksAndThreadIdsMap_.erase(mutex);
       unblock_conflicting_threads(mutex);

#if LOGGING_BLOCKS
@@ -305,13 +305,13 @@
#endif
    }

- latmLockedLocksOfThreadMap_.erase(mutex);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
    unblock_threads_if_locks_are_empty();

    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}

}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -56,7 +56,7 @@
    // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
    // so we can abort all the in-flight transactions
    //--------------------------------------------------------------------------
- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
    {

     //{
@@ -106,7 +106,7 @@
    }

    try {
- latmLockedLocks_.insert(mutex); }
+ latm::instance().latmLockedLocks_.insert(mutex); }
    catch (...)
    {
        // BUG ???
@@ -121,7 +121,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_full_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_full_pthread_lock_mutex(latm::mutex_type* mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -133,12 +133,12 @@

       // this method locks LATM and keeps it locked upon returning if param true
       wait_until_all_locks_are_released(true);
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       synchro::unlock(*latm_lock());

- if (hadLock) return 0;
+ if (hadLock) return;
       else synchro::lock(*mutex);
- return 0;
+ return;
    }

    int waitTime = 0, aborted = 0;
@@ -150,7 +150,7 @@
       synchro::lock(*mutex);
       //synchro::lock_guard<Mutex> lock_m(*mutex);

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);
       //synchro::lock_guard<Mutex> lock_l(latmMutex_);

       try
@@ -163,7 +163,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -171,7 +171,7 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
         //}

       SLEEP(cm_lock_sleep_time());
@@ -179,9 +179,9 @@
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
- return 0;
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);
+ return;
}

//----------------------------------------------------------------------------
@@ -199,7 +199,7 @@

       // this method locks LATM and keeps it locked upon returning if param true
       wait_until_all_locks_are_released(true);
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       synchro::unlock(*latm_lock());

       if (hadLock) return 0;
@@ -213,7 +213,7 @@
    if (!synchro::try_lock(*mutex)) return 1;

    //synchro::lock(latmMutex_);
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);

    try
    {
@@ -223,18 +223,18 @@
       if (!dir_do_core_full_pthread_lock_mutex(mutex, 0, 0))
       {
          //synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          return -1;
       }
    }
    catch (...)
    {
       //synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
    //synchro::unlock(latmMutex_);
    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
@@ -244,12 +244,12 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_full_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_full_pthread_unlock_mutex(latm::mutex_type* mutex)
{
    bool hasLock = true;
     {
    //synchro::lock(latmMutex_);
- synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ synchro::lock_guard<Mutex> lock_l(latm::instance().latmMutex_);

    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -265,9 +265,9 @@
       t->remove_from_currently_locked_locks(mutex);
    }

- latmLockedLocks_.erase(mutex);
+ latm::instance().latmLockedLocks_.erase(mutex);

- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
    {
       synchro::lock_guard<Mutex> lock_l(*general_lock());
       //synchro::lock(*general_lock());
@@ -277,13 +277,13 @@
       //synchro::unlock(*general_lock());
    }

- latmLockedLocksOfThreadMap_.erase(mutex);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
    //synchro::unlock(latmMutex_);
     }
    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}

}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -58,13 +58,13 @@
    //
    // if it isn't we don't interrupt any in-flight transactions
    //--------------------------------------------------------------------------
- if (tmConflictingLocks_.find(mutex) != tmConflictingLocks_.end())
+ if (latm::instance().tmConflictingLocks_.find(mutex) != latm::instance().tmConflictingLocks_.end())
    {
       //--------------------------------------------------------------------------
       // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
       // so we can abort all the in-flight transactions
       //--------------------------------------------------------------------------
- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
       {
          synchro::lock(*general_lock());
          synchro::lock(*inflight_lock());
@@ -108,7 +108,7 @@
          while (!transactionsInFlight_.empty()) { SLEEP(10); }
       }

- latmLockedLocks_.insert(mutex);
+ latm::instance().latmLockedLocks_.insert(mutex);
    }

    return true;
@@ -117,17 +117,17 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
- transaction::must_be_in_tm_conflicting_lock_set(mutex);
+ latm::instance().must_be_in_tm_conflicting_lock_set(mutex);
       t->make_isolated();
       synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       synchro::unlock(*latm_lock());
       synchro::lock(*mutex);
- return 0;
+ return;
    }

    int waitTime = 0, aborted = 0;
@@ -138,7 +138,7 @@
       // TBR if (0 != val) return val;
       synchro::lock(*mutex);

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

       try
       {
@@ -151,7 +151,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -159,17 +159,17 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);

       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

- return 0;
+ return;
}

//----------------------------------------------------------------------------
@@ -179,10 +179,10 @@
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
- transaction::must_be_in_tm_conflicting_lock_set(mutex);
+ latm::instance().must_be_in_tm_conflicting_lock_set(mutex);
       t->make_isolated();
       synchro::lock(*latm_lock());
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       synchro::unlock(*latm_lock());
       return synchro::try_lock(*mutex)?0:1;
    }
@@ -191,7 +191,7 @@
    //if (0 != val) return val;
    if (!synchro::try_lock(*mutex)) return 1;

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

    try
    {
@@ -201,19 +201,19 @@
       if (!dir_do_core_tm_conflicting_lock_pthread_lock_mutex(mutex, 0, 0))
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          return -1;
       }
    }
    catch (...)
    {
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);
    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
    return 0;
@@ -222,9 +222,9 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
{
- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);
    bool hasLock = true;

    if (transaction* t = get_inflight_tx_of_same_thread(false))
@@ -246,11 +246,11 @@
    // it from the latmLocks and check to see if we allow transactions to
    // continue.
    //--------------------------------------------------------------------------
- if (tmConflictingLocks_.find(mutex) != tmConflictingLocks_.end())
+ if (latm::instance().tmConflictingLocks_.find(mutex) != latm::instance().tmConflictingLocks_.end())
    {
- latmLockedLocks_.erase(mutex);
+ latm::instance().latmLockedLocks_.erase(mutex);

- if (latmLockedLocks_.empty())
+ if (latm::instance().latmLockedLocks_.empty())
       {
          synchro::lock(*general_lock());

@@ -260,13 +260,13 @@
       }
    }

- latmLockedLocksOfThreadMap_.erase(mutex);
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
+ synchro::unlock(latm::instance().latmMutex_);

    //if (hasLock) return unlock(mutex);
    //else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}

}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -95,9 +95,9 @@

       try
       {
- latmLockedLocksAndThreadIdsMap_.insert
+ latm::instance().latmLockedLocksAndThreadIdsMap_.insert
          (std::make_pair<latm::mutex_type*, ThreadIdSet>(mutex, txThreadId));
- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
       }
       catch (...)
       {
@@ -154,7 +154,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex)
{
    int waitTime = 0, aborted = 0;

@@ -192,12 +192,12 @@
       t->add_to_currently_locked_locks(mutex);
       t->add_to_obtained_locks(mutex);

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);
       def_do_core_tx_conflicting_lock_pthread_lock_mutex
          (mutex, 0, 0, true);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);

- return 0;
+ return;
    }

    for (;;)
@@ -206,7 +206,7 @@
       // TBR if (0 != val) return val;
       synchro::lock(*mutex);

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

       try
       {
@@ -219,7 +219,7 @@
       catch (...)
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          throw;
       }

@@ -227,19 +227,19 @@
       // we weren't able to do the core lock work, unlock our mutex and sleep
       //-----------------------------------------------------------------------
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);

       SLEEP(cm_lock_sleep_time());
       waitTime += cm_lock_sleep_time();
       ++aborted;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
- return 0;
+ return;
}

//----------------------------------------------------------------------------
@@ -256,7 +256,7 @@
    //if (0 != val) return val;
    if (!synchro::try_lock(*mutex)) return 1;

- synchro::lock(latmMutex_);
+ synchro::lock(latm::instance().latmMutex_);

    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -274,19 +274,19 @@
       if (!dir_do_core_tx_conflicting_lock_pthread_lock_mutex(mutex, 0, 0, txIsIrrevocable))
       {
          synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
          return -1;
       }
    }
    catch (...)
    {
       synchro::unlock(*mutex);
- synchro::unlock(latmMutex_);
+ synchro::unlock(latm::instance().latmMutex_);
       throw;
    }

- latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
- synchro::unlock(latmMutex_);
+ latm::instance().latmLockedLocksOfThreadMap_[mutex] = this_thread::get_id();
+ synchro::unlock(latm::instance().latmMutex_);

    // note: we do not release the transactionsInFlightMutex - this will prevents
    // new transactions from starting until this lock is released
@@ -296,7 +296,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
+inline void transaction::dir_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex)
{
    synchro::lock_guard<Mutex> autolock_l(*latm_lock());
    synchro::lock_guard<Mutex> autolock_g(*general_lock());
@@ -322,19 +322,19 @@
    // it from the latmLocks and any txs on the full thread list that are
    // blocked because of this lock being locked should be unblocked
    //--------------------------------------------------------------------------
- if (latmLockedLocksAndThreadIdsMap_.find(mutex) != latmLockedLocksAndThreadIdsMap_.end())
+ if (latm::instance().latmLockedLocksAndThreadIdsMap_.find(mutex) != latm::instance().latmLockedLocksAndThreadIdsMap_.end())
    {
- latmLockedLocksAndThreadIdsMap_.erase(mutex);
+ latm::instance().latmLockedLocksAndThreadIdsMap_.erase(mutex);
       unblock_conflicting_threads(mutex);
    }

- latmLockedLocksOfThreadMap_.erase(mutex);
+ latm::instance().latmLockedLocksOfThreadMap_.erase(mutex);
    unblock_threads_if_locks_are_empty();

    // TBR if (hasLock) return unlock(mutex);
    // TBR else return 0;
    if (hasLock) synchro::unlock(*mutex);
- return 0;
+ return;
}
}}

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -51,7 +51,7 @@
    while (true)
    {
       synchro::lock(*latm_lock());
- if (latmLockedLocks_.empty()) break;
+ if (latm::instance().latmLockedLocks_.empty()) break;
       synchro::unlock(*latm_lock());
       SLEEP(10);
    }
@@ -166,7 +166,7 @@
inline void boost::stm::transaction::unblock_conflicting_threads(latm::mutex_type* mutex)
{
    // if the mutex is on the latm locks map, we can't unblock yet
- if (latmLockedLocksAndThreadIdsMap_.find(mutex) != latmLockedLocksAndThreadIdsMap_.end())
+ if (latm::instance().latmLockedLocksAndThreadIdsMap_.find(mutex) != latm::instance().latmLockedLocksAndThreadIdsMap_.end())
    {
#if LOGGING_BLOCKS
       logFile_ << "\ncannot unlock <" << mutex << ">, in latmLockedLocksAndThreadIdsMap_" << endl << endl;
@@ -192,7 +192,7 @@
{
#if 0
    // if the size is 0, unblock everybody
- if (latmLockedLocksOfThreadMap_.empty())
+ if (latm::instance().latmLockedLocksOfThreadMap_.empty())
    {
       for (latm::thread_id_mutex_set_map::iterator it = threadObtainedLocks_.begin();
       it != threadObtainedLocks_.end(); ++it)
@@ -206,8 +206,12 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
+
inline void boost::stm::transaction::tm_lock_conflict(latm::mutex_type* inLock)
{
+#if 1
+ latm::instance().tm_lock_conflict(inLock);
+#else
    if (!latm::instance().doing_tm_lock_protection()) return;

    //synchro::lock(latmMutex_);
@@ -225,8 +229,11 @@
       //throw;
    //}
    //synchro::unlock(latmMutex_);
+#endif
}

+#if 0
+
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline void boost::stm::transaction::clear_tm_conflicting_locks()
@@ -246,6 +253,7 @@
       throw "lock not in tx conflict lock set, use add_tm_conflicting_lock";
    }
}
+#endif

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
@@ -300,21 +308,21 @@
// the client chose
//
//----------------------------------------------------------------------------
-inline int boost::stm::transaction::pthread_lock(latm::mutex_type* mutex)
+inline void boost::stm::transaction::pthread_lock(latm::mutex_type* mutex)
{
    //using namespace boost::stm;

    switch (latm::instance().protection())
    {
    case eFullLatmProtection:
- if (direct_updating()) return dir_full_pthread_lock_mutex(mutex);
- else return def_full_pthread_lock_mutex(mutex);
+ if (direct_updating()) {dir_full_pthread_lock_mutex(mutex); return;}
+ else {def_full_pthread_lock_mutex(mutex);return;}
    case eTmConflictingLockLatmProtection:
- if (direct_updating()) return dir_tm_conflicting_lock_pthread_lock_mutex(mutex);
- else return def_tm_conflicting_lock_pthread_lock_mutex(mutex);
+ if (direct_updating()) {dir_tm_conflicting_lock_pthread_lock_mutex(mutex);return;}
+ else {def_tm_conflicting_lock_pthread_lock_mutex(mutex);return;}
    case eTxConflictingLockLatmProtection:
- if (direct_updating()) return dir_tx_conflicting_lock_pthread_lock_mutex(mutex);
- else return def_tx_conflicting_lock_pthread_lock_mutex(mutex);
+ if (direct_updating()) {dir_tx_conflicting_lock_pthread_lock_mutex(mutex);return;}
+ else {def_tx_conflicting_lock_pthread_lock_mutex(mutex);return;}
    default:
       throw "invalid LATM type";
    }
@@ -322,6 +330,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
+#if 0
inline int boost::stm::transaction::pthread_trylock(latm::mutex_type* mutex)
{
    //using namespace boost::stm;
@@ -341,24 +350,24 @@
       throw "invalid LATM type";
    }
}
-
+#endif
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline int boost::stm::transaction::pthread_unlock(latm::mutex_type* mutex)
+inline void boost::stm::transaction::pthread_unlock(latm::mutex_type* mutex)
{
    //using namespace boost::stm;

    switch (latm::instance().protection())
    {
    case eFullLatmProtection:
- if (direct_updating()) return dir_full_pthread_unlock_mutex(mutex);
- return def_full_pthread_unlock_mutex(mutex);
+ if (direct_updating()) {dir_full_pthread_unlock_mutex(mutex);return;}
+ else {def_full_pthread_unlock_mutex(mutex);return;}
    case eTmConflictingLockLatmProtection:
- if (direct_updating()) return dir_tm_conflicting_lock_pthread_unlock_mutex(mutex);
- else return def_tm_conflicting_lock_pthread_unlock_mutex(mutex);
+ if (direct_updating()) {dir_tm_conflicting_lock_pthread_unlock_mutex(mutex);return;}
+ else {def_tm_conflicting_lock_pthread_unlock_mutex(mutex); return;}
    case eTxConflictingLockLatmProtection:
- if (direct_updating()) return dir_tx_conflicting_lock_pthread_unlock_mutex(mutex);
- else return def_tx_conflicting_lock_pthread_unlock_mutex(mutex);
+ if (direct_updating()) {dir_tx_conflicting_lock_pthread_unlock_mutex(mutex);return;}
+ else {def_tx_conflicting_lock_pthread_unlock_mutex(mutex);return;}
    default:
       throw "invalid LATM type";
    }
@@ -385,8 +394,8 @@
    //--------------------------------------------------------------------------
    // iterate through all currently locked locks
    //--------------------------------------------------------------------------
- for (latm::mutex_thread_id_set_map::iterator iter = latmLockedLocksAndThreadIdsMap_.begin();
- latmLockedLocksAndThreadIdsMap_.end() != iter; ++iter)
+ for (latm::mutex_thread_id_set_map::iterator iter = latm::instance().latmLockedLocksAndThreadIdsMap_.begin();
+ latm::instance().latmLockedLocksAndThreadIdsMap_.end() != iter; ++iter)
    {
       //-----------------------------------------------------------------------
       // iterate through this transaction's conflicting mutex ref - if one of
@@ -404,19 +413,19 @@
    for (latm::mutex_set::iterator k = get_tx_conflicting_locks().begin(); k != get_tx_conflicting_locks().end(); ++k)
    {
       // if it is locked by our thread, it is ok ... otherwise it is not
- latm::mutex_thread_id_map::iterator l = latmLockedLocksOfThreadMap_.find(*k);
+ latm::mutex_thread_id_map::iterator l = latm::instance().latmLockedLocksOfThreadMap_.find(*k);

- if (l != latmLockedLocksOfThreadMap_.end() &&
+ if (l != latm::instance().latmLockedLocksOfThreadMap_.end() &&
          this_thread::get_id() != l->second)
       {
- latm::mutex_thread_id_set_map::iterator locksAndThreadsIter = latmLockedLocksAndThreadIdsMap_.find(*k);
+ latm::mutex_thread_id_set_map::iterator locksAndThreadsIter = latm::instance().latmLockedLocksAndThreadIdsMap_.find(*k);

- if (locksAndThreadsIter == latmLockedLocksAndThreadIdsMap_.end())
+ if (locksAndThreadsIter == latm::instance().latmLockedLocksAndThreadIdsMap_.end())
          {
             ThreadIdSet s;
             s.insert(this_thread::get_id());

- latmLockedLocksAndThreadIdsMap_.insert
+ latm::instance().latmLockedLocksAndThreadIdsMap_.insert
             (std::make_pair<latm::mutex_type*, ThreadIdSet>(*k, s));
          }
          else
@@ -440,8 +449,8 @@
{
    int count = 0;

- for (latm::mutex_thread_id_set_map::iterator iter = latmLockedLocksAndThreadIdsMap_.begin();
- latmLockedLocksAndThreadIdsMap_.end() != iter; ++iter)
+ for (latm::mutex_thread_id_set_map::iterator iter = latm::instance().latmLockedLocksAndThreadIdsMap_.begin();
+ latm::instance().latmLockedLocksAndThreadIdsMap_.end() != iter; ++iter)
    {
       if (iter->second.find(threadId) != iter->second.end()) ++count;
    }

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-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -539,8 +539,8 @@

    o << "Currently locked locks:" << endl << endl;

- for (latm::mutex_thread_id_set_map::iterator i = latmLockedLocksAndThreadIdsMap_.begin();
- i != latmLockedLocksAndThreadIdsMap_.end(); ++i)
+ for (latm::mutex_thread_id_set_map::iterator i = latm::instance().latmLockedLocksAndThreadIdsMap_.begin();
+ i != latm::instance().latmLockedLocksAndThreadIdsMap_.end(); ++i)
    {
       o << i->first << endl << "\t";

@@ -616,6 +616,7 @@
    return true;
}

+#if 0
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline bool transaction::can_go_inflight()
@@ -658,7 +659,7 @@

    return true;
}
-
+#endif
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void transaction::put_tx_inflight()
@@ -670,7 +671,7 @@
       //lock(inflight_lock());
       synchro::lock_guard<Mutex> lock_i(*inflight_lock());

- if (can_go_inflight() && !isolatedTxInFlight())
+ if (latm::instance().can_go_inflight() && !isolatedTxInFlight())
       {
          transactionsInFlight_.insert(this);
          state_ = e_in_flight;

Modified: sandbox/stm/branches/vbe/boost/stm/latm/base_mode.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/latm/base_mode.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/latm/base_mode.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -1,10 +1,10 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Justin E. Gottchlich 2009.
-// (C) Copyright Vicente J. Botet Escriba 2009.
+// (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
+// 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.
@@ -16,23 +16,39 @@

#include <boost/stm/detail/config.hpp>
#include <boost/stm/latm/datatypes.hpp>
+#include <boost/synchro.hpp>

namespace boost { namespace stm { namespace latm {

- class base_mode {
- public:
- virtual latm_type const protection() =0;
- virtual std::string const protection_str();
-
- virtual bool doing_full_lock_protection();
- virtual bool doing_tm_lock_protection();
- virtual bool doing_tx_lock_protection();
-
- virtual void lock(mutex_type& lock);
- virtual bool try_lock(mutex_type& lock);
- virtual void unlock(mutex_type& lock);
- };
-
+template <typename Base=static_mode>
+class base_mode : public Base {
+public:
+ latm::mutex_set tmConflictingLocks_;
+ latm::mutex_set latmLockedLocks_;
+ latm::mutex_thread_id_set_map latmLockedLocksAndThreadIdsMap_;
+ latm::mutex_thread_id_map latmLockedLocksOfThreadMap_;
+
+ mutex_type latmMutex_;
+
+
+ latm::mutex_set get_tm_conflicting_locks() { return tmConflictingLocks_; }
+
+ void clear_tm_conflicting_locks()
+ {
+ synchro::lock_guard<Mutex> lock_l(latmMutex_);
+ tmConflictingLocks_.clear();
+ }
+
+ void must_be_in_tm_conflicting_lock_set(latm::mutex_type* inLock)
+ {
+ if (tmConflictingLocks_.find(inLock) == tmConflictingLocks_.end())
+ {
+ throw "lock not in tx conflict lock set, use add_tm_conflicting_lock";
+ }
+ }
+
+};
+
}}}

#endif // BOOST_STM_LATM_DYNAMIC__HPP

Modified: sandbox/stm/branches/vbe/boost/stm/latm/datatypes.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/latm/datatypes.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/latm/datatypes.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -20,6 +20,7 @@
#include <map>

namespace boost { namespace stm { namespace latm {
+ struct static_mode {};
#if BOOST_STM_LATM_GENERIC
//typedef synchro::poly::mutex mutex_type;
#else

Deleted: sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
+++ (empty file)
@@ -1,112 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (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_STM_LATM_DYNAMIC__HPP
-#define BOOST_STM_LATM_DYNAMIC__HPP
-
-#include <boost/stm/detail/config.hpp>
-#include <boost/stm/latm/datatypes.hpp>
-
-namespace boost { namespace stm { namespace latm {
- #if 0
- struct poly {
- static full_mode<base_mode> full_;
- static tm_mode<base_mode> tm_;
- static tx_mode<base_mode> tx_;
- static base_mode* more_;
- };
- void do_full_lock_protection() {
- poly::mode_ = &full_;
- }
- void do_tm_lock_protection() {
- poly::mode_ = &tm_;
- }
- void do_tx_lock_protection() {
- poly::mode_ = &tx_;
- }
- inline base_mode& instance() {
- return poly::mode_;
- }
-
- #endif
- class dynamic {
- latm_type eLatmType_;
- public:
- dynamic() : eLatmType_(eFullLatmProtection) {}
- latm_type const protection() { return eLatmType_; }
- std::string const protection_str() {
- switch (eLatmType_)
- {
- case eFullLatmProtection:
- return "full_protect";
- case eTmConflictingLockLatmProtection:
- return "tm_protect";
- case eTxConflictingLockLatmProtection:
- return "tx_protect";
- default:
- throw "invalid LATM type";
- }
- }
- void do_full_lock_protection_i() {
- eLatmType_ = eFullLatmProtection;
- }
- void do_tm_lock_protection_i() {
- eLatmType_ = eTmConflictingLockLatmProtection;
- }
- void do_tx_lock_protection_i() {
- eLatmType_ = eTxConflictingLockLatmProtection;
- }
-
- bool doing_full_lock_protection() {
- return eFullLatmProtection == eLatmType_;
- }
- bool doing_tm_lock_protection() {
- return eTmConflictingLockLatmProtection == eLatmType_;
- }
- bool doing_tx_lock_protection() {
- return eTxConflictingLockLatmProtection == eLatmType_;
- }
-
-#if BOOST_STM_LATM_GENERIC
- template <typename Lockable>
- void lock(Lockable& lock);
- template <typename Lockable>
- bool try_lock(Lockable& lock);
- template <typename Lockable>
- void unlock(Lockable& lock);
-#else
- int lock(mutex_type& lock);
- int try_lock(mutex_type& lock);
- int unlock(mutex_type& lock);
-#endif
-
- };
- inline dynamic& instance() {
- static dynamic ctx;
- return ctx;
- }
- inline void do_full_lock_protection() {
- instance().do_full_lock_protection_i();
- }
- inline void do_tm_lock_protection() {
- instance().do_tm_lock_protection_i();
- }
- inline void do_tx_lock_protection() {
- instance().do_tx_lock_protection_i();
- }
-
-}}}
-
-#endif // BOOST_STM_LATM_DYNAMIC__HPP
-
-

Copied: sandbox/stm/branches/vbe/boost/stm/latm/dynamic_mode.hpp (from r57154, /sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp)
==============================================================================
--- /sandbox/stm/branches/vbe/boost/stm/latm/dynamic.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/latm/dynamic_mode.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -16,94 +16,33 @@

#include <boost/stm/detail/config.hpp>
#include <boost/stm/latm/datatypes.hpp>
+#include <boost/stm/latm/base_mode.hpp>
+#include <boost/stm/latm/abstract_mode.hpp>
+#include <boost/stm/latm/full_mode.hpp>
+#include <boost/stm/latm/tm_mode.hpp>
+#include <boost/stm/latm/tx_mode.hpp>

namespace boost { namespace stm { namespace latm {
- #if 0
- struct poly {
- static full_mode<base_mode> full_;
- static tm_mode<base_mode> tm_;
- static tx_mode<base_mode> tx_;
- static base_mode* more_;
+ typedef base_mode<abstract_mode> latm_mode;
+ struct mode {
+ static full_mode<abstract_mode> full_;
+ static tm_mode<abstract_mode> tm_;
+ static tx_mode<abstract_mode> tx_;
+ static latm_mode* instance_;
     };
- void do_full_lock_protection() {
- poly::mode_ = &full_;
- }
- void do_tm_lock_protection() {
- poly::mode_ = &tm_;
- }
- void do_tx_lock_protection() {
- poly::mode_ = &tx_;
- }
- inline base_mode& instance() {
- return poly::mode_;
- }
-
- #endif
- class dynamic {
- latm_type eLatmType_;
- public:
- dynamic() : eLatmType_(eFullLatmProtection) {}
- latm_type const protection() { return eLatmType_; }
- std::string const protection_str() {
- switch (eLatmType_)
- {
- case eFullLatmProtection:
- return "full_protect";
- case eTmConflictingLockLatmProtection:
- return "tm_protect";
- case eTxConflictingLockLatmProtection:
- return "tx_protect";
- default:
- throw "invalid LATM type";
- }
- }
- void do_full_lock_protection_i() {
- eLatmType_ = eFullLatmProtection;
- }
- void do_tm_lock_protection_i() {
- eLatmType_ = eTmConflictingLockLatmProtection;
- }
- void do_tx_lock_protection_i() {
- eLatmType_ = eTxConflictingLockLatmProtection;
- }
-
- bool doing_full_lock_protection() {
- return eFullLatmProtection == eLatmType_;
- }
- bool doing_tm_lock_protection() {
- return eTmConflictingLockLatmProtection == eLatmType_;
- }
- bool doing_tx_lock_protection() {
- return eTxConflictingLockLatmProtection == eLatmType_;
- }
-
-#if BOOST_STM_LATM_GENERIC
- template <typename Lockable>
- void lock(Lockable& lock);
- template <typename Lockable>
- bool try_lock(Lockable& lock);
- template <typename Lockable>
- void unlock(Lockable& lock);
-#else
- int lock(mutex_type& lock);
- int try_lock(mutex_type& lock);
- int unlock(mutex_type& lock);
-#endif
-
- };
- inline dynamic& instance() {
- static dynamic ctx;
- return ctx;
- }
     inline void do_full_lock_protection() {
- instance().do_full_lock_protection_i();
+ mode::instance_ = &mode::full_;
     }
     inline void do_tm_lock_protection() {
- instance().do_tm_lock_protection_i();
+ mode::instance_ = &mode::tm_;
     }
     inline void do_tx_lock_protection() {
- instance().do_tx_lock_protection_i();
+ mode::instance_ = &mode::tx_;
     }
+ inline latm_mode& instance() {
+ return *mode::instance_;
+ }
+

}}}

Deleted: sandbox/stm/branches/vbe/boost/stm/latm/full.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/latm/full.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
+++ (empty file)
@@ -1,51 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (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_STM_LATM_DYNAMIC__HPP
-#define BOOST_STM_LATM_DYNAMIC__HPP
-
-#include <boost/stm/detail/config.hpp>
-#include <boost/stm/latm/datatypes.hpp>
-
-namespace boost { namespace stm { namespace latm {
-
- struct static_mode {};
- template <typename Base=static_mode>
- class full_mode : {
- public:
- latm_type const protection() { return eFullLatmProtection; }
- std::string const protection_str() {
- return "full_protect";
- }
-
- bool doing_full_lock_protection() {
- return true;
- }
- bool doing_tm_lock_protection() {
- return false;
- }
- bool doing_tx_lock_protection() {
- return false;
- }
-
- int lock(mutex_type& lock);
- int try_lock(mutex_type& lock);
- int unlock(mutex_type& lock);
-
- };
-
-}}}
-
-#endif // BOOST_STM_LATM_DYNAMIC__HPP
-
-

Copied: sandbox/stm/branches/vbe/boost/stm/latm/full_mode.hpp (from r57154, /sandbox/stm/branches/vbe/boost/stm/latm/full.hpp)
==============================================================================
--- /sandbox/stm/branches/vbe/boost/stm/latm/full.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/latm/full_mode.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -1,51 +1,89 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Justin E. Gottchlich 2009.
-// (C) Copyright Vicente J. Botet Escriba 2009.
+// (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
+// 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_STM_LATM_DYNAMIC__HPP
-#define BOOST_STM_LATM_DYNAMIC__HPP
+#ifndef BOOST_STM_LATM_FULL_MIXIN__HPP
+#define BOOST_STM_LATM_FULL_MIXIN__HPP

+//-----------------------------------------------------------------------------
#include <boost/stm/detail/config.hpp>
#include <boost/stm/latm/datatypes.hpp>
+#include <boost/stm/latm/base_mode.hpp>
+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------
namespace boost { namespace stm { namespace latm {

- struct static_mode {};
- template <typename Base=static_mode>
- class full_mode : {
- public:
- latm_type const protection() { return eFullLatmProtection; }
- std::string const protection_str() {
- return "full_protect";
+//-----------------------------------------------------------------------------
+template <typename Base=static_mode>
+class full_mode : public base_mode<Base> {
+public:
+
+ ~full_mode() {}
+//-----------------------------------------------------------------------------
+ latm_type const protection() { return eFullLatmProtection; }
+ std::string const protection_str() {
+ return "full_protect";
+ }
+
+ bool doing_full_lock_protection() {
+ return true;
+ }
+
+ bool doing_tm_lock_protection() {
+ return false;
+ }
+
+ bool doing_tx_lock_protection() {
+ return false;
+ }
+
+//-----------------------------------------------------------------------------
+ bool can_go_inflight()
+ {
+ // allow transactions
+ // to start only if no locks are obtained or the only lock that
+ // is obtained is on this_thread::get_id()
+ for (latm::mutex_thread_id_map::iterator j = this->latmLockedLocksOfThreadMap_.begin();
+ j != this->latmLockedLocksOfThreadMap_.end(); ++j)
+ {
+ if (this_thread::get_id() != j->second)
+ {
+ return false;
+ }
}

- bool doing_full_lock_protection() {
- return true;
- }
- bool doing_tm_lock_protection() {
- return false;
- }
- bool doing_tx_lock_protection() {
- return false;
- }
-
- int lock(mutex_type& lock);
- int try_lock(mutex_type& lock);
- int unlock(mutex_type& lock);
-
+ return true;
+ }
+
+//-----------------------------------------------------------------------------
+ void tm_lock_conflict(Mutex &lock)
+ {
+ tm_lock_conflict(&lock);
+ }
+ void tm_lock_conflict(latm::mutex_type* inLock)
+ {
+ return ;
+ }
+
+//-----------------------------------------------------------------------------
+ //int lock(mutex_type& lock);
+ //int try_lock(mutex_type& lock);
+ //int unlock(mutex_type& lock);
+
};
-
+
}}}

-#endif // BOOST_STM_LATM_DYNAMIC__HPP
+#endif // BOOST_STM_LATM_FULL_MIXIN__HPP

Modified: sandbox/stm/branches/vbe/boost/stm/latm/selector.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/latm/selector.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/latm/selector.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -18,10 +18,16 @@
#include <boost/stm/detail/config.hpp>
//-----------------------------------------------------------------------------

-#if defined(BOOST_STM_LATM_STATIC_CONF)
-#include BOOST_STM_LATM_STATIC_CONF
+#if defined(BOOST_STM_LATM_STATIC_FULL_MODE)
+#include <boost/stm/latm/static_full_mode.hpp>
+#elif defined(BOOST_STM_LATM_STATIC_TM_MODE)
+#include <boost/stm/latm/static_tm_mode.hpp>
+#elif defined(BOOST_STM_LATM_STATIC_TX_MODE)
+#include <boost/stm/latm/static_tx_mode.hpp>
+#elif defined(BOOST_STM_LATM_DYNAMIC_MODE)
+#include <boost/stm/latm/dynamic_mode.hpp>
#else
-#include <boost/stm/latm/dynamic.hpp>
+#include <boost/stm/latm/all_in_one_mode.hpp>
#endif

#endif // BOOST_STM_LATM_SELECTOR__HPP

Modified: sandbox/stm/branches/vbe/boost/stm/transaction.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/transaction.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/transaction.hpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -334,19 +334,19 @@
    template <>
    inline static int unlock_(Mutex *lock) { return pthread_unlock(lock); }
     #else
- inline static int lock_(PLOCK &lock) { return pthread_lock(&lock); }
- inline static int lock_(PLOCK *lock) { return pthread_lock(lock); }
+ inline static void lock_(latm::mutex_type &lock) { pthread_lock(&lock); }
+ inline static void lock_(latm::mutex_type *lock) { pthread_lock(lock); }

- inline static int trylock_(PLOCK &lock) { return pthread_trylock(&lock); }
- inline static int trylock_(PLOCK *lock) { return pthread_trylock(lock); }
+ //inline static int trylock_(latm::mutex_type &lock) { return pthread_trylock(&lock); }
+ //inline static int trylock_(latm::mutex_type *lock) { return pthread_trylock(lock); }

- inline static int unlock_(PLOCK &lock) { return pthread_unlock(&lock); }
- inline static int unlock_(PLOCK *lock) { return pthread_unlock(lock); }
+ inline static void unlock_(latm::mutex_type &lock) { pthread_unlock(&lock); }
+ inline static void unlock_(latm::mutex_type *lock) { pthread_unlock(lock); }
     #endif

- static int pthread_lock(latm::mutex_type* lock);
- static int pthread_trylock(latm::mutex_type* lock);
- static int pthread_unlock(latm::mutex_type* lock);
+ static void pthread_lock(latm::mutex_type* lock);
+ //static int pthread_trylock(latm::mutex_type* lock);
+ static void pthread_unlock(latm::mutex_type* lock);

    //--------------------------------------------------------------------------
     #if PERFORMING_LATM
@@ -356,12 +356,12 @@
       tm_lock_conflict(&lock);
    }
    static void tm_lock_conflict(latm::mutex_type* lock);
-
+
    static void clear_tm_conflicting_locks();
- inline static latm::mutex_set get_tm_conflicting_locks() { return tmConflictingLocks_; }
+ //inline static latm::mutex_set get_tm_conflicting_locks() { return tmConflictingLocks_; }

    void must_be_in_conflicting_lock_set(latm::mutex_type* inLock);
- static void must_be_in_tm_conflicting_lock_set(latm::mutex_type* inLock);
+ //static void must_be_in_tm_conflicting_lock_set(latm::mutex_type* inLock);

     #if USING_TRANSACTION_SPECIFIC_LATM
    void see_if_tx_must_block_due_to_tx_latm();
@@ -380,6 +380,8 @@

    void clear_tx_conflicting_locks();
    //latm::mutex_set get_tx_conflicting_locks() { return conflictingMutexRef_; }
+
+
     #endif

    void add_to_obtained_locks(latm::mutex_type* mutex);
@@ -743,7 +745,8 @@
    void lock_tx();
    void unlock_tx();

- inline static PLOCK* latm_lock() { return &latmMutex_; }
+ //inline static latm_mutex* latm_lock() { return &latmMutex_; }
+ inline static latm::mutex_type* latm_lock() { return &latm::instance().latmMutex_; }
    inline static PLOCK* general_lock() { return &transactionMutex_; }
    inline static PLOCK* inflight_lock() { return &transactionsInFlightMutex_; }

@@ -754,7 +757,7 @@
    bool canAbortAllInFlightTxs();
    bool abortAllInFlightTxs();
    void put_tx_inflight();
- bool can_go_inflight();
+ //static bool can_go_inflight();
    static transaction* get_inflight_tx_of_same_thread(bool);

#if !PERFORMING_VALIDATION
@@ -1276,32 +1279,32 @@
    //--------------------------------------------------------------------------
    // deferred updating locking methods
    //--------------------------------------------------------------------------
- static int def_full_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void def_full_pthread_lock_mutex(latm::mutex_type* mutex);
    static int def_full_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int def_full_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void def_full_pthread_unlock_mutex(latm::mutex_type* mutex);

- static int def_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void def_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
    static int def_tm_conflicting_lock_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int def_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void def_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);

- static int def_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void def_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
    static int def_tx_conflicting_lock_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int def_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void def_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);

    //--------------------------------------------------------------------------
    // direct updating locking methods
    //--------------------------------------------------------------------------
- static int dir_full_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void dir_full_pthread_lock_mutex(latm::mutex_type* mutex);
    static int dir_full_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int dir_full_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void dir_full_pthread_unlock_mutex(latm::mutex_type* mutex);

- static int dir_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void dir_tm_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
    static int dir_tm_conflicting_lock_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int dir_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void dir_tm_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);

- static int dir_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
+ static void dir_tx_conflicting_lock_pthread_lock_mutex(latm::mutex_type* mutex);
    static int dir_tx_conflicting_lock_pthread_trylock_mutex(latm::mutex_type* mutex);
- static int dir_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);
+ static void dir_tx_conflicting_lock_pthread_unlock_mutex(latm::mutex_type* mutex);

    //--------------------------------------------------------------------------

@@ -1309,18 +1312,18 @@
    static DeletionBuffer deletionBuffer_;
    static std::ofstream logFile_;

- static latm::mutex_set tmConflictingLocks_;
- static latm::mutex_set latmLockedLocks_;
- static latm::mutex_thread_id_set_map latmLockedLocksAndThreadIdsMap_;
- static latm::mutex_thread_id_map latmLockedLocksOfThreadMap_;
+ //static latm::mutex_set tmConflictingLocks_;
+ //static latm::mutex_set latmLockedLocks_;
+ //static latm::mutex_thread_id_set_map latmLockedLocksAndThreadIdsMap_;
+ //static latm::mutex_thread_id_map latmLockedLocksOfThreadMap_;
    //static LatmType eLatmType_;
    static InflightTxes transactionsInFlight_;

    static Mutex deletionBufferMutex_;
    static Mutex transactionMutex_;
    static Mutex transactionsInFlightMutex_;
- static Mutex latmMutex_;
- static pthread_mutexattr_t transactionMutexAttribute_;
+ //static Mutex latmMutex_;
+ //static pthread_mutexattr_t transactionMutexAttribute_;

    static bool initialized_;
    static bool directLateWriteReadConflict_;
@@ -2015,27 +2018,6 @@
     ~thread_initializer() {transaction::terminate_thread();}
};

-#if 0
-
-template <>
-inline int transaction::lock<Mutex> (Mutex &lock) { return transaction::pthread_lock(&lock); }
-
-template <>
-inline int transaction::lock<Mutex*> (Mutex *lock) { return transaction::pthread_lock(lock); }
-
-template <>
-inline int transaction::trylock<Mutex> (Mutex &lock) { return transaction::pthread_trylock(&lock); }
-
-template <>
-inline int transaction::trylock<Mutex*> (Mutex *lock) { return transaction::pthread_trylock(lock); }
-
-template <>
-inline int transaction::unlock<Mutex> (Mutex &lock) { return transaction::pthread_unlock(&lock); }
-
-template <>
-inline int transaction::unlock<Mutex*> (Mutex *lock) { return transaction::pthread_unlock(lock); }
-
-#endif

//---------------------------------------------------------------------------
// do not remove if (). It is necessary a necessary fix for compilers

Modified: sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -12,6 +12,7 @@
//////////////////////////////////////////////////////////////////////////////

#include <boost/stm/transaction.hpp>
+#include <boost/stm/latm.hpp>
#include <boost/stm/non_tx/detail/cache_map.hpp>
#include <boost/stm/contention_managers/contention_manager.hpp>
#include <iostream>
@@ -31,12 +32,33 @@
// Static initialization
///////////////////////////////////////////////////////////////////////////////
transaction::InflightTxes transaction::transactionsInFlight_;
-latm::mutex_set transaction::latmLockedLocks_;
-latm::mutex_thread_id_set_map transaction::latmLockedLocksAndThreadIdsMap_;
-latm::mutex_thread_id_map transaction::latmLockedLocksOfThreadMap_;
-latm::mutex_set transaction::tmConflictingLocks_;
+//latm::mutex_set transaction::latmLockedLocks_;
+//latm::mutex_thread_id_set_map transaction::latmLockedLocksAndThreadIdsMap_;
+//latm::mutex_thread_id_map transaction::latmLockedLocksOfThreadMap_;
+//latm::mutex_set transaction::tmConflictingLocks_;
transaction::DeletionBuffer transaction::deletionBuffer_;

+//////////////
+// LATM
+/////////////
+namespace latm {
+#if defined(BOOST_STM_LATM_STATIC_FULL_MODE)
+latm_mode mode::instance_;
+#elif defined(BOOST_STM_LATM_STATIC_TM_MODE)
+latm_mode mode::instance_;
+#elif defined(BOOST_STM_LATM_STATIC_TX_MODE)
+latm_mode mode::instance_;
+#elif defined(BOOST_STM_LATM_DYNAMIC_MODE)
+full_mode<abstract_mode> mode::full_;
+tm_mode<abstract_mode> mode::tm_;
+tx_mode<abstract_mode> mode::tx_;
+latm_mode* mode::instance_=&mode::full_;
+#else
+latm_mode mode::instance_;
+#endif
+}
+
+
clock_t transaction::global_clock_ = 0;
size_t transaction::stalls_ = 0;

@@ -45,12 +67,12 @@
bool transaction::directLateWriteReadConflict_ = false;
bool transaction::usingMoveSemantics_ = false;

-pthread_mutexattr_t transaction::transactionMutexAttribute_;
+//pthread_mutexattr_t transaction::transactionMutexAttribute_;

Mutex transaction::transactionsInFlightMutex_;
Mutex transaction::transactionMutex_;
Mutex transaction::deletionBufferMutex_;
-Mutex transaction::latmMutex_;
+//Mutex transaction::latmMutex_;

std::ofstream transaction::logFile_;

@@ -150,7 +172,7 @@
    pthread_mutex_init(&transactionMutex_, 0);
    pthread_mutex_init(&transactionsInFlightMutex_, 0);
    pthread_mutex_init(&deletionBufferMutex_, 0);
- pthread_mutex_init(&latmMutex_, 0);
+ pthread_mutex_init(&latm::instance().latmMutex_, 0);

    //pthread_mutex_init(&transactionMutex_, &transactionMutexAttribute_);
    //pthread_mutex_init(&transactionsInFlightMutex_, &transactionMutexAttribute_);

Modified: sandbox/stm/branches/vbe/libs/stm/test/Jamfile.v2
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/Jamfile.v2 (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/Jamfile.v2 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -53,72 +53,147 @@

     alias def_invalid
         :
+ [ run stm : -bench accounts -def -threads 2 -inserts 100 : : : test_accounts_def_t2_i100 ]
+ ########### fails sometimes
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
             [ run stm : -bench accounts -def -threads 4 -inserts 100 : : : test_accounts_def_t4_i100 ]

- [ run stm : -bench hashmap -def -threads 4 -inserts 100 : : : test_hashmap_def_t4_i100 ]
+ [ run stm : -bench hashmap -def -threads 2 -inserts 100 : : : test_hashmap_def_t2_i100 ]
+ ########### fails
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
+ #[ run stm : -bench hashmap -def -threads 4 -inserts 100 : : : test_hashmap_def_t4_i100 ]

             ########### fails
             # /bin/sh: line 4: 2944 Aborted (core dumped) "bin/test_ht_def_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_ht_def_t2_i1000.exe" > "bin/test_ht_def_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_ht_def_t2_i1000.output" 2>&1
             # Rounding max threads to the next multiple of 4 (4).
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench ht -def -threads 2 -inserts 100 : : : test_ht_def_t2_i100 ]
+ #[ run stm : -bench ht -def -threads 2 -inserts 100 -latm full : : : test_ht_def_full_t2_i100 ]
+ [ run stm : -bench ht -def -threads 2 -inserts 100 -latm tm : : : test_ht_def_tm_t2_i100 ]
+ [ run stm : -bench ht -def -threads 4 -inserts 100 -latm tm : : : test_ht_def_tm_t4_i100 ]
+ [ run stm : -bench ht -def -threads 2 -inserts 100 -latm tx : : : test_ht_def_tx_t2_i100 ]
+ [ run stm : -bench ht -def -threads 4 -inserts 100 -latm tx : : : test_ht_def_tx_t4_i100 ]

             [ run stm : -bench isolated_int -def -threads 4 -inserts 100 : : : test_isolated_int_def_t2_i100 ]

+ [ run stm : -bench linkedlist -def -threads 2 -inserts 100 : : : test_linkedlist_def_t2_i100 ]
+ ########### fails sometimes
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
             [ run stm : -bench linkedlist -def -threads 4 -inserts 100 : : : test_linkedlist_def_t4_i100 ]

             ########### fails
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench ll -def -threads 2 -inserts 100 : : : test_ll_def_t2_i100 ]
+ #[ run stm : -bench ll -def -threads 2 -inserts 100 -latm full : : : test_ll_def_full_t2_i100 ]
+ [ run stm : -bench ll -def -threads 2 -inserts 100 -latm tm : : : test_ll_def_tm_t2_i100 ]
+ [ run stm : -bench ll -def -threads 4 -inserts 100 -latm tm : : : test_ll_def_tm_t4_i100 ]
+ ########### fails
+ #[ run stm : -bench ll -def -threads 2 -inserts 100 -latm tx : : : test_ll_def_tx_t2_i100 ]

- ########### deadlock. killed after 0:26. 00% CPU
+ ########### fails all-modes
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
             # 19469 [sig] test_tx_linear_lock_def_t2 3768 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack)
- [ run stm : -bench tx_linear_lock -def -threads 2 -inserts 100 : : : test_tx_linear_lock_def_t2_i100 ]
+ #[ run stm : -bench tx_linear_lock -def -threads 2 -inserts 100 -latm full : : : test_tx_linear_lock_def_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench tx_linear_lock -def -threads 2 -inserts 100 -latm tm : : : test_tx_linear_lock_def_tm_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench tx_linear_lock -def -threads 2 -inserts 100 -latm tx : : : test_tx_linear_lock_def_tx_t2_i100 ]

- ########### deadlock. killed after 0:26. 00% CPU
- [ run stm : -bench isolated_int_lock_in_tx -def -threads 2 -inserts 100 : : : test_isolated_int_lock_in_tx_def_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 2 -inserts 100 -latm full : : : test_isolated_int_lock_in_tx_def_full_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 4 -inserts 100 -latm full : : : test_isolated_int_lock_in_tx_def_full_t4_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 2 -inserts 100 -latm tm : : : test_isolated_int_lock_in_tx_def_tm_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 4 -inserts 100 -latm tm : : : test_isolated_int_lock_in_tx_def_tm_t4_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 2 -inserts 100 -latm tx : : : test_isolated_int_lock_in_tx_def_tx_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -def -threads 4 -inserts 100 -latm tx : : : test_isolated_int_lock_in_tx_def_tx_t4_i100 ]

- ########### fails
+ ########### fails all-modes
             # /bin/sh: line 4: 3660 Segmentation fault (core dumped) "bin/test_isolated_composed_int_lock_def_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock_def_t2.exe" > "bin/test_isolated_composed_int_lock_def_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock_def_t2.output" 2>&1
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench isolated_composed_int_lock -def -threads 2 -inserts 100 : : : test_isolated_composed_int_lock_def_t2_i100 ]
+ #[ run stm : -bench isolated_composed_int_lock -def -threads 2 -inserts 100 -latm full : : : test_isolated_composed_int_lock_def_full_t2_i100 ]
+ ########### fails
+ # /bin/sh: line 4: 4744 Aborted (core dumped) "bin/gcc-3.4.4/debug/threading-multi/stm.exe" -bench isolated_composed_int_lock -def -threads 2 -inserts 100 -latm tm > "bin/test_isolated_composed_int_lock_def_tm_t2_i100.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock_def_tm_t2_i100.output" 2>&1
+ #[ run stm : -bench isolated_composed_int_lock -def -threads 2 -inserts 100 -latm tm : : : test_isolated_composed_int_lock_def_tm_t2_i100 ]
+ ########### fails
+ # /bin/sh: line 4: 4772 Aborted (core dumped) "bin/gcc-3.4.4/debug/threading-multi/stm.exe" -bench isolated_composed_int_lock -def -threads 2 -inserts 100 -latm tx > "bin/test_isolated_composed_int_lock_def_tx_t2_i100.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock_def_tx_t2_i100.output" 2>&1
+ #[ run stm : -bench isolated_composed_int_lock -def -threads 2 -inserts 100 -latm tx : : : test_isolated_composed_int_lock_def_tx_t2_i100 ]

             ########### fails
- # /bin/sh: line 4: 3172 Aborted (core dumped) "bin/test_isolated_composed_int_lock2_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_dir_t2.exe" > "bin/test_isolated_composed_int_lock2_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_dir_t2.output" 2>&1
- # ====== BEGIN OUTPUT ======
- # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 : : : test_isolated_composed_int_lock2_def_t2_i100 ]
+ #/bin/sh: line 4: 4536 Aborted (core dumped) "bin/gcc-3.4.4/debug/threading-multi/stm.exe" -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 -latm full > "bin/test_isolated_composed_int_lock2_def_full_t2_i100.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_def_full_t2_i100.output" 2>&1
+ #====== BEGIN OUTPUT ======
+ #61 i= 0
+ #66 i=0 end= 50 count= 1
+ #70 lock
+ #73 1
+ #74 unlock
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
+ #[ run stm : -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 -latm full : : : test_isolated_composed_int_lock2_def_full_t2_i100 ]
+ ########### fails
+ #/bin/sh: line 4: 4556 Aborted (core dumped) "bin/gcc-3.4.4/debug/threading-multi/stm.exe" -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 -latm tm > "bin/test_isolated_composed_int_lock2_def_tm_t2_i100.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_def_tm_t2_i100.output" 2>&1
+ #====== BEGIN OUTPUT ======
+ #61 i= 0
+ #66 i=0 end= 50 count= 1
+ #70 lock
+ #[ run stm : -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 -latm tm : : : test_isolated_composed_int_lock2_def_tm_t2_i100 ]
+ [ run stm : -bench isolated_composed_int_lock2 -def -threads 2 -inserts 100 -latm tx : : : test_isolated_composed_int_lock2_def_tx_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench isolated_composed_int_lock2 -def -threads 4 -inserts 100 -latm tx : : : test_isolated_composed_int_lock2_def_tx_t4_i100 ]

+ [ run stm : -bench irrevocable_int -def -threads 2 -inserts 100 : : : test_irrevocable_int_def_t2_i100 ]
+ ########### fails sometimes
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
             [ run stm : -bench irrevocable_int -def -threads 4 -inserts 100 : : : test_irrevocable_int_def_t4_i100 ]

- ########### deadlock. killed after 0:26. 00% CPU
- #[ run stm : -bench lot_example -def -threads 2 -inserts 100 : : : test_lot_example_def_t2_i100 ]
+ ########### deadlock. killed after 0:26. 00% CPU all-modes
+ #[ run stm : -bench lot_example -def -threads 2 -inserts 100 -latm full : : : test_lot_example_def_full_t2_i100 ]
+ ########### deadlock.
+ #[ run stm : -bench lot_example -def -threads 2 -inserts 100 -latm tm : : : test_lot_example_def_tm_t2_i100 ]
+ ########### deadlock.
+ #[ run stm : -bench lot_example -def -threads 2 -inserts 100 -latm tx : : : test_lot_example_def_tx_t2_i100 ]

- ########### fails with CHECK
+ ########### fails with CHECK all-modes
             # /bin/sh: line 4: 4072 Aborted (core dumped) "bin/test_lit_def_t2.test/gcc-3.4.4/debug/threading-multi/test_lit_def_t2.exe" > "bin/test_lit_def_t2.test/gcc-3.4.4/debug/threading-multi/test_lit_def_t2.output" 2>&1
             ########### deadlock sometimes without CHECK. killed after 0:40. 00% CPU
- #[ run stm : -bench lit_example -def -threads 2 -inserts 100 : : : test_lit_example_def_t2_i100 ]
+ #[ run stm : -bench lit_example -def -threads 2 -inserts 100 -latm full : : : test_lit_example_def_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench lit_example -def -threads 2 -inserts 100 -latm tm : : : test_lit_example_def_tm_t2_i100 ]
+ ########### deadlock
+ #[ run stm : -bench lit_example -def -threads 2 -inserts 100 -latm tx : : : test_lit_example_def_tx_t2_i100 ]
+

             ########### livelock. killed after 3:50. 50% CPU
- #[ run stm : -bench nested_tx -def -threads 2 -inserts 100 : : : test_nested_tx_def_t2_i100 ]
+ #[ run stm : -bench nested_tx -def -threads 2 -inserts 100 -latm full : : : test_nested_tx_def_full_t2_i100 ]
+ ##[ run stm : -bench nested_tx -def -threads 2 -inserts 100 -latm tm : : : test_nested_tx_def_tm_t2_i100 ]
+ ##[ run stm : -bench nested_tx -def -threads 2 -inserts 100 -latm tx : : : test_nested_tx_def_tx_t2_i100 ]

             [ run stm : -bench rbtree -def -threads 4 -inserts 100 : : : test_rbtree_def_t4_i100 ]

             [ run stm : -bench smart -def -threads 4 -inserts 100 : : : test_smart_def_t4_i100 ]

- ########### fails
+ ########### fails all-modes
             # /bin/sh: line 4: 2376 Aborted (core dumped) "bin/test_using_linkedlist_def_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_using_linkedlist_def_t2_i1000.exe" > "bin/test_using_linkedlist_def_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_using_linkedlist_def_t2_i1000.output" 2>&1
- [ run stm : -bench using_linkedlist -def -threads 2 -inserts 100 : : : test_using_linkedlist_def_t2_i100 ]
+ #[ run stm : -bench using_linkedlist -def -threads 2 -inserts 100 -latm full : : : test_using_linkedlist_def_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench using_linkedlist -def -threads 2 -inserts 100 -latm tm : : : test_using_linkedlist_def_tm_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench using_linkedlist -def -threads 2 -inserts 100 -latm tx : : : test_using_linkedlist_def_tx_t2_i100 ]

+ ########### fails all-modes
+ # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
+ #[ run stm : -bench hashmap_w_locks -def -threads 2 -inserts 100 -latm full : : : test_hashmap_w_locks_def_full_t2_i100 ]
             ########### fails
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench hashmap_w_locks -def -threads 2 -inserts 100 : : : test_hashmap_w_locks_def_t2_i100 ]
+ #[ run stm : -bench hashmap_w_locks -def -threads 2 -inserts 100 -latm tm : : : test_hashmap_w_locks_def_tm_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench hashmap_w_locks -def -threads 2 -inserts 100 -latm tx : : : test_hashmap_w_locks_def_tx_t2_i100 ]

             ########### fails
             # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
- [ run stm : -bench list_hash_w_locks -def -threads 2 -inserts 100 : : : test_list_hash_w_locks_def_t2_i100 ]
+ #[ run stm : -bench list_hash_w_locks -def -threads 2 -inserts 100 -latm full : : : test_list_hash_w_locks_def_full_t2_i100 ]
+ [ run stm : -bench list_hash_w_locks -def -threads 2 -inserts 100 -latm tm : : : test_list_hash_w_locks_def_tm_t2_i100 ]
+ ########### fails
+ #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
+ #[ run stm : -bench list_hash_w_locks -def -threads 4 -inserts 100 -latm tm : : : test_list_hash_w_locks_def_tm_t4_i100 ]
+ [ run stm : -bench list_hash_w_locks -def -threads 2 -inserts 100 -latm tx : : : test_list_hash_w_locks_def_tx_t2_i100 ]
+ [ run stm : -bench list_hash_w_locks -def -threads 4 -inserts 100 -latm tx : : : test_list_hash_w_locks_def_tx_t4_i100 ]
     ;

     alias dir_invalid
@@ -127,54 +202,103 @@

             [ run stm : -bench hashmap -dir -threads 4 -inserts 100 : : : test_hashmap_dir_t4_i100 ]

- ########### livelock. killed after 3:00 25% CPU
- [ run stm : -bench ht -dir -threads 2 -inserts 100 : : : test_ht_dir_t2_i100 ]
+ [ run stm : -bench ht -dir -threads 2 -inserts 100 -latm full : : : test_ht_dir_full_t2_i100 ]
+ [ run stm : -bench ht -dir -threads 4 -inserts 100 -latm full : : : test_ht_dir_full_t4_i100 ]
+ [ run stm : -bench ht -dir -threads 2 -inserts 100 -latm tm : : : test_ht_dir_tm_t2_i100 ]
+ [ run stm : -bench ht -dir -threads 4 -inserts 100 -latm tm : : : test_ht_dir_tm_t4_i100 ]
+ [ run stm : -bench ht -dir -threads 2 -inserts 100 -latm tx : : : test_ht_dir_tx_t2_i100 ]
+ [ run stm : -bench ht -dir -threads 4 -inserts 100 -latm tx : : : test_ht_dir_tx_t4_i100 ]

             [ run stm : -bench isolated_int -dir -threads 4 -inserts 100 : : : test_isolated_int_dir_t2_i100 ]

             [ run stm : -bench linkedlist -dir -threads 4 -inserts 100 : : : test_linkedlist_dir_t4_i100 ]

- [ run stm : -bench ll -dir -threads 2 -inserts 100 : : : test_ll_dir_t2_i100 ]
+ [ run stm : -bench ll -dir -threads 2 -inserts 100 -latm full : : : test_ll_dir_t2_full_i100 ]
+ [ run stm : -bench ll -dir -threads 4 -inserts 100 -latm full : : : test_ll_dir_t4_full_i100 ]
+ [ run stm : -bench ll -dir -threads 2 -inserts 100 -latm tm : : : test_ll_dir_t2_tm_i100 ]
+ [ run stm : -bench ll -dir -threads 4 -inserts 100 -latm tm : : : test_ll_dir_t4_tm_i100 ]
+ ########### fails
+ #[ run stm : -bench ll -dir -threads 2 -inserts 100 -latm tx : : : test_ll_dir_t2_tx_i100 ]
+ ########### fails sometimes
+ [ run stm : -bench ll -dir -threads 4 -inserts 100 -latm tx : : : test_ll_dir_t4_tx_i100 ]

- ########### fails with CHECK
+ ########### fails with CHECK all-modes
             #/bin/sh: line 4: 3764 Aborted (core dumped) "bin/test_tx_linear_lock_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_tx_linear_lock_dir_t2.exe" > "bin/test_tx_linear_lock_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_tx_linear_lock_dir_t2.output" 2>&1
             #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
             ########### deadlock. without CHECK
- #[ run stm : -bench tx_linear_lock -dir -threads 2 -inserts 100 : : : test_tx_linear_lock_dir_t2_i100 ]
-
- [ run stm : -bench isolated_int_lock_in_tx -dir -threads 2 -inserts 100 : : : test_isolated_int_lock_in_tx_dir_t2_i100 ]
-
- ########### deadlock. killed after 0:20. 00% CPU
- #[ run stm : -bench isolated_composed_int_lock -dir -threads 2 -inserts 100 : : : test_isolated_composed_int_lock_dir_t2_i100 ]
+ [ run stm : -bench tx_linear_lock -dir -threads 2 -inserts 100 -latm full : : : test_tx_linear_lock_dir_full_t2_i100 ]
+ ###########
+ #[ run stm : -bench tx_linear_lock -dir -threads 4 -inserts 100 -latm full : : : test_tx_linear_lock_dir_full_t4_i100 ]
+ ########### fails
+ #[ run stm : -bench tx_linear_lock -dir -threads 2 -inserts 100 -latm tm : : : test_tx_linear_lock_dir_tm_t2_i100 ]
+ ########### deadlock
+ #[ run stm : -bench tx_linear_lock -dir -threads 2 -inserts 100 -latm tx : : : test_tx_linear_lock_dir_tx_t2_i100 ]
+
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 2 -inserts 100 -latm full : : : test_isolated_int_lock_in_tx_dir_full_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 4 -inserts 100 -latm full : : : test_isolated_int_lock_in_tx_dir_full_t4_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 2 -inserts 100 -latm tm : : : test_isolated_int_lock_in_tx_dir_tm_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 4 -inserts 100 -latm tm : : : test_isolated_int_lock_in_tx_dir_tm_t4_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 2 -inserts 100 -latm tx : : : test_isolated_int_lock_in_tx_dir_tx_t2_i100 ]
+ [ run stm : -bench isolated_int_lock_in_tx -dir -threads 4 -inserts 100 -latm tx : : : test_isolated_int_lock_in_tx_dir_tx_t4_i100 ]
+
+ ########### deadlock. killed after 0:20. 00% CPU all-modes all-modes
+ #[ run stm : -bench isolated_composed_int_lock -dir -threads 2 -inserts 100 -latm full : : : test_isolated_composed_int_lock_dir_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench isolated_composed_int_lock -dir -threads 2 -inserts 100 -latm tm : : : test_isolated_composed_int_lock_dir_tm_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench isolated_composed_int_lock -dir -threads 2 -inserts 100 -latm tx : : : test_isolated_composed_int_lock_dir_tx_t2_i100 ]

             ########### fails
             # /bin/sh: line 4: 3172 Aborted (core dumped) "bin/test_isolated_composed_int_lock2_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_dir_t2.exe" > "bin/test_isolated_composed_int_lock2_dir_t2.test/gcc-3.4.4/debug/threading-multi/test_isolated_composed_int_lock2_dir_t2.output" 2>&1
             #assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 40
             # 11 [sig] test_isolated_composed_int_lock_def_t2 3660 _cygtls::handle_except ions: Error while dumping state (probably corrupted stack)
- [ run stm : -bench isolated_composed_int_lock2 -dir -threads 2 -inserts 100 : : : test_isolated_composed_int_lock2_dir_t2_i100 ]
+ #[ run stm : -bench isolated_composed_int_lock2 -dir -threads 2 -inserts 100 -latm full : : : test_isolated_composed_int_lock2_dir_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench isolated_composed_int_lock2 -dir -threads 2 -inserts 100 -latm tm : : : test_isolated_composed_int_lock2_dir_tm_t2_i100 ]
+ [ run stm : -bench isolated_composed_int_lock2 -dir -threads 2 -inserts 100 -latm tx : : : test_isolated_composed_int_lock2_dir_tx_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench isolated_composed_int_lock2 -dir -threads 4 -inserts 100 -latm tx : : : test_isolated_composed_int_lock2_dir_tx_t4_i100 ]

             [ run stm : -bench irrevocable_int -dir -threads 4 -inserts 100 : : : test_irrevocable_int_dir_t4_i100 ]

- ########### deadlock. killed after 0:20. 00% CPU
- #[ run stm : -bench lot_example -dir -threads 2 -inserts 100 : : : test_lot_example_dir_t2_i100 ]
-
- ########### deadlock. killed after 0:40. 00% CPU
- #[ run stm : -bench lit_example -dir -threads 2 -inserts 100 : : : test_lit_example_dir_t2_i100 ]
+ ########### deadlock. killed after 0:20. 00% CPU all-modes
+ #[ run stm : -bench lot_example -dir -threads 2 -inserts 100 -latm full : : : test_lot_example_dir_full_t2_i100 ]
+ ########### deadlock
+ #[ run stm : -bench lot_example -dir -threads 2 -inserts 100 -latm tm : : : test_lot_example_dir_tm_t2_i100 ]
+ ########### deadlock
+ #[ run stm : -bench lot_example -dir -threads 2 -inserts 100 -latm tx : : : test_lot_example_dir_tx_t2_i100 ]
+
+ ########### deadlock. killed after 0:40. 00% CPU all-modes
+ #[ run stm : -bench lit_example -dir -threads 2 -inserts 100 -latm full : : : test_lit_example_dir_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench lit_example -dir -threads 2 -inserts 100 -latm tm : : : test_lit_example_dir_tm_t2_i100 ]
+ ########### deadlock
+ #[ run stm : -bench lit_example -dir -threads 2 -inserts 100 -latm tx : : : test_lit_example_dir_tx_t2_i100 ]

             ########### livelock. killed after 3:00. 50% CPU
- #[ run stm : -bench nested_tx -dir -threads 2 -inserts 100 : : : test_nested_tx_dir_t2_i100 ]
+ #[ run stm : -bench nested_tx -dir -threads 2 -inserts 100 -latm full : : : test_nested_tx_dir_full_t2_i100 ]
+ ##[ run stm : -bench nested_tx -dir -threads 2 -inserts 100 -latm tm : : : test_nested_tx_dir_tm_t2_i100 ]
+ ##[ run stm : -bench nested_tx -dir -threads 2 -inserts 100 -latm tx : : : test_nested_tx_dir_tx_t2_i100 ]

             [ run stm : -bench rbtree -dir -threads 4 -inserts 100 : : : test_rbtree_dir_t4_i100 ]

             [ run stm : -bench smart -dir -threads 4 -inserts 100 : : : test_smart_dir_t4_i100 ]

- ########### fails
+ ########### fails all-modes
             #/bin/sh: line 4: 408 Aborted (core dumped) "bin/test_using_linkedlist_dir_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_using_linkedlist_dir_t2_i1000.exe" > "bin/test_using_linkedlist_dir_t2_i1000.test/gcc-3.4.4/debug/threading-multi/test_using_linkedlist_dir_t2_i1000.output" 2>&1
- [ run stm : -bench using_linkedlist -dir -threads 2 -inserts 100 : : : test_using_linkedlist_dir_t2_i100 ]
-
- [ run stm : -bench hashmap_w_locks -dir -threads 4 -inserts 100 : : : test_hashmap_w_locks_dir_t4_i100 ]
+ #[ run stm : -bench using_linkedlist -dir -threads 2 -inserts 100 -latm full : : : test_using_linkedlist_dir_full_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench using_linkedlist -dir -threads 2 -inserts 100 -latm tm : : : test_using_linkedlist_dir_tm_t2_i100 ]
+ ########### fails
+ #[ run stm : -bench using_linkedlist -dir -threads 2 -inserts 100 -latm tx : : : test_using_linkedlist_dir_tx_t2_i100 ]

- [ run stm : -bench list_hash_w_locks -dir -threads 4 -inserts 100 : : : test_list_hash_w_locks_dir_t4_i100 ]
+ [ run stm : -bench hashmap_w_locks -dir -threads 4 -inserts 100 -latm full : : : test_hashmap_w_locks_dir_full_t4_i100 ]
+ [ run stm : -bench hashmap_w_locks -dir -threads 4 -inserts 100 -latm tm : : : test_hashmap_w_locks_dir_tm_t4_i100 ]
+ [ run stm : -bench hashmap_w_locks -dir -threads 4 -inserts 100 -latm tx : : : test_hashmap_w_locks_dir_tx_t4_i100 ]
+
+ [ run stm : -bench list_hash_w_locks -dir -threads 4 -inserts 100 -latm full : : : test_list_hash_w_locks_dir_full_t4_i100 ]
+ [ run stm : -bench list_hash_w_locks -dir -threads 4 -inserts 100 -latm tm : : : test_list_hash_w_locks_dir_tm_t4_i100 ]
+ [ run stm : -bench list_hash_w_locks -dir -threads 4 -inserts 100 -latm tx : : : test_list_hash_w_locks_dir_tx_t4_i100 ]
     ;

     alias examples
@@ -186,6 +310,8 @@
             [ link ../example/list.cpp ]

             [ run ../example/counter.cpp ]
+ # fails sometimes
+ # assertion "res==0" failed: file "../../../boost/synchro/pthread/mutex.hpp", line 52
             [ run ../example/numeric.cpp ]
             [ run ../example/tx/pointer.cpp ]
             [ run ../example/counter_ptr.cpp ]

Modified: sandbox/stm/branches/vbe/libs/stm/test/isolatedComposedIntLockInTx2.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/isolatedComposedIntLockInTx2.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/isolatedComposedIntLockInTx2.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -58,23 +58,31 @@

    for (int i = startingValue; i < endingValue/2; ++i)
    {
+ std::cout<< __LINE__ << " i= " << i << std::endl;
+ int count=0;
       for (transaction t; ; t.restart())
       {
- t.add_tx_conflicting_lock(&lock1);
+ count++;
+ std::cout<< __LINE__ << " i="<<i << " end= " << endingValue/2 << " count= " << count << std::endl;
+ t.lock_conflict(&lock1);
          try
          {
+ std::cout<< __LINE__ << " lock" << std::endl;
             transaction::lock_(lock1);
             ++gInt.value();
- cout << "\t" << gInt.value() << endl;
+ cout << __LINE__ << "\t" << gInt.value() << endl;
+ std::cout<< __LINE__ << " unlock" << std::endl;
             transaction::unlock_(lock1);

             SLEEP(50);
             // do nothing on purpose, allowing other threads time to see
             // intermediate state IF they can get lock1 (they shouldn't)

+ std::cout<< __LINE__ << " lock" << std::endl;
             transaction::lock_(lock1);
             --gInt.value();
- cout << "\t" << gInt.value() << endl;
+ cout << __LINE__ << "\t" << gInt.value() << endl;
+ std::cout<< __LINE__ << " unlock" << std::endl;
             transaction::unlock_(lock1);

             t.end();
@@ -82,9 +90,12 @@

             break;
          }
- catch (aborted_tx&) {}
+ catch (aborted_tx&) {
+ std::cout<< __LINE__ << " aborted_tx " << i << std::endl;
+ }
       }
    }
+ std::cout<< __LINE__ << std::endl;

    //--------------------------------------------------------------------------
    // last thread out sets the endTimer
@@ -92,59 +103,23 @@
    endTimer = time(0);
    finishThread(start);

+ std::cout<< __LINE__ << std::endl;
    if (*(int*)threadId != kMainThreadId)
    {
       transaction::terminate_thread();
- pthread_exit(threadId);
+ std::cout<< __LINE__ << std::endl;
+ //pthread_exit(threadId);
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
-#if 0
-static void* Test2(void *threadId)
-{
- transaction::initialize_thread();
- int start = *(int*)threadId;
-
- int startingValue = start * 100000;
- int endingValue = startingValue + kMaxInserts;
-
- for (int i = startingValue; i < 100*endingValue; ++i)
- {
- try
- {
- transaction t;
- t.add_tx_conflicting_lock(&lock1);
- int val = t.r(gInt).value();
- //transaction::lock(lock2);
- cout << val << endl;
- //transaction::unlock(lock2);
- t.end();
- SLEEP(10); // do nothing on purpose
- } catch (aborted_tx&) {}
- }
-
- //--------------------------------------------------------------------------
- // last thread out sets the endTimer
- //--------------------------------------------------------------------------
- endTimer = time(0);
- finishThread(start);
-
- if (*(int*)threadId != kMainThreadId)
- {
- transaction::terminate_thread();
- pthread_exit(threadId);
- }
-
- return 0;
-}
-#endif
-///////////////////////////////////////////////////////////////////////////////
static void* Test3(void *threadId)
{
+ if (*(int*)threadId != kMainThreadId) {
    transaction::initialize_thread();
+ }
    int start = *(int*)threadId;

    int startingValue = 0;
@@ -170,12 +145,12 @@
    // last thread out sets the endTimer
    //--------------------------------------------------------------------------
    endTimer = time(0);
- finishThread(start);

    if (*(int*)threadId != kMainThreadId)
    {
+ finishThread(start);
       transaction::terminate_thread();
- pthread_exit(threadId);
+ //pthread_exit(threadId);
    }

    return 0;
@@ -185,6 +160,7 @@
void TestIsolatedComposedIntLockInTx2()
{
    transaction::initialize();
+ transaction::initialize_thread();

    pthread_t *threads = new pthread_t[kMaxThreads];
    int *threadId = new int[kMaxThreads];
@@ -206,8 +182,10 @@

    int mainThreadId = kMaxThreads-1;

- Test3((void*)&mainThreadId);
+ //Test3((void*)&mainThreadId);

+ finishThread(mainThreadId);
+ transaction::terminate_thread();
    while (true)
    {
       if (threadsFinished.value() == kMaxThreads) break;
@@ -217,3 +195,43 @@
    cout << "gInt : " << gInt.value() << endl;
}

+///////////////////////////////////////////////////////////////////////////////
+#if 0
+static void* Test2(void *threadId)
+{
+ transaction::initialize_thread();
+ int start = *(int*)threadId;
+
+ int startingValue = start * 100000;
+ int endingValue = startingValue + kMaxInserts;
+
+ for (int i = startingValue; i < 100*endingValue; ++i)
+ {
+ try
+ {
+ transaction t;
+ t.lock_conflict(&lock1);
+ int val = t.r(gInt).value();
+ //transaction::lock(lock2);
+ cout << val << endl;
+ //transaction::unlock(lock2);
+ t.end();
+ SLEEP(10); // do nothing on purpose
+ } catch (aborted_tx&) {}
+ }
+
+ //--------------------------------------------------------------------------
+ // last thread out sets the endTimer
+ //--------------------------------------------------------------------------
+ endTimer = time(0);
+
+ if (*(int*)threadId != kMainThreadId)
+ {
+ finishThread(start);
+ transaction::terminate_thread();
+ pthread_exit(threadId);
+ }
+
+ return 0;
+}
+#endif

Modified: sandbox/stm/branches/vbe/libs/stm/test/litExample.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/litExample.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/litExample.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -194,7 +194,7 @@
    {
       for (transaction t;;t.restart())
         try {
- t.add_tx_conflicting_lock(L2);
+ t.lock_conflict(L2);
           inc2();
           t.end(); break;
         } catch (aborted_tx&) {}
@@ -229,7 +229,7 @@
       for (transaction t;;t.restart())
         try {

- t.add_tx_conflicting_lock(L3);
+ t.lock_conflict(L3);
           inc3();
           t.end(); break;
         } catch (aborted_tx&) {}
@@ -334,8 +334,8 @@
    arr8 = new native_trans<int>[kMaxArrSize];

    transaction::initialize();
- transaction::tm_lock_conflict(L2);
- transaction::tm_lock_conflict(L3);
+ //transaction::tm_lock_conflict(L2);
+ //transaction::tm_lock_conflict(L3);

    if (kTxIntenseWork == gWorkLoadType) txFactor = 5;
    if (kLockIntenseWork == gWorkLoadType) lockFactor = 10;

Modified: sandbox/stm/branches/vbe/libs/stm/test/lotExample.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/lotExample.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/lotExample.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -223,8 +223,8 @@
       for (transaction t;;t.restart())
         try {

- t.add_tx_conflicting_lock(L1);
- t.add_tx_conflicting_lock(L2);
+ t.lock_conflict(L1);
+ t.lock_conflict(L2);

           for (int i = 0; i < kMaxArrSize; ++i)
           {

Modified: sandbox/stm/branches/vbe/libs/stm/test/nestedTxs.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/nestedTxs.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/nestedTxs.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -246,9 +246,9 @@
    //latm::do_tm_lock_protection();
    latm::do_tx_lock_protection();

- //transaction::tm_lock_conflict(&L);
- //transaction::tm_lock_conflict(&L2);
- //transaction::tm_lock_conflict(&L3);
+ transaction::tm_lock_conflict(&L);
+ transaction::tm_lock_conflict(&L2);
+ transaction::tm_lock_conflict(&L3);

    nested2();
    nested1();

Modified: sandbox/stm/branches/vbe/libs/stm/test/testHT_latm.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/testHT_latm.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/testHT_latm.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -272,7 +272,7 @@
       //----------------------------------------------------------------
       if (latm::instance().doing_tm_lock_protection() && 0 == (k+1) % 2)
       {
- //transaction::add_tm_conflicting_lock(llist[index]->get_list_lock());
+ //transaction::tm_lock_conflict(llist[index]->get_list_lock());
          //cout << "TM-lock conflict added: " << index << endl;
       }
    }

Modified: sandbox/stm/branches/vbe/libs/stm/test/testHashMapAndLinkedListsWithLocks.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/testHashMapAndLinkedListsWithLocks.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/testHashMapAndLinkedListsWithLocks.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -427,13 +427,10 @@
    globalLinkedList = new LATM::LinkedList<int>;
    transaction::initialize();

- if (latm::instance().doing_tm_lock_protection())
- {
       for (int k = 1; k < kBuckets2; ++k)
       {
          transaction::tm_lock_conflict(globalHashMap->get_hash_lock(k));
       }
- }

    threadsFinished.value() = 0;
    threadsStarted.value() = 0;

Modified: sandbox/stm/branches/vbe/libs/stm/test/testHashMapWithLocks.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/testHashMapWithLocks.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/testHashMapWithLocks.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -213,7 +213,7 @@

    for (int k = 1; k < kBuckets; ++k)
    {
- transaction::add_tm_conflicting_lock(globalHashMap->get_hash_lock(k));
+ transaction::tm_lock_conflict(globalHashMap->get_hash_lock(k));
    }
#endif

Modified: sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -272,7 +272,7 @@
       //----------------------------------------------------------------
       if (latm::instance().doing_tm_lock_protection() && 0 == (k+1) % 2)
       {
- //transaction::add_tm_conflicting_lock(llist[index]->get_list_lock());
+ //transaction::tm_lock_conflict(llist[index]->get_list_lock());
          //cout << "TM-lock conflict added: " << index << endl;
       }
    }

Modified: sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.h
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.h (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/testLL_latm.h 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -139,14 +139,7 @@

       transaction t;

- if (latm::instance().doing_tx_lock_protection())
- {
          t.lock_conflict(&list_lock_);
- }
- else if (latm::instance().doing_tm_lock_protection())
- {
- transaction::tm_lock_conflict(&list_lock_);
- }

       for (; ;t.restart())
       {

Modified: sandbox/stm/branches/vbe/libs/stm/test/txLinearLock.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/txLinearLock.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/txLinearLock.cpp 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -42,8 +42,8 @@
    {
       for (transaction t; ; t.restart())
       {
- t.add_tx_conflicting_lock(&lock1);
- t.add_tx_conflicting_lock(&lock2);
+ t.lock_conflict(&lock1);
+ t.lock_conflict(&lock2);

          try
          {

Modified: sandbox/stm/branches/vbe/libs/stm/test/usingLockTx.h
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/test/usingLockTx.h (original)
+++ sandbox/stm/branches/vbe/libs/stm/test/usingLockTx.h 2009-10-29 05:27:24 EDT (Thu, 29 Oct 2009)
@@ -144,7 +144,7 @@
       {
          if (eTxConflictingLockLatmProtection == latm::instance().protection())
          {
- t.add_tx_conflicting_lock(&list_lock_);
+ t.lock_conflict(&list_lock_);
          }

          return internal_insert(node, t);
@@ -167,7 +167,7 @@
       {
          if (eTxConflictingLockLatmProtection == latm::instance().protection())
          {
- t.add_tx_conflicting_lock(&list_lock_);
+ t.lock_conflict(&list_lock_);
          }

          return internal_lookup(val, t);

Date view	Thread view	Subject view	Author view

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