Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r57144 - in sandbox/stm/branches/vbe: boost/stm boost/stm/contention_managers boost/stm/detail boost/stm/memory_managers boost/stm/non_tx boost/stm/non_tx/detail boost/stm/tx boost/stm/txw libs/stm/src libs/stm/test
From: vicente.botet_at_[hidden]
Date: 2009-10-25 03:57:23

Next message: oliver.kowalke_at_[hidden]: "[Boost-commit] svn:boost r57145 - sandbox/task/boost/task/detail"
Previous message: oliver.kowalke_at_[hidden]: "[Boost-commit] svn:boost r57143 - in sandbox/task: boost/task boost/task/detail libs/task/test"

Author: viboes
Date: 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
New Revision: 57144
URL: http://svn.boost.org/trac/boost/changeset/57144

Log:
TBoost.STM vbe:
* Move stm/contention_manager.hpp to stm/contention_managers/contention_manager.hpp
* Move stm/base_contention_manager.hpp to stm/contention_managers/base_contention_manager.hpp
* Rename stm/memory_managers/memory_manage.hpp to stm/memory_managers/memory_manager.hpp
* Remove the specific memory manager logic on base_transaction_object and use instead the base_memory_manager
* Use memory_manager mixin in transaction_object, transactional_object, shallow_transaction_object and non_tx::detail::cache
* Prepare the use of other LATM Mutex than pthread_mutex*, replacing the uses of Mutex by latm_mutex,and some container renaming.

Added:
   sandbox/stm/branches/vbe/boost/stm/contention_managers/contention_manager.hpp (contents, props changed)
   sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manager.hpp
      - copied, changed from r57055, /sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp
Removed:
   sandbox/stm/branches/vbe/boost/stm/contention_manager.hpp
   sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp
   sandbox/stm/branches/vbe/boost/stm/non_tx/integers.hpp
Text files modified:
   sandbox/stm/branches/vbe/boost/stm/base_transaction_object.hpp | 29 -----
   sandbox/stm/branches/vbe/boost/stm/detail/config.hpp | 4
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_full_impl.hpp | 8
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tm_impl.hpp | 8
   sandbox/stm/branches/vbe/boost/stm/detail/latm_def_tx_impl.hpp | 10 +-
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_full_impl.hpp | 8
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tm_impl.hpp | 8
   sandbox/stm/branches/vbe/boost/stm/detail/latm_dir_tx_impl.hpp | 10 +-
   sandbox/stm/branches/vbe/boost/stm/detail/latm_general_impl.hpp | 40 ++++----
   sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp | 6
   sandbox/stm/branches/vbe/boost/stm/memory_managers/base_memory_manager.hpp | 4
   sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manager.hpp | 12 +-
   sandbox/stm/branches/vbe/boost/stm/non_tx/detail/cache_map.hpp | 32 ++++--
   sandbox/stm/branches/vbe/boost/stm/transaction.hpp | 197 ++++++++++++++++++++-------------------
   sandbox/stm/branches/vbe/boost/stm/transaction_object.hpp | 26 +++--
   sandbox/stm/branches/vbe/boost/stm/tx/deep_transaction_object.hpp | 2
   sandbox/stm/branches/vbe/boost/stm/tx/shallow_transaction_object.hpp | 37 ++-----
   sandbox/stm/branches/vbe/boost/stm/txw/transactional_object.hpp | 35 ++++--
   sandbox/stm/branches/vbe/libs/stm/src/contention_manager.cpp | 2
   sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp | 59 +++++------
   sandbox/stm/branches/vbe/libs/stm/test/Jamfile.v2 | 4
   21 files changed, 268 insertions(+), 273 deletions(-)

Modified: sandbox/stm/branches/vbe/boost/stm/base_transaction_object.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/base_transaction_object.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/base_transaction_object.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -24,6 +24,7 @@
#include <boost/stm/detail/config.hpp>
//-----------------------------------------------------------------------------
#include <boost/stm/datatypes.hpp>
+
//-----------------------------------------------------------------------------
#include <boost/stm/detail/memory_pool.hpp>
//-----------------------------------------------------------------------------
@@ -106,29 +107,7 @@
 std::list<base_transaction_object*>& embeddeds() {return embeddeds_;}
 void bind(base_transaction_object* bto) {embeddeds_.push_back(bto);}
#endif
-
-#if USE_STM_MEMORY_MANAGER
- static void alloc_size(std::size_t size) { memory_.alloc_size(size); }
-#else
- static void alloc_size(std::size_t size) { }
-#endif
-//protected:
-
-#if USE_STM_MEMORY_MANAGER
- static void return_mem(void *mem, std::size_t size)
- {
- synchro::lock_guard<Mutex> lock(transactionObjectMutex_);
- memory_.returnChunk(mem, size);
- }
-
- static void* retrieve_mem(std::size_t size)
- {
- synchro::lock_guard<Mutex> lock(transactionObjectMutex_);
- void *mem = memory_.retrieveChunk(size);
- return mem;
- }
-#endif
-
+
private:

 //--------------------------------------------------------------------------
@@ -147,10 +126,6 @@
 //--------------------------------------------------------------------------
 mutable thread_id_t transactionThread_;
 mutable new_memory_t newMemory_;
-#if USE_STM_MEMORY_MANAGER
- static Mutex transactionObjectMutex_;
- static MemoryPool<base_transaction_object> memory_;
-#endif
#if BOOST_STM_ALLOWS_EMBEDEEDS
 std::list<base_transaction_object*> embeddeds_;
#endif

Deleted: sandbox/stm/branches/vbe/boost/stm/contention_manager.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/contention_manager.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
+++ (empty file)
@@ -1,255 +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_CONTENTION_MANAGER_H
-#define BOOST_STM_CONTENTION_MANAGER_H
-
-#include <boost/stm/transaction.hpp>
-
-namespace boost { namespace stm {
-
-
- //-----------------------------------------------------------------------------
-class DefaultContentionManager : public base_contention_manager
-{
-public:
- //--------------------------------------------------------------------------
- void abort_on_new(transaction const &t);
- void abort_on_delete(transaction const &t,
- base_transaction_object const &in);
-
- void abort_on_read(transaction const &t,
- base_transaction_object const &in);
- void abort_on_write(transaction &t,
- base_transaction_object const &in);
-
- virtual bool abort_before_commit(transaction const &t)
- {
- return false;
- }
-
- virtual bool permission_to_abort
- (transaction const &lhs, transaction const &rhs)
- { return true; }
-
- virtual bool allow_lock_to_abort_tx(int const & lockWaitTime, int const &lockAborted,
- bool txIsIrrevocable, transaction const &rhs);
-
- virtual void perform_isolated_tx_wait_priority_promotion(transaction &);
- virtual void perform_irrevocable_tx_wait_priority_promotion(transaction &);
-};
-
-////////////////////////////////////////////////////////////////////////////
-//
-// this class does nothing on abort notices for writes and reads
-//
-// this is an important concept as sometimes the overhead from the exception
-// handling is more severe than simply aborting at "commit" time.
-//
-////////////////////////////////////////////////////////////////////////////
-class NoExceptionOnAbortNoticeOnReadWritesCM : public base_contention_manager
-{
-public:
- /////////////////////////////////////////////////////////////////////////
- // do nothing for both of these interfaces
- /////////////////////////////////////////////////////////////////////////
- void abort_on_write(transaction &t,
- base_transaction_object const &in) {}
- void abort_on_read(transaction const &t,
- base_transaction_object const &in) {}
- void abort_on_delete(transaction const &t,
- base_transaction_object const &in) {}
- void abort_on_new(transaction const &t) {}
-};
-
-////////////////////////////////////////////////////////////////////////////
-//
-// this class backs off (and sleeps) when aborting. this is commonly known
-// as "exponential backoff" for locking mechanisms.
-//
-////////////////////////////////////////////////////////////////////////////
-class ExceptAndBackOffOnAbortNoticeCM : public base_contention_manager
-{
-public:
-
- ExceptAndBackOffOnAbortNoticeCM(int const initialSleepTime, int const sleepIncrease,
- int const maxIncreases)
- : sleepTime_(initialSleepTime), kSleepFactorIncrease_(sleepIncrease),
- kMaxIncreases_(maxIncreases), initialSleepTime_(initialSleepTime)
- {
- kMaxSleepTime_ = kSleepFactorIncrease_ * sleepTime_ * kMaxIncreases_;
- }
-
- ////////////////////////////////////////////////////////////////////////////
- void abort_on_write(transaction &t,
- base_transaction_object const &in);
- void abort_on_read(transaction const &t,
- base_transaction_object const &in);
- void abort_on_delete(transaction const &t,
- base_transaction_object const &in);
- void abort_on_new(transaction const &t);
-
- ////////////////////////////////////////////////////////////////////////////
- void perform_isolated_tx_wait_priority_promotion(transaction &lhs)
- {
- lhs.raise_priority();
- }
-
- ////////////////////////////////////////////////////////////////////////////
- void perform_irrevocable_tx_wait_priority_promotion(transaction &lhs)
- {
- lhs.raise_priority();
- }
-
- //--------------------------------------------------------------------------
- // this code is only ever called if "validation" is on not "invalidation"
- // so don't worry about this code EVER stopping invalidation from committing
- //--------------------------------------------------------------------------
- virtual bool abort_before_commit(transaction const &t)
- {
-
- for (transaction::in_flight_trans_cont::const_iterator i =
- transaction::in_flight_transactions().begin();
- i != transaction::in_flight_transactions().end(); ++i)
- {
- if (t.priority() < (*i)->priority()) return true;
- }
-
- return false;
- }
-
- virtual bool permission_to_abort
- (transaction const &lhs, transaction const &rhs)
- {
- return true;
-#if 0
- if (lhs.priority() + 100 > rhs.priority()) return true;
-
- rhs.set_priority(rhs.priority() + 1000);
- return false;
-#endif
- //return lhs.writes() * lhs.priority() >= rhs.writes() * rhs.priority();
- //return lhs.writes() + lhs.reads() >= rhs.writes() + rhs.reads();
- }
-
- virtual bool permission_to_abort
- (transaction const &lhs,
- std::list<transaction*> &rhs)
- {
-#ifdef JUST_PRIORITY
- int setSize = (lhs.writes() * lhs.priority()) +
- (lhs.reads() * lhs.priority());
- double abortSetSize = 0;
- double abortPriority = 0;
- double decrementing = 1.0;
-
- double highestPriority = 0;
-
- bool hasLargestReadSet = true;
-
- for (std::list<core::transaction*>::iterator iter = rhs.begin();
- iter != rhs.end(); ++iter)
- {
- if ((*iter)->priority() > highestPriority)
- {
- highestPriority = (*iter)->priority();
- }
-
- if ((*iter)->reads() > lhs.reads()) hasLargestReadSet = false;
- if ((*iter)->writes() > 0) return true;
-
- abortSetSize += (double)(*iter)->reads() / decrementing;
- abortPriority += (double)(*iter)->priority() / decrementing;
- decrementing += 0.5;
- }
-
- if (lhs.priority() >= highestPriority) return true;
-
- if (hasLargestReadSet) return true;
-
- if (setSize >= abortPriority + abortSetSize)
- {
- return true;
- }
- else
- {
- return false;
- }
-
-#else
- double setSize = (lhs.writes() * lhs.priority()) +
- (lhs.reads() * lhs.priority());
- double abortSetSize = 0;
- double abortPriority = 0;
- bool hasLargestReadSet = true;
-
- unsigned int mem = lhs.reads() + (lhs.writes() * 10);
-
- double decrementing = 1.0;
- for (std::list<transaction*>::iterator iter = rhs.begin();
- iter != rhs.end(); ++iter)
- {
- if ((*iter)->reads() > mem) hasLargestReadSet = false;
-
- if ((*iter)->writes() > 0) return true;
-
- if (lhs.reads() < (*iter)->reads() / 8 &&
- lhs.priority() * 100 < (*iter)->priority()) return false;
-
- abortSetSize += (double)(*iter)->reads() / decrementing;
- abortPriority += (double)(*iter)->priority() / decrementing;
- decrementing += 0.5;
- }
-
- if (hasLargestReadSet) return true;
-
- if (setSize >=
- (abortPriority / setSize) + (abortSetSize / setSize))
- {
- return true;
- }
- else
- {
- return false;
- }
-#endif
- }
-
- virtual bool allow_lock_to_abort_tx
- (int const & lockWaitTime, int const &lockAborted,
- bool txTryingToAbortIsIrrevocable, transaction const &rhs)
- {
- if (txTryingToAbortIsIrrevocable) return true;
-
-#ifndef DISABLE_READ_SETS
- if ((clock_t)lockWaitTime > rhs.read_set_size() + 100 * rhs.writes())
-#else
- if ((clock_t)lockWaitTime > 100 * rhs.writes())
-#endif
- {
- return true;
- }
- else return false;
- }
-
-private:
-
- int sleepTime_;
- int const kSleepFactorIncrease_;
- int kMaxSleepTime_;
- int const kMaxIncreases_;
- int const initialSleepTime_;
-};
-
-}}
-#endif // CONTENTION_MANAGER_H

Added: sandbox/stm/branches/vbe/boost/stm/contention_managers/contention_manager.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/stm/contention_managers/contention_manager.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -0,0 +1,255 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONTENTION_MANAGER_H
+#define BOOST_STM_CONTENTION_MANAGER_H
+
+#include <boost/stm/transaction.hpp>
+
+namespace boost { namespace stm {
+
+
+ //-----------------------------------------------------------------------------
+class DefaultContentionManager : public base_contention_manager
+{
+public:
+ //--------------------------------------------------------------------------
+ void abort_on_new(transaction const &t);
+ void abort_on_delete(transaction const &t,
+ base_transaction_object const &in);
+
+ void abort_on_read(transaction const &t,
+ base_transaction_object const &in);
+ void abort_on_write(transaction &t,
+ base_transaction_object const &in);
+
+ virtual bool abort_before_commit(transaction const &t)
+ {
+ return false;
+ }
+
+ virtual bool permission_to_abort
+ (transaction const &lhs, transaction const &rhs)
+ { return true; }
+
+ virtual bool allow_lock_to_abort_tx(int const & lockWaitTime, int const &lockAborted,
+ bool txIsIrrevocable, transaction const &rhs);
+
+ virtual void perform_isolated_tx_wait_priority_promotion(transaction &);
+ virtual void perform_irrevocable_tx_wait_priority_promotion(transaction &);
+};
+
+////////////////////////////////////////////////////////////////////////////
+//
+// this class does nothing on abort notices for writes and reads
+//
+// this is an important concept as sometimes the overhead from the exception
+// handling is more severe than simply aborting at "commit" time.
+//
+////////////////////////////////////////////////////////////////////////////
+class NoExceptionOnAbortNoticeOnReadWritesCM : public base_contention_manager
+{
+public:
+ /////////////////////////////////////////////////////////////////////////
+ // do nothing for both of these interfaces
+ /////////////////////////////////////////////////////////////////////////
+ void abort_on_write(transaction &t,
+ base_transaction_object const &in) {}
+ void abort_on_read(transaction const &t,
+ base_transaction_object const &in) {}
+ void abort_on_delete(transaction const &t,
+ base_transaction_object const &in) {}
+ void abort_on_new(transaction const &t) {}
+};
+
+////////////////////////////////////////////////////////////////////////////
+//
+// this class backs off (and sleeps) when aborting. this is commonly known
+// as "exponential backoff" for locking mechanisms.
+//
+////////////////////////////////////////////////////////////////////////////
+class ExceptAndBackOffOnAbortNoticeCM : public base_contention_manager
+{
+public:
+
+ ExceptAndBackOffOnAbortNoticeCM(int const initialSleepTime, int const sleepIncrease,
+ int const maxIncreases)
+ : sleepTime_(initialSleepTime), kSleepFactorIncrease_(sleepIncrease),
+ kMaxIncreases_(maxIncreases), initialSleepTime_(initialSleepTime)
+ {
+ kMaxSleepTime_ = kSleepFactorIncrease_ * sleepTime_ * kMaxIncreases_;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+ void abort_on_write(transaction &t,
+ base_transaction_object const &in);
+ void abort_on_read(transaction const &t,
+ base_transaction_object const &in);
+ void abort_on_delete(transaction const &t,
+ base_transaction_object const &in);
+ void abort_on_new(transaction const &t);
+
+ ////////////////////////////////////////////////////////////////////////////
+ void perform_isolated_tx_wait_priority_promotion(transaction &lhs)
+ {
+ lhs.raise_priority();
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+ void perform_irrevocable_tx_wait_priority_promotion(transaction &lhs)
+ {
+ lhs.raise_priority();
+ }
+
+ //--------------------------------------------------------------------------
+ // this code is only ever called if "validation" is on not "invalidation"
+ // so don't worry about this code EVER stopping invalidation from committing
+ //--------------------------------------------------------------------------
+ virtual bool abort_before_commit(transaction const &t)
+ {
+
+ for (transaction::in_flight_trans_cont::const_iterator i =
+ transaction::in_flight_transactions().begin();
+ i != transaction::in_flight_transactions().end(); ++i)
+ {
+ if (t.priority() < (*i)->priority()) return true;
+ }
+
+ return false;
+ }
+
+ virtual bool permission_to_abort
+ (transaction const &lhs, transaction const &rhs)
+ {
+ return true;
+#if 0
+ if (lhs.priority() + 100 > rhs.priority()) return true;
+
+ rhs.set_priority(rhs.priority() + 1000);
+ return false;
+#endif
+ //return lhs.writes() * lhs.priority() >= rhs.writes() * rhs.priority();
+ //return lhs.writes() + lhs.reads() >= rhs.writes() + rhs.reads();
+ }
+
+ virtual bool permission_to_abort
+ (transaction const &lhs,
+ std::list<transaction*> &rhs)
+ {
+#ifdef JUST_PRIORITY
+ int setSize = (lhs.writes() * lhs.priority()) +
+ (lhs.reads() * lhs.priority());
+ double abortSetSize = 0;
+ double abortPriority = 0;
+ double decrementing = 1.0;
+
+ double highestPriority = 0;
+
+ bool hasLargestReadSet = true;
+
+ for (std::list<core::transaction*>::iterator iter = rhs.begin();
+ iter != rhs.end(); ++iter)
+ {
+ if ((*iter)->priority() > highestPriority)
+ {
+ highestPriority = (*iter)->priority();
+ }
+
+ if ((*iter)->reads() > lhs.reads()) hasLargestReadSet = false;
+ if ((*iter)->writes() > 0) return true;
+
+ abortSetSize += (double)(*iter)->reads() / decrementing;
+ abortPriority += (double)(*iter)->priority() / decrementing;
+ decrementing += 0.5;
+ }
+
+ if (lhs.priority() >= highestPriority) return true;
+
+ if (hasLargestReadSet) return true;
+
+ if (setSize >= abortPriority + abortSetSize)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+
+#else
+ double setSize = (lhs.writes() * lhs.priority()) +
+ (lhs.reads() * lhs.priority());
+ double abortSetSize = 0;
+ double abortPriority = 0;
+ bool hasLargestReadSet = true;
+
+ unsigned int mem = lhs.reads() + (lhs.writes() * 10);
+
+ double decrementing = 1.0;
+ for (std::list<transaction*>::iterator iter = rhs.begin();
+ iter != rhs.end(); ++iter)
+ {
+ if ((*iter)->reads() > mem) hasLargestReadSet = false;
+
+ if ((*iter)->writes() > 0) return true;
+
+ if (lhs.reads() < (*iter)->reads() / 8 &&
+ lhs.priority() * 100 < (*iter)->priority()) return false;
+
+ abortSetSize += (double)(*iter)->reads() / decrementing;
+ abortPriority += (double)(*iter)->priority() / decrementing;
+ decrementing += 0.5;
+ }
+
+ if (hasLargestReadSet) return true;
+
+ if (setSize >=
+ (abortPriority / setSize) + (abortSetSize / setSize))
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+#endif
+ }
+
+ virtual bool allow_lock_to_abort_tx
+ (int const & lockWaitTime, int const &lockAborted,
+ bool txTryingToAbortIsIrrevocable, transaction const &rhs)
+ {
+ if (txTryingToAbortIsIrrevocable) return true;
+
+#ifndef DISABLE_READ_SETS
+ if ((clock_t)lockWaitTime > rhs.read_set_size() + 100 * rhs.writes())
+#else
+ if ((clock_t)lockWaitTime > 100 * rhs.writes())
+#endif
+ {
+ return true;
+ }
+ else return false;
+ }
+
+private:
+
+ int sleepTime_;
+ int const kSleepFactorIncrease_;
+ int kMaxSleepTime_;
+ int const kMaxIncreases_;
+ int const initialSleepTime_;
+};
+
+}}
+#endif // CONTENTION_MANAGER_H

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -27,7 +27,7 @@
//#define PERFORMING_VALIDATION 1
#define PERFORMING_LATM 1
#define PERFORMING_COMPOSITION 1
-//#define USE_STM_MEMORY_MANAGER 1
+#define USE_STM_MEMORY_MANAGER 1
#define BUILD_MOVE_SEMANTICS 0
#define USING_TRANSACTION_SPECIFIC_LATM 1
#define USE_BLOOM_FILTER 1
@@ -62,7 +62,7 @@
// Define only one of
// BOOST_STM_CM_STATIC_CONF_except_and_back_off_on_abort_notice_cm when configuration manager is except_and_back_off_on_abort_notice_cm

-//#define BOOST_STM_CM_STATIC_CONF <boost/stm/contention_managers/except_and_back_off_on_abort_notice_cm.hpp>
+#define BOOST_STM_CM_STATIC_CONF <boost/stm/contention_managers/except_and_back_off_on_abort_notice_cm.hpp>
//#define BOOST_STM_CM_STATIC_CONF_except_and_back_off_on_abort_notice_cm 1

#define BOOST_STM_CM_STATIC_INITIAL_SLEEP_TIME 0

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -50,7 +50,7 @@
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline bool transaction::def_do_core_full_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted)
+(latm_mutex mutex, int lockWaitTime, int lockAborted)
{
 //--------------------------------------------------------------------------
 // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
@@ -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(Mutex *mutex)
+inline int transaction::def_full_pthread_lock_mutex(latm_mutex mutex)
{
 if (transaction* t = get_inflight_tx_of_same_thread(false))
 {
@@ -172,7 +172,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_full_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::def_full_pthread_trylock_mutex(latm_mutex mutex)
{
 if (transaction* t = get_inflight_tx_of_same_thread(false))
 {
@@ -229,7 +229,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_full_pthread_unlock_mutex(Mutex *mutex)
+inline int transaction::def_full_pthread_unlock_mutex(latm_mutex mutex)
{
 bool hasLock = true;
 { synchro::lock_guard<Mutex> lock_l(latmMutex_);

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -50,7 +50,7 @@
//
//----------------------------------------------------------------------------
inline bool transaction::def_do_core_tm_conflicting_lock_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted)
+(latm_mutex mutex, int lockWaitTime, int lockAborted)
{
    //--------------------------------------------------------------------------
    // if this mutex is on the tmConflictingLocks_ set, then we need to stop
@@ -97,7 +97,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tm_conflicting_lock_pthread_lock_mutex(Mutex *mutex)
+inline int transaction::def_tm_conflicting_lock_pthread_lock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -170,7 +170,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tm_conflicting_lock_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::def_tm_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -231,7 +231,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tm_conflicting_lock_pthread_unlock_mutex(Mutex *mutex)
+inline int transaction::def_tm_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex)
{
    bool hasLock = true;
    {

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -42,7 +42,7 @@
//
//----------------------------------------------------------------------------
inline bool transaction::def_do_core_tx_conflicting_lock_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable)
+(latm_mutex mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable)
{
 //--------------------------------------------------------------------------
 // see if this mutex is part of any of the in-flight transactions conflicting
@@ -94,7 +94,7 @@

 try {
 latmLockedLocksAndThreadIdsMap_.insert
- (std::make_pair<Mutex*, ThreadIdSet>(mutex, txThreadId));
+ (std::make_pair<latm_mutex, 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(Mutex *mutex)
+inline int transaction::def_tx_conflicting_lock_pthread_lock_mutex(latm_mutex mutex)
{
 int waitTime = 0, aborted = 0;

@@ -211,7 +211,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::def_tx_conflicting_lock_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::def_tx_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex)
{
 //--------------------------------------------------------------------------

@@ -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(Mutex *mutex)
+inline int transaction::def_tx_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex)
{
 synchro::lock_guard<Mutex> autolock_l(*latm_lock());
 synchro::lock_guard<Mutex> autolock_g(*general_lock());

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -50,7 +50,7 @@
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
inline bool transaction::dir_do_core_full_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted)
+(latm_mutex mutex, int lockWaitTime, int lockAborted)
{
    //--------------------------------------------------------------------------
    // if the lock-aware tm lock set is empty, lock the in-flight trans mutex
@@ -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(Mutex *mutex)
+inline int transaction::dir_full_pthread_lock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -187,7 +187,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_full_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::dir_full_pthread_trylock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -244,7 +244,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_full_pthread_unlock_mutex(Mutex *mutex)
+inline int transaction::dir_full_pthread_unlock_mutex(latm_mutex mutex)
{
    bool hasLock = true;
     {

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -50,7 +50,7 @@
//
//----------------------------------------------------------------------------
inline bool transaction::dir_do_core_tm_conflicting_lock_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted)
+(latm_mutex mutex, int lockWaitTime, int lockAborted)
{
    //--------------------------------------------------------------------------
    // if this mutex is on the tmConflictingLocks_ set, then we need to stop
@@ -117,7 +117,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tm_conflicting_lock_pthread_lock_mutex(Mutex *mutex)
+inline int transaction::dir_tm_conflicting_lock_pthread_lock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -175,7 +175,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tm_conflicting_lock_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::dir_tm_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex)
{
    if (transaction* t = get_inflight_tx_of_same_thread(false))
    {
@@ -222,7 +222,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tm_conflicting_lock_pthread_unlock_mutex(Mutex *mutex)
+inline int transaction::dir_tm_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex)
{
    synchro::lock(latmMutex_);
    bool hasLock = true;

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -43,7 +43,7 @@
//
//----------------------------------------------------------------------------
inline bool transaction::dir_do_core_tx_conflicting_lock_pthread_lock_mutex
-(Mutex *mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable)
+(latm_mutex mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable)
{
 //--------------------------------------------------------------------------
 // see if this mutex is part of any of the in-flight transactions conflicting
@@ -96,7 +96,7 @@
 try
 {
 latmLockedLocksAndThreadIdsMap_.insert
- (std::make_pair<Mutex*, ThreadIdSet>(mutex, txThreadId));
+ (std::make_pair<latm_mutex, ThreadIdSet>(mutex, txThreadId));
 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(Mutex *mutex)
+inline int transaction::dir_tx_conflicting_lock_pthread_lock_mutex(latm_mutex mutex)
{
 int waitTime = 0, aborted = 0;

@@ -245,7 +245,7 @@
//----------------------------------------------------------------------------
// only allow one thread to execute any of these methods at a time
//----------------------------------------------------------------------------
-inline int transaction::dir_tx_conflicting_lock_pthread_trylock_mutex(Mutex *mutex)
+inline int transaction::dir_tx_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex)
{
 //--------------------------------------------------------------------------
 throw "might not be possible to implement trylock for this";
@@ -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(Mutex *mutex)
+inline int transaction::dir_tx_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex)
{
 synchro::lock_guard<Mutex> autolock_l(*latm_lock());
 synchro::lock_guard<Mutex> autolock_g(*general_lock());

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -61,7 +61,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::add_to_obtained_locks(Mutex* m)
+inline void boost::stm::transaction::add_to_obtained_locks(latm_mutex m)
{
 obtainedLocksRef().insert(m);

@@ -72,7 +72,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline bool boost::stm::transaction::is_on_obtained_locks_list(Mutex *m)
+inline bool boost::stm::transaction::is_on_obtained_locks_list(latm_mutex m)
{
 return obtainedLocksRef().find(m) != obtainedLocksRef().end();
}
@@ -80,21 +80,21 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline bool boost::stm::transaction::is_currently_locked_lock(Mutex *m)
+inline bool boost::stm::transaction::is_currently_locked_lock(latm_mutex m)
{
 return currentlyLockedLocksRef().find(m) != currentlyLockedLocksRef().end();
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::add_to_currently_locked_locks(Mutex* m)
+inline void boost::stm::transaction::add_to_currently_locked_locks(latm_mutex m)
{
 currentlyLockedLocksRef().insert(m);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::remove_from_currently_locked_locks(Mutex *m)
+inline void boost::stm::transaction::remove_from_currently_locked_locks(latm_mutex m)
{
 currentlyLockedLocksRef().erase(m);
}
@@ -103,9 +103,9 @@
//----------------------------------------------------------------------------
inline void boost::stm::transaction::clear_latm_obtained_locks()
{
- for (MutexSet::iterator i = obtainedLocksRef().begin(); i != obtainedLocksRef().end();)
+ for (latm_mutex_set::iterator i = obtainedLocksRef().begin(); i != obtainedLocksRef().end();)
 {
- Mutex* m = *i;
+ latm_mutex m = *i;
 obtainedLocksRef().erase(i);
 i = obtainedLocksRef().begin();

@@ -133,7 +133,7 @@
// prior to calling this method.
//
//----------------------------------------------------------------------------
-inline bool boost::stm::transaction::mutex_is_on_obtained_tx_list(Mutex *mutex)
+inline bool boost::stm::transaction::mutex_is_on_obtained_tx_list(latm_mutex mutex)
{
#ifdef BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP
 for (tss_context_map_type::iterator iter = tss_context_map_.begin();
@@ -145,7 +145,7 @@
 }
 }
#else
- for (ThreadMutexSetContainer::iterator iter = threadObtainedLocks_.begin();
+ for (thread_latm_mutex_set::iterator iter = threadObtainedLocks_.begin();
 threadObtainedLocks_.end() != iter; ++iter)
 {
 if (iter->second->find(mutex) != iter->second->end())
@@ -163,7 +163,7 @@
// prior to calling this method.
//
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::unblock_conflicting_threads(Mutex *mutex)
+inline void boost::stm::transaction::unblock_conflicting_threads(latm_mutex mutex)
{
 // if the mutex is on the latm locks map, we can't unblock yet
 if (latmLockedLocksAndThreadIdsMap_.find(mutex) != latmLockedLocksAndThreadIdsMap_.end())
@@ -194,7 +194,7 @@
 // if the size is 0, unblock everybody
 if (latmLockedLocksOfThreadMap_.empty())
 {
- for (ThreadMutexSetContainer::iterator it = threadObtainedLocks_.begin();
+ for (thread_latm_mutex_set::iterator it = threadObtainedLocks_.begin();
 it != threadObtainedLocks_.end(); ++it)
 {
 if (!it->second->empty()) return;
@@ -267,7 +267,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::tm_lock_conflict(Mutex *inLock)
+inline void boost::stm::transaction::tm_lock_conflict(latm_mutex inLock)
{
 if (!doing_tm_lock_protection()) return;

@@ -300,7 +300,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::must_be_in_tm_conflicting_lock_set(Mutex *inLock)
+inline void boost::stm::transaction::must_be_in_tm_conflicting_lock_set(latm_mutex inLock)
{
 if (tmConflictingLocks_.find(inLock) == tmConflictingLocks_.end())
 {
@@ -310,7 +310,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::must_be_in_conflicting_lock_set(Mutex *inLock)
+inline void boost::stm::transaction::must_be_in_conflicting_lock_set(latm_mutex inLock)
{
 if (get_tx_conflicting_locks().find(inLock) == get_tx_conflicting_locks().end())
 {
@@ -320,7 +320,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline void boost::stm::transaction::add_tx_conflicting_lock(Mutex *inLock)
+inline void boost::stm::transaction::add_tx_conflicting_lock(latm_mutex inLock)
{
 if (!doing_tx_lock_protection()) return;

@@ -361,7 +361,7 @@
// the client chose
//
//----------------------------------------------------------------------------
-inline int boost::stm::transaction::pthread_lock(Mutex *mutex)
+inline int boost::stm::transaction::pthread_lock(latm_mutex mutex)
{
 //using namespace boost::stm;

@@ -383,7 +383,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline int boost::stm::transaction::pthread_trylock(Mutex *mutex)
+inline int boost::stm::transaction::pthread_trylock(latm_mutex mutex)
{
 //using namespace boost::stm;

@@ -405,7 +405,7 @@

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-inline int boost::stm::transaction::pthread_unlock(Mutex *mutex)
+inline int boost::stm::transaction::pthread_unlock(latm_mutex mutex)
{
 //using namespace boost::stm;

@@ -462,7 +462,7 @@

 block_if_conflict_mutex();

- for (MutexSet::iterator k = get_tx_conflicting_locks().begin(); k != get_tx_conflicting_locks().end(); ++k)
+ 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
 MutexThreadMap::iterator l = latmLockedLocksOfThreadMap_.find(*k);
@@ -478,7 +478,7 @@
 s.insert(this_thread::get_id());

 latmLockedLocksAndThreadIdsMap_.insert
- (std::make_pair<Mutex*, ThreadIdSet>(*k, s));
+ (std::make_pair<latm_mutex, ThreadIdSet>(*k, s));
 }
 else
 {

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -520,7 +520,7 @@

 o << "Threads and their conflicting mutexes:" << endl << endl;

- for (ThreadMutexSetContainer::iterator iter = threadConflictingMutexes_.begin();
+ for (thread_latm_mutex_set::iterator iter = threadConflictingMutexes_.begin();
 threadConflictingMutexes_.end() != iter; ++iter)
 {
 // if this mutex is found in the transaction's conflicting mutexes
@@ -530,7 +530,7 @@
 o << iter->first << " blocked: " << blocked(iter->first) << endl;
 o << "\t";

- for (MutexSet::iterator inner = iter->second->begin(); inner != iter->second->end(); ++inner)
+ for (latm_mutex_set::iterator inner = iter->second->begin(); inner != iter->second->end(); ++inner)
 {
 o << *inner << " ";
 }
@@ -639,7 +639,7 @@
 // to start only if
 else if (transaction::doing_tm_lock_protection())
 {
- for (MutexSet::iterator i = tmConflictingLocks_.begin(); i != tmConflictingLocks_.end(); ++i)
+ for (latm_mutex_set::iterator i = tmConflictingLocks_.begin(); i != tmConflictingLocks_.end(); ++i)
 {
 // if one of your conflicting locks is currently locked ...
 if (latmLockedLocks_.end() != latmLockedLocks_.find(*i))

Modified: sandbox/stm/branches/vbe/boost/stm/memory_managers/base_memory_manager.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/memory_managers/base_memory_manager.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/memory_managers/base_memory_manager.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -47,7 +47,9 @@
{
     base_memory_manager();
public:
- static void alloc_size(std::size_t size) { memory_.alloc_size(size); }
+ static void alloc_size(std::size_t size) {
+ memory_.alloc_size(size);
+ }

     static void return_mem(void *mem, std::size_t size)
     {

Deleted: sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
+++ (empty file)
@@ -1,73 +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_MEMORY_MANAGER__HPP
-#define BOOST_STM_MEMORY_MANAGER__HPP
-
-//-----------------------------------------------------------------------------
-//#include <stdarg.h>
-#include <pthread.h>
-//-----------------------------------------------------------------------------
-#include <list>
-//-----------------------------------------------------------------------------
-#include <boost/stm/detail/config.hpp>
-//-----------------------------------------------------------------------------
-#include <boost/stm/base_transaction_object.hpp>
-#include <boost/stm/cache_fct.hpp>
-#include <boost/stm/datatypes.hpp>
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-namespace boost { namespace stm {
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// memory_manager mixin
-// Functions new and delete
-
-// The parameter Base allows to mix memory_manager and polymorphism
-// class B : memory_manager {}
-// class D : memory_manager<D, B> {}
-// the single issue is the forward constructors from memory_manager<D, B> to B
-//-----------------------------------------------------------------------------
-template <class Derived, typename Base>
-class memory_manager : public Base
-{
-public:
- typedef memory_manager<Derived, Base> this_type;
-
- void* operator new(std::size_t size, const nothrow_t&) throw () {
- return base_memory_manager::retrieve_mem(size);
- }
-
- void* operator new(std::size_t size) throw (std::bad_alloc) {
- void* ptr= base_memory_manager::retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
- return ptr;
- }
-
- void operator delete(void* mem) throw () {
- static Derived elem;
- static std::size_t elemSize = sizeof(elem);
- base_memory_manager::return_mem(mem, elemSize);
- }
-};
-
-}}
-#endif // BOOST_STM_TRANSACTION_OBJECT__HPP
-
-

Copied: sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manager.hpp (from r57055, /sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp)
==============================================================================
--- /sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manage.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/memory_managers/memory_manager.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -19,12 +19,14 @@
#include <pthread.h>
//-----------------------------------------------------------------------------
#include <list>
+#include <exception>
//-----------------------------------------------------------------------------
#include <boost/stm/detail/config.hpp>
//-----------------------------------------------------------------------------
#include <boost/stm/base_transaction_object.hpp>
#include <boost/stm/cache_fct.hpp>
#include <boost/stm/datatypes.hpp>
+#include <boost/stm/memory_managers/base_memory_manager.hpp>
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -50,24 +52,22 @@
public:
 typedef memory_manager<Derived, Base> this_type;

- void* operator new(std::size_t size, const nothrow_t&) throw () {
+ void* operator new(std::size_t size, const std::nothrow_t&) throw () {
 return base_memory_manager::retrieve_mem(size);
 }

 void* operator new(std::size_t size) throw (std::bad_alloc) {
 void* ptr= base_memory_manager::retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
+ if (ptr==0) throw std::bad_alloc();
 return ptr;
 }

 void operator delete(void* mem) throw () {
- static Derived elem;
- static std::size_t elemSize = sizeof(elem);
- base_memory_manager::return_mem(mem, elemSize);
+ base_memory_manager::return_mem(mem, sizeof(Derived));
 }
};

}}
-#endif // BOOST_STM_TRANSACTION_OBJECT__HPP
+#endif // BOOST_STM_MEMORY_MANAGER__HPP

Modified: sandbox/stm/branches/vbe/boost/stm/non_tx/detail/cache_map.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/non_tx/detail/cache_map.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/non_tx/detail/cache_map.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -21,6 +21,8 @@
//-----------------------------------------------------------------------------
#include <boost/stm/base_transaction_object.hpp>
#include <boost/stm/cache_fct.hpp>
+#include <boost/stm/memory_managers/memory_manager.hpp>
+//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
namespace boost { namespace stm {
@@ -34,17 +36,28 @@
//-----------------------------------------------------------------------------

template <typename T>
-class cache : public base_transaction_object {
+class cache : public
+#ifdef USE_STM_MEMORY_MANAGER2
+ memory_manager<cache<T>, base_transaction_object>
+#else
+ base_transaction_object
+#endif
+{
+#ifdef USE_STM_MEMORY_MANAGER2
+ typedef memory_manager<cache<T>, base_transaction_object> base_type;
+#else
+ typedef base_transaction_object base_type;
+#endif
public:
 T* const value_;
 mutable T* ptr_;

 inline cache(T& ref)
- : base_transaction_object()
+ : base_type()
 , value_(&ref), ptr_(0) {}

 inline cache(T* ptr)
- : base_transaction_object()
+ : base_type()
 , value_(ptr), ptr_(0) {}

 inline ~cache() {
@@ -103,24 +116,21 @@
#if USE_STM_MEMORY_MANAGER
 void* operator new(std::size_t size, const std::nothrow_t&) throw ()
 {
- return retrieve_mem(size);
+ return base_memory_manager::retrieve_mem(size);
 }
 void* operator new(std::size_t size) throw (std::bad_alloc)
 {
- void* ptr= retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
+ void* ptr= base_memory_manager::retrieve_mem(size);
+ if (ptr==0) throw std::bad_alloc();
 return ptr;
 }

 void operator delete(void* mem) throw ()
 {
- static cache<T> elem;
- static std::size_t elemSize = sizeof(elem);
- return_mem(mem, elemSize);
+ base_memory_manager::return_mem(mem, sizeof(cache<T>));
 }
#endif
-
-
+
private:
 //cache(cache<T> const & r);

Deleted: sandbox/stm/branches/vbe/boost/stm/non_tx/integers.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/non_tx/integers.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
+++ (empty file)
@@ -1,161 +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_TX_SMART_PTR__HPP
-#define BOOST_STM_TX_SMART_PTR__HPP
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-#include <assert.h>
-#include <boost/stm/transaction.hpp>
-#include <boost/stm/non_tx/detail/cache_map.hpp>
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-namespace boost { namespace stm {
-namespace non_tx {
-
-template <typename T>
-class numeric;
-class chat_t;
-class uchat_t;
-class short_t;
-class ushort_t;
-class int_t;
-class uint_t;
-class long_t;
-class ulong_t;
-
-//-----------------------------------------------------------------------------
-// class numeric wraps a transactional_object providing builting operators
-//-----------------------------------------------------------------------------
-
-template <typename T>
-class numeric {
-public:
- T val_;
- //-----------------------------------------------------------------------------
- numeric() : val_(0) {}
-
- //
- template<class U>
- numeric(numeric const& r) : val(r.value()) {}
-
- // contructor from a implicitly convertible to T
- template <typename U>
- numeric(U v) : val_(v) {}
- //
- ~numeric() {}
-
- operator T() const { return value(); }
- operator T&() { return ref(); }
-
- T& ref() {
- transaction* tx=transaction::current_transaction();
- if (tx!=0) {
- if (tx->forced_to_abort()) {
- tx->lock_and_abort();
- throw aborted_transaction_exception("aborting transaction");
- }
-
- detail::cache<T>* r(tx.write_ptr(detail::cache_map::get(&val_)));
- return *(r->get());
- }
- return val_;
- }
-
- T value() const {
- transaction* tx=transaction::current_transaction();
- if (tx!=0) {
- if (tx->forced_to_abort()) {
- tx->lock_and_abort();
- throw aborted_transaction_exception("aborting transaction");
- }
- detail::cache<T>* r(tx.read_ptr(detail::cache_map::get(&val_)));
- return *(r->get());
- }
- return val_;
- }
-
-#if 0
- numeric& operator--() { --ref(); return *this; }
- T operator--(int) { T n = val_; --ref(); return n; }
-
- numeric& operator++() { ++ref(); return *this; }
- T operator++(int) { T n = val_; ++ref(); return n; }
-
- template <typename U>
- numeric& operator+=(U const &rhs) {
- ref() += rhs;
- return *this;
- }
-
- template <typename U>
- numeric& operator-=(U const &rhs) {
- ref() -= rhs;
- return *this;
- }
-
- template <typename U>
- T operator+(U const &rhs) const {
- return value()+u;
- }
-
- template <typename U>
- T operator-(U const &rhs) const {
- return value()+u;
- }
- // as lvalue
- template <typename U>
- numeric& operator=(U& u) {
- ref()=u;
- return *this;
- }
- void swap(numeric & other) { // never throws
- std::swap(obj_, other.obj_);
- }
-#endif
-
-};
-#if 0
-
-// two transactional pointers are equal if they point to the same cache on the current transaction.
-template <typename T, typename U>
-inline bool operator==(const numeric<T>& lhs, const numeric& rhs) {
- return lhs.ref()==rhs.ref();
-}
-
-template <typename T, typename U>
-inline bool operator==(const T& lhs, const numeric& rhs) {
- return lhs==rhs.ref();
-}
-
-template <typename T, typename U>
-inline bool operator==(const numeric<T>& lhs, const U& rhs) {
- return lhs.ref()==rhs;
-}
-
-template <typename T, typename U>
-inline bool operator!=(const numeric<T>& lhs, const numeric& rhs) {
- return lhs.ref()!=rhs.ref();
-}
-
-template<class T> inline void swap(numeric<T> & a, numeric<T> & b) {
- a.swap(b);
-}
-#endif
-
-}}}
-#endif
-
-

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -34,6 +34,7 @@
#include <boost/stm/datatypes.hpp>
#include <boost/stm/transaction_bookkeeping.hpp>
#include <boost/stm/contention_managers/select_contention_manager.hpp>
+#include <boost/stm/memory_managers/base_memory_manager.hpp>
//-----------------------------------------------------------------------------
#include <boost/stm/detail/bloom_filter.hpp>
#include <boost/stm/detail/deleters.hpp>
@@ -100,9 +101,9 @@

 typedef std::multimap<clock_t, MemoryContainerList > DeletionBuffer;

- typedef std::set<Mutex*> MutexSet;
- typedef void* latm_mutex;
- //typedef Mutex* latm_mutex;
+ //typedef std::set<Mutex*> MutexSet;
+ //typedef void* latm_mutex;
+ typedef Mutex* latm_mutex;
 typedef std::set<latm_mutex> latm_mutex_set;

 typedef std::set<thread_id_t> ThreadIdSet;
@@ -116,7 +117,8 @@
 typedef std::map<thread_id_t, Mutex*> ThreadMutexContainer;
 #endif

- typedef std::map<thread_id_t, MutexSet* > ThreadMutexSetContainer;
+ //typedef std::map<thread_id_t, MutexSet* > ThreadMutexSetContainer;
+ typedef std::map<thread_id_t, latm_mutex_set* > thread_latm_mutex_set;
 typedef std::map<thread_id_t, bloom_filter*> ThreadBloomFilterList;
 #ifdef BOOST_STM_BLOOM_FILTER_USE_DYNAMIC_BITSET
 typedef std::map<thread_id_t, boost::dynamic_bitset<>*> ThreadBitVectorList;
@@ -130,8 +132,9 @@
 typedef std::map<thread_id_t, int*> ThreadBoolContainer;
 #endif

- typedef std::map<Mutex*, ThreadIdSet > MutexThreadSetMap;
- typedef std::map<Mutex*, thread_id_t> MutexThreadMap;
+ typedef std::map<latm_mutex, ThreadIdSet > MutexThreadSetMap;
+ typedef std::map<latm_mutex, thread_id_t> MutexThreadMap;
+ //typedef std::map<Mutex*, thread_id_t> latm_mutex_thread_map;

 typedef std::set<transaction*> LockedTransactionContainer;

@@ -360,9 +363,9 @@
 inline static int unlock_(PLOCK *lock) { return pthread_unlock(lock); }
 #endif

- static int pthread_lock(Mutex *lock);
- static int pthread_trylock(Mutex *lock);
- static int pthread_unlock(Mutex *lock);
+ static int pthread_lock(latm_mutex lock);
+ static int pthread_trylock(latm_mutex lock);
+ static int pthread_unlock(latm_mutex lock);

@@ -373,13 +376,13 @@
 {
 tm_lock_conflict(&lock);
 }
- static void tm_lock_conflict(Mutex *lock);
+ static void tm_lock_conflict(latm_mutex lock);

 static void clear_tm_conflicting_locks();
- inline static MutexSet get_tm_conflicting_locks() { return tmConflictingLocks_; }
+ inline static latm_mutex_set get_tm_conflicting_locks() { return tmConflictingLocks_; }

- void must_be_in_conflicting_lock_set(Mutex *inLock);
- static void must_be_in_tm_conflicting_lock_set(Mutex *inLock);
+ void must_be_in_conflicting_lock_set(latm_mutex inLock);
+ static void must_be_in_tm_conflicting_lock_set(latm_mutex inLock);

 #if USING_TRANSACTION_SPECIFIC_LATM
 void see_if_tx_must_block_due_to_tx_latm();
@@ -387,29 +390,29 @@
 inline void lock_conflict(Mutex &lock)
 { add_tx_conflicting_lock(&lock); }

- inline void lock_conflict(Mutex *lock)
+ inline void lock_conflict(latm_mutex lock)
 { add_tx_conflicting_lock(lock); }

 inline void add_tx_conflicting_lock(Mutex &lock)
 {
 add_tx_conflicting_lock(&lock);
 }
- void add_tx_conflicting_lock(Mutex *lock);
+ void add_tx_conflicting_lock(latm_mutex lock);

 void clear_tx_conflicting_locks();
- //MutexSet get_tx_conflicting_locks() { return conflictingMutexRef_; }
+ //latm_mutex_set get_tx_conflicting_locks() { return conflictingMutexRef_; }
 #endif

- void add_to_obtained_locks(Mutex* );
- static void unblock_conflicting_threads(Mutex *mutex);
- static bool mutex_is_on_obtained_tx_list(Mutex *mutex);
+ void add_to_obtained_locks(latm_mutex mutex);
+ static void unblock_conflicting_threads(latm_mutex mutex);
+ static bool mutex_is_on_obtained_tx_list(latm_mutex mutex);
 static void unblock_threads_if_locks_are_empty();
 void clear_latm_obtained_locks();

- void add_to_currently_locked_locks(Mutex* m);
- void remove_from_currently_locked_locks(Mutex *m);
- bool is_currently_locked_lock(Mutex *m);
- bool is_on_obtained_locks_list(Mutex *m);
+ void add_to_currently_locked_locks(latm_mutex m);
+ void remove_from_currently_locked_locks(latm_mutex m);
+ bool is_currently_locked_lock(latm_mutex m);
+ bool is_on_obtained_locks_list(latm_mutex m);
 #endif

 //--------------------------------------------------------------------------
@@ -1271,21 +1274,21 @@
 // deferred updating methods
 //--------------------------------------------------------------------------
 static bool def_do_core_tm_conflicting_lock_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted);
 static bool def_do_core_tx_conflicting_lock_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable);
 static bool def_do_core_full_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted);

 //--------------------------------------------------------------------------
 // direct updating methods
 //--------------------------------------------------------------------------
 static bool dir_do_core_tm_conflicting_lock_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted);
 static bool dir_do_core_tx_conflicting_lock_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted, bool txIsIrrevocable);
 static bool dir_do_core_full_pthread_lock_mutex
- (Mutex *mutex, int lockWaitTime, int lockAborted);
+ (latm_mutex mutex, int lockWaitTime, int lockAborted);

 static int thread_id_occurance_in_locked_locks_map(thread_id_t threadId);

@@ -1294,32 +1297,32 @@
 //--------------------------------------------------------------------------
 // deferred updating locking methods
 //--------------------------------------------------------------------------
- static int def_full_pthread_lock_mutex(Mutex *mutex);
- static int def_full_pthread_trylock_mutex(Mutex *mutex);
- static int def_full_pthread_unlock_mutex(Mutex *mutex);
-
- static int def_tm_conflicting_lock_pthread_lock_mutex(Mutex *mutex);
- static int def_tm_conflicting_lock_pthread_trylock_mutex(Mutex *mutex);
- static int def_tm_conflicting_lock_pthread_unlock_mutex(Mutex *mutex);
-
- static int def_tx_conflicting_lock_pthread_lock_mutex(Mutex *mutex);
- static int def_tx_conflicting_lock_pthread_trylock_mutex(Mutex *mutex);
- static int def_tx_conflicting_lock_pthread_unlock_mutex(Mutex *mutex);
+ static int def_full_pthread_lock_mutex(latm_mutex mutex);
+ static int def_full_pthread_trylock_mutex(latm_mutex mutex);
+ static int def_full_pthread_unlock_mutex(latm_mutex mutex);
+
+ static int def_tm_conflicting_lock_pthread_lock_mutex(latm_mutex mutex);
+ static int def_tm_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex);
+ static int def_tm_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex);
+
+ static int def_tx_conflicting_lock_pthread_lock_mutex(latm_mutex mutex);
+ static int def_tx_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex);
+ static int def_tx_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex);

 //--------------------------------------------------------------------------
 // direct updating locking methods
 //--------------------------------------------------------------------------
- static int dir_full_pthread_lock_mutex(Mutex *mutex);
- static int dir_full_pthread_trylock_mutex(Mutex *mutex);
- static int dir_full_pthread_unlock_mutex(Mutex *mutex);
-
- static int dir_tm_conflicting_lock_pthread_lock_mutex(Mutex *mutex);
- static int dir_tm_conflicting_lock_pthread_trylock_mutex(Mutex *mutex);
- static int dir_tm_conflicting_lock_pthread_unlock_mutex(Mutex *mutex);
-
- static int dir_tx_conflicting_lock_pthread_lock_mutex(Mutex *mutex);
- static int dir_tx_conflicting_lock_pthread_trylock_mutex(Mutex *mutex);
- static int dir_tx_conflicting_lock_pthread_unlock_mutex(Mutex *mutex);
+ static int dir_full_pthread_lock_mutex(latm_mutex mutex);
+ static int dir_full_pthread_trylock_mutex(latm_mutex mutex);
+ static int dir_full_pthread_unlock_mutex(latm_mutex mutex);
+
+ static int dir_tm_conflicting_lock_pthread_lock_mutex(latm_mutex mutex);
+ static int dir_tm_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex);
+ static int dir_tm_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex);
+
+ static int dir_tx_conflicting_lock_pthread_lock_mutex(latm_mutex mutex);
+ static int dir_tx_conflicting_lock_pthread_trylock_mutex(latm_mutex mutex);
+ static int dir_tx_conflicting_lock_pthread_unlock_mutex(latm_mutex mutex);

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

@@ -1327,8 +1330,8 @@
 static DeletionBuffer deletionBuffer_;
 static std::ofstream logFile_;

- static MutexSet tmConflictingLocks_;
- static MutexSet latmLockedLocks_;
+ static latm_mutex_set tmConflictingLocks_;
+ static latm_mutex_set latmLockedLocks_;
 static MutexThreadSetMap latmLockedLocksAndThreadIdsMap_;
 static MutexThreadMap latmLockedLocksOfThreadMap_;
 static LatmType eLatmType_;
@@ -1499,18 +1502,18 @@

#if PERFORMING_LATM
- static ThreadMutexSetContainer threadConflictingMutexes_;
- static ThreadMutexSetContainer threadObtainedLocks_;
- static ThreadMutexSetContainer threadCurrentlyLockedLocks_;
+ static thread_latm_mutex_set threadConflictingMutexes_;
+ static thread_latm_mutex_set threadObtainedLocks_;
+ static thread_latm_mutex_set threadCurrentlyLockedLocks_;

#if USING_TRANSACTION_SPECIFIC_LATM
- MutexSet &conflictingMutexRef_;
- inline MutexSet& get_tx_conflicting_locks() { return conflictingMutexRef_; }
- inline MutexSet& get_tx_conflicting_locks(thread_id_t id) {
+ latm_mutex_set &conflictingMutexRef_;
+ inline latm_mutex_set& get_tx_conflicting_locks() { return conflictingMutexRef_; }
+ inline latm_mutex_set& get_tx_conflicting_locks(thread_id_t id) {
 return *threadConflictingMutexes_.find(threadId_)->second;
 }
 static void thread_conflicting_mutexes_set_all(int b) {
- for (ThreadMutexSetContainer::iterator iter = threadConflictingMutexes_.begin();
+ for (thread_latm_mutex_set::iterator iter = threadConflictingMutexes_.begin();
 threadConflictingMutexes_.end() != iter; ++iter)
 {
 blocked(iter->first) = b;
@@ -1518,7 +1521,7 @@
 }

 static void thread_conflicting_mutexes_set_all_cnd(Mutex *mutex, int b) {
- for (ThreadMutexSetContainer::iterator iter = threadConflictingMutexes_.begin();
+ for (thread_latm_mutex_set::iterator iter = threadConflictingMutexes_.begin();
 threadConflictingMutexes_.end() != iter; ++iter)
 {
 // if this mutex is found in the transaction's conflicting mutexes
@@ -1534,21 +1537,21 @@
 }
#endif

- MutexSet &obtainedLocksRef_;
- inline MutexSet &obtainedLocksRef() {return obtainedLocksRef_;}
- inline static MutexSet &obtainedLocksRef(thread_id_t id) {return *threadObtainedLocks_.find(id)->second;}
+ latm_mutex_set &obtainedLocksRef_;
+ inline latm_mutex_set &obtainedLocksRef() {return obtainedLocksRef_;}
+ inline static latm_mutex_set &obtainedLocksRef(thread_id_t id) {return *threadObtainedLocks_.find(id)->second;}

 void block_if_conflict_mutex() {
 //--------------------------------------------------------------------------
 // iterate through all currently locked locks
 //--------------------------------------------------------------------------
- for (ThreadMutexSetContainer::iterator i = threadObtainedLocks_.begin();
+ for (thread_latm_mutex_set::iterator i = threadObtainedLocks_.begin();
 threadObtainedLocks_.end() != i; ++i)
 {
 // if these are locks obtained by this thread (in a parent tx), don't block
 if (i->first == this_thread::get_id()) continue;

- for (MutexSet::iterator j = i->second->begin(); j != i->second->end(); ++j)
+ for (latm_mutex_set::iterator j = i->second->begin(); j != i->second->end(); ++j)
 {
 //-----------------------------------------------------------------------
 // iterate through this transaction's conflicting mutex ref - if one of
@@ -1563,9 +1566,9 @@
 }
 }

- MutexSet &currentlyLockedLocksRef_;
- inline MutexSet &currentlyLockedLocksRef() {return currentlyLockedLocksRef_;}
- inline static MutexSet &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
+ latm_mutex_set &currentlyLockedLocksRef_;
+ inline latm_mutex_set &currentlyLockedLocksRef() {return currentlyLockedLocksRef_;}
+ inline static latm_mutex_set &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
#endif

@@ -1657,8 +1660,8 @@
#if PERFORMING_LATM

#if USING_TRANSACTION_SPECIFIC_LATM
- inline MutexSet& get_tx_conflicting_locks() { return context_.conflictingMutex_; }
- inline MutexSet& get_tx_conflicting_locks(thread_id_t id) {
+ inline latm_mutex_set& get_tx_conflicting_locks() { return context_.conflictingMutex_; }
+ inline latm_mutex_set& get_tx_conflicting_locks(thread_id_t id) {
 tss_context_map_type::iterator i = tss_context_map_.find(id);
 return i->second->conflictingMutex_;
 }
@@ -1670,7 +1673,7 @@
 }
 }

- static void thread_conflicting_mutexes_set_all_cnd(Mutex *mutex, int b) {
+ static void thread_conflicting_mutexes_set_all_cnd(latm_mutex mutex, int b) {
 for (tss_context_map_type::iterator iter = tss_context_map_.begin();
 tss_context_map_.end() != iter; ++iter)
 {
@@ -1687,8 +1690,8 @@
 }
#endif

- inline MutexSet &obtainedLocksRef() {return context_.obtainedLocks_;}
- inline static MutexSet &obtainedLocksRef(thread_id_t id) {
+ inline latm_mutex_set &obtainedLocksRef() {return context_.obtainedLocks_;}
+ inline static latm_mutex_set &obtainedLocksRef(thread_id_t id) {
 tss_context_map_type::iterator i = tss_context_map_.find(id);
 return i->second->obtainedLocks_;
 }
@@ -1703,7 +1706,7 @@
 // if these are locks obtained by this thread (in a parent tx), don't block
 if (i->first == this_thread::get_id()) continue;

- for (MutexSet::iterator j = i->second->obtainedLocks_.begin(); j != i->second->obtainedLocks_.end(); ++j)
+ for (latm_mutex_set::iterator j = i->second->obtainedLocks_.begin(); j != i->second->obtainedLocks_.end(); ++j)
 {
 //-----------------------------------------------------------------------
 // iterate through this transaction's conflicting mutex ref - if one of
@@ -1719,8 +1722,8 @@
 }

- inline MutexSet &currentlyLockedLocksRef() {return context_.currentlyLockedLocks_;}
- inline static MutexSet &currentlyLockedLocksRef(thread_id_t id) {
+ inline latm_mutex_set &currentlyLockedLocksRef() {return context_.currentlyLockedLocks_;}
+ inline static latm_mutex_set &currentlyLockedLocksRef(thread_id_t id) {
 tss_context_map_type::iterator i = tss_context_map_.find(id);
 return i->second->currentlyLockedLocks_;
 }
@@ -1793,26 +1796,26 @@

#if PERFORMING_LATM
- static ThreadMutexSetContainer threadConflictingMutexes_;
- static ThreadMutexSetContainer threadObtainedLocks_;
- static ThreadMutexSetContainer threadCurrentlyLockedLocks_;
+ static thread_latm_mutex_set threadConflictingMutexes_;
+ static thread_latm_mutex_set threadObtainedLocks_;
+ static thread_latm_mutex_set threadCurrentlyLockedLocks_;

#if USING_TRANSACTION_SPECIFIC_LATM
- MutexSet &conflictingMutexRef_;
- inline MutexSet& get_tx_conflicting_locks() { return conflictingMutexRef_; }
- inline MutexSet& get_tx_conflicting_locks(thread_id_t id) {
+ latm_mutex_set &conflictingMutexRef_;
+ inline latm_mutex_set& get_tx_conflicting_locks() { return conflictingMutexRef_; }
+ inline latm_mutex_set& get_tx_conflicting_locks(thread_id_t id) {
 return *threadConflictingMutexes_.find(threadId_)->second;
 }
 static void thread_conflicting_mutexes_set_all(int b) {
- for (ThreadMutexSetContainer::iterator iter = threadConflictingMutexes_.begin();
+ for (thread_latm_mutex_set::iterator iter = threadConflictingMutexes_.begin();
 threadConflictingMutexes_.end() != iter; ++iter)
 {
 blocked(iter->first) = b;
 }
 }

- static void thread_conflicting_mutexes_set_all_cnd(Mutex *mutex, int b) {
- for (ThreadMutexSetContainer::iterator iter = threadConflictingMutexes_.begin();
+ static void thread_conflicting_mutexes_set_all_cnd(latm_mutex mutex, int b) {
+ for (thread_latm_mutex_set::iterator iter = threadConflictingMutexes_.begin();
 threadConflictingMutexes_.end() != iter; ++iter)
 {
 // if this mutex is found in the transaction's conflicting mutexes
@@ -1828,21 +1831,21 @@
 }
#endif

- MutexSet &obtainedLocksRef_;
- inline MutexSet &obtainedLocksRef() {return obtainedLocksRef_;}
- inline static MutexSet &obtainedLocksRef(thread_id_t id) {return *threadObtainedLocks_.find(id)->second;}
+ latm_mutex_set &obtainedLocksRef_;
+ inline latm_mutex_set &obtainedLocksRef() {return obtainedLocksRef_;}
+ inline static latm_mutex_set &obtainedLocksRef(thread_id_t id) {return *threadObtainedLocks_.find(id)->second;}

 void block_if_conflict_mutex() {
 //--------------------------------------------------------------------------
 // iterate through all currently locked locks
 //--------------------------------------------------------------------------
- for (ThreadMutexSetContainer::iterator i = threadObtainedLocks_.begin();
+ for (thread_latm_mutex_set::iterator i = threadObtainedLocks_.begin();
 threadObtainedLocks_.end() != i; ++i)
 {
 // if these are locks obtained by this thread (in a parent tx), don't block
 if (i->first == this_thread::get_id()) continue;

- for (MutexSet::iterator j = i->second->begin(); j != i->second->end(); ++j)
+ for (latm_mutex_set::iterator j = i->second->begin(); j != i->second->end(); ++j)
 {
 //-----------------------------------------------------------------------
 // iterate through this transaction's conflicting mutex ref - if one of
@@ -1859,9 +1862,9 @@

- MutexSet &currentlyLockedLocksRef_;
- inline MutexSet &currentlyLockedLocksRef() {return currentlyLockedLocksRef_;}
- inline static MutexSet &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
+ latm_mutex_set &currentlyLockedLocksRef_;
+ inline latm_mutex_set &currentlyLockedLocksRef() {return currentlyLockedLocksRef_;}
+ inline static latm_mutex_set &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
#endif

@@ -1898,7 +1901,7 @@

template <class T> T* cache_allocate(transaction* t) {
 #if defined(BOOST_STM_CACHE_USE_MEMORY_MANAGER) && defined (USE_STM_MEMORY_MANAGER)
- return reinterpret_cast<T*>(T::retrieve_mem(sizeof(T)));
+ return reinterpret_cast<T*>(base_memory_manager::retrieve_mem(sizeof(T)));
 #elif defined(BOOST_STM_CACHE_USE_MALLOC)
 return reinterpret_cast<T*>(malloc(sizeof(T)));
 #elif defined(BOOST_STM_CACHE_USE_TSS_MONOTONIC_MEMORY_MANAGER)
@@ -1921,7 +1924,7 @@
 static void apply(T* ptr) {
 if (ptr) {
 #if defined(BOOST_STM_CACHE_USE_MEMORY_MANAGER) && defined (USE_STM_MEMORY_MANAGER)
- base_transaction_object::return_mem(ptr,sizeof(T));
+ base_memory_manager::return_mem(ptr,sizeof(T));
 #elif defined(BOOST_STM_CACHE_USE_MALLOC)
 free(ptr);
 #elif defined(BOOST_STM_CACHE_USE_TSS_MONOTONIC_MEMORY_MANAGER)
@@ -1944,7 +1947,7 @@
inline void cache_deallocate(T* ptr) {
 if (ptr) {
 #if defined(BOOST_STM_CACHE_USE_MEMORY_MANAGER) && defined (USE_STM_MEMORY_MANAGER
- base_transaction_object::return_mem(ptr,sizeof(T));
+ base_memory_manager::return_mem(ptr,sizeof(T));
 #elif defined(BOOST_STM_CACHE_USE_MALLOC)
 free(ptr);
 #elif defined(BOOST_STM_CACHE_USE_TSS_MONOTONIC_MEMORY_MANAGER)

Modified: sandbox/stm/branches/vbe/boost/stm/transaction_object.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/transaction_object.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/transaction_object.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -26,9 +26,7 @@
#include <boost/stm/base_transaction_object.hpp>
#include <boost/stm/cache_fct.hpp>
#include <boost/stm/datatypes.hpp>
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
+#include <boost/stm/memory_managers/memory_manager.hpp>
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
@@ -56,8 +54,18 @@
// the single issue is the forward constructors from transaction_object<D, B> to B
//-----------------------------------------------------------------------------
template <class Derived, typename Base=base_transaction_object>
-class transaction_object : public base_transaction_object
+class transaction_object : public
+#ifdef USE_STM_MEMORY_MANAGER2
+ memory_manager<transaction_object<Derived,Base>, Base>
+#else
+ Base
+#endif
{
+#ifdef USE_STM_MEMORY_MANAGER2
+ typedef memory_manager<transaction_object<Derived,Base>, Base> base_type;
+#else
+ typedef Base base_type;
+#endif
public:
 typedef transaction_object<Derived, Base> this_type;

@@ -107,20 +115,18 @@
#if USE_STM_MEMORY_MANAGER
 void* operator new(std::size_t size, const std::nothrow_t&) throw ()
 {
- return retrieve_mem(size);
+ return base_memory_manager::retrieve_mem(size);
 }
 void* operator new(std::size_t size) throw (std::bad_alloc)
 {
- void* ptr= retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
+ void* ptr= base_memory_manager::retrieve_mem(size);
+ if (ptr==0) throw std::bad_alloc();
 return ptr;
 }

 void operator delete(void* mem) throw ()
 {
- static Derived elem;
- static std::size_t elemSize = sizeof(elem);
- return_mem(mem, elemSize);
+ base_memory_manager::return_mem(mem, sizeof(Derived));
 }
#endif
};

Modified: sandbox/stm/branches/vbe/boost/stm/tx/deep_transaction_object.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/tx/deep_transaction_object.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/tx/deep_transaction_object.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -17,6 +17,6 @@
//-----------------------------------------------------------------------------
#include <boost/stm/transaction_object.hpp>
//-----------------------------------------------------------------------------
-#endif // BOOST_STM_SHALLOW_TRANSACTION_OBJECT__HPP
+#endif // BOOST_STM_TX_DEEP_TRANSACTION_OBJECT__HPP

Modified: sandbox/stm/branches/vbe/boost/stm/tx/shallow_transaction_object.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/tx/shallow_transaction_object.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/tx/shallow_transaction_object.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -25,9 +25,7 @@
#include <boost/stm/base_transaction_object.hpp>
#include <boost/stm/cache_fct.hpp>
#include <boost/stm/datatypes.hpp>
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
+#include <boost/stm/memory_managers/memory_manager.hpp>
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
@@ -56,8 +54,18 @@
//-----------------------------------------------------------------------------

template <class Derived, typename Base=base_transaction_object>
-class shallow_transaction_object : public base_transaction_object
+class shallow_transaction_object : public
+#ifdef USE_STM_MEMORY_MANAGER
+ memory_manager<shallow_transaction_object<Derived,Base>, Base>
+#else
+ Base
+#endif
{
+#ifdef USE_STM_MEMORY_MANAGER
+ typedef memory_manager<transaction_object<Derived,Base>, Base> base_type;
+#else
+ typedef Base base_type;
+#endif
public:

//--------------------------------------------------------------------------
@@ -85,27 +93,6 @@
}
#endif

-
-#if USE_STM_MEMORY_MANAGER
- void* operator new(std::size_t size, const std::nothrow_t&) throw ()
- {
- return retrieve_mem(size);
- }
- void* operator new(std::size_t size) throw (std::bad_alloc)
- {
- void* ptr= retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
- return ptr;
- }
-
- void operator delete(void* mem) throw ()
- {
- static Derived elem;
- static std::size_t elemSize = sizeof(elem);
- return_mem(mem, elemSize);
- }
-#endif
-
};

template <typename T> class shallow_native_trans :

Modified: sandbox/stm/branches/vbe/boost/stm/txw/transactional_object.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/txw/transactional_object.hpp (original)
+++ sandbox/stm/branches/vbe/boost/stm/txw/transactional_object.hpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -14,7 +14,10 @@
#ifndef BOOST_STM_TXW_TRANSACTIONAL_OBJECT__HPP
#define BOOST_STM_TXW_TRANSACTIONAL_OBJECT__HPP

+//-----------------------------------------------------------------------------
#include <boost/stm/base_transaction.hpp>
+#include <boost/stm/memory_managers/memory_manager.hpp>
+//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
namespace boost { namespace stm {
@@ -42,27 +45,39 @@
//-----------------------------------------------------------------------------

template <typename T>
-class transactional_object : public base_transaction_object {
+class transactional_object : public
+#ifdef USE_STM_MEMORY_MANAGER2
+ memory_manager<transactional_object<T>, base_transaction_object>
+#else
+ base_transaction_object
+#endif
+{
+#ifdef USE_STM_MEMORY_MANAGER2
+ typedef memory_manager<transactional_object<T>, base_transaction_object> base_type;
+#else
+ typedef base_transaction_object base_type;
+#endif
public:
+
 T value;

 transactional_object() {}
 transactional_object(const T*ptr)
- : base_transaction_object()
+ : base_type()
 , value(*ptr) {}

 transactional_object(transactional_object<T> const & r)
- : base_transaction_object(r)
+ : base_type(r)
 , value(r.value) {}

 template <typename T1>
 transactional_object(T1 const &p1)
- : base_transaction_object()
+ : base_type()
 , value(p1) {}

 template <typename T1, typename T2>
 transactional_object(T1 const &p1, T2 const &p2)
- : base_transaction_object()
+ : base_type()
 , value(p1,p2) {}

 transactional_object & operator=(transactional_object const & r) // =default never throws
@@ -106,20 +121,18 @@
 #if USE_STM_MEMORY_MANAGER
 void* operator new(std::size_t size, const std::nothrow_t&) throw ()
 {
- return retrieve_mem(size);
+ return base_memory_manager::retrieve_mem(size);
 }
 void* operator new(std::size_t size) throw (std::bad_alloc)
 {
- void* ptr= retrieve_mem(size);
- if (ptr==0) throw std::bad_alloc;
+ void* ptr= base_memory_manager::retrieve_mem(size);
+ if (ptr==0) throw std::bad_alloc();
 return ptr;
 }

 void operator delete(void* mem) throw ()
 {
- static transactional_object<T> elem;
- static std::size_t elemSize = sizeof(elem);
- return_mem(mem, elemSize);
+ base_memory_manager::return_mem(mem, sizeof(transactional_object<T>));
 }
 #endif

Modified: sandbox/stm/branches/vbe/libs/stm/src/contention_manager.cpp
==============================================================================
--- sandbox/stm/branches/vbe/libs/stm/src/contention_manager.cpp (original)
+++ sandbox/stm/branches/vbe/libs/stm/src/contention_manager.cpp 2009-10-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -11,7 +11,7 @@
//
//////////////////////////////////////////////////////////////////////////////

-#include <boost/stm/contention_manager.hpp>
+#include <boost/stm/contention_managers/contention_manager.hpp>
#include <boost/stm/transaction.hpp>
#include <pthread.h>

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -13,7 +13,7 @@

#include <boost/stm/transaction.hpp>
#include <boost/stm/non_tx/detail/cache_map.hpp>
-#include <boost/stm/contention_manager.hpp>
+#include <boost/stm/contention_managers/contention_manager.hpp>
#include <iostream>

using namespace std;
@@ -31,10 +31,10 @@
// Static initialization
///////////////////////////////////////////////////////////////////////////////
transaction::InflightTxes transaction::transactionsInFlight_;
-transaction::MutexSet transaction::latmLockedLocks_;
+transaction::latm_mutex_set transaction::latmLockedLocks_;
transaction::MutexThreadSetMap transaction::latmLockedLocksAndThreadIdsMap_;
transaction::MutexThreadMap transaction::latmLockedLocksOfThreadMap_;
-transaction::MutexSet transaction::tmConflictingLocks_;
+transaction::latm_mutex_set transaction::tmConflictingLocks_;
transaction::DeletionBuffer transaction::deletionBuffer_;

clock_t transaction::global_clock_ = 0;
@@ -55,14 +55,13 @@
boost::stm::LatmType transaction::eLatmType_ = eFullLatmProtection;
std::ofstream transaction::logFile_;

-#if USE_STM_MEMORY_MANAGER
#ifndef BOOST_STM_USE_BOOST_MUTEX
-Mutex base_transaction_object::transactionObjectMutex_ = PTHREAD_MUTEX_INITIALIZER;
+Mutex base_memory_manager::transactionObjectMutex_ = PTHREAD_MUTEX_INITIALIZER;
#else
-boost::mutex base_transaction_object::transactionObjectMutex_;
-#endif
-boost::stm::MemoryPool<base_transaction_object> base_transaction_object::memory_(16384);
+boost::mutex base_memory_manager::transactionObjectMutex_;
#endif
+boost::stm::MemoryPool<void*> base_memory_manager::memory_(16384);
+

bool transaction::initialized_ = false;
///////////////////////////////////////////////////////////////////////////////
@@ -97,10 +96,10 @@
#ifndef USE_SINGLE_THREAD_CONTEXT_MAP
#if PERFORMING_LATM
#if USING_TRANSACTION_SPECIFIC_LATM
-transaction::ThreadMutexSetContainer transaction::threadConflictingMutexes_;
+transaction::thread_latm_mutex_set transaction::threadConflictingMutexes_;
#endif
-transaction::ThreadMutexSetContainer transaction::threadObtainedLocks_;
-transaction::ThreadMutexSetContainer transaction::threadCurrentlyLockedLocks_;
+transaction::thread_latm_mutex_set transaction::threadObtainedLocks_;
+transaction::thread_latm_mutex_set transaction::threadCurrentlyLockedLocks_;
#endif
transaction::ThreadWriteContainer transaction::threadWriteLists_;
transaction::ThreadReadContainer transaction::threadReadLists_;
@@ -118,10 +117,10 @@
#ifndef BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP
#if PERFORMING_LATM
#if USING_TRANSACTION_SPECIFIC_LATM
-transaction::ThreadMutexSetContainer transaction::threadConflictingMutexes_;
+transaction::thread_latm_mutex_set transaction::threadConflictingMutexes_;
#endif
-transaction::ThreadMutexSetContainer transaction::threadObtainedLocks_;
-transaction::ThreadMutexSetContainer transaction::threadCurrentlyLockedLocks_;
+transaction::thread_latm_mutex_set transaction::threadObtainedLocks_;
+transaction::thread_latm_mutex_set transaction::threadCurrentlyLockedLocks_;
#endif
transaction::ThreadMutexContainer transaction::threadMutexes_;
transaction::ThreadBoolContainer transaction::threadBlockedLists_;
@@ -139,7 +138,7 @@
///////////////////////////////////////////////////////////////////////////////
void transaction::initialize()
{
- base_transaction_object::alloc_size(16384);
+ base_memory_manager::alloc_size(16384);

 if (initialized_) return;
 initialized_ = true;
@@ -219,23 +218,23 @@

#if PERFORMING_LATM
#if USING_TRANSACTION_SPECIFIC_LATM
- ThreadMutexSetContainer::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
+ thread_latm_mutex_set::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
 if (threadConflictingMutexes_.end() == conflictingMutexIter)
 {
- threadConflictingMutexes_[threadId] = new MutexSet;
+ threadConflictingMutexes_[threadId] = new latm_mutex_set;
 }
#endif

- ThreadMutexSetContainer::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
 if (threadObtainedLocks_.end() == obtainedLocksIter)
 {
- threadObtainedLocks_[threadId] = new MutexSet;
+ threadObtainedLocks_[threadId] = new latm_mutex_set;
 }

- ThreadMutexSetContainer::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
 if (threadCurrentlyLockedLocks_.end() == currentlyLockedLocksIter)
 {
- threadCurrentlyLockedLocks_[threadId] = new MutexSet;
+ threadCurrentlyLockedLocks_[threadId] = new latm_mutex_set;
 }
#endif

@@ -312,23 +311,23 @@
 ThreadBoolContainer::iterator blockedIter = threadBlockedLists_.find(threadId);
#if PERFORMING_LATM
#if USING_TRANSACTION_SPECIFIC_LATM
- ThreadMutexSetContainer::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
+ thread_latm_mutex_set::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
 if (threadConflictingMutexes_.end() == conflictingMutexIter)
 {
- threadConflictingMutexes_[threadId] = new MutexSet;
+ threadConflictingMutexes_[threadId] = new latm_mutex_set;
 }
#endif

- ThreadMutexSetContainer::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
 if (threadObtainedLocks_.end() == obtainedLocksIter)
 {
- threadObtainedLocks_[threadId] = new MutexSet;
+ threadObtainedLocks_[threadId] = new latm_mutex_set;
 }

- ThreadMutexSetContainer::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
 if (threadCurrentlyLockedLocks_.end() == currentlyLockedLocksIter)
 {
- threadCurrentlyLockedLocks_[threadId] = new MutexSet;
+ threadCurrentlyLockedLocks_[threadId] = new latm_mutex_set;
 }
#endif

@@ -482,16 +481,16 @@

#if PERFORMING_LATM
#if USING_TRANSACTION_SPECIFIC_LATM
- ThreadMutexSetContainer::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
+ thread_latm_mutex_set::iterator conflictingMutexIter = threadConflictingMutexes_.find(threadId);
 delete conflictingMutexIter->second;
 threadConflictingMutexes_.erase(conflictingMutexIter);
#endif

- ThreadMutexSetContainer::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator obtainedLocksIter = threadObtainedLocks_.find(threadId);
 delete obtainedLocksIter->second;
 threadObtainedLocks_.erase(obtainedLocksIter);

- ThreadMutexSetContainer::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
+ thread_latm_mutex_set::iterator currentlyLockedLocksIter = threadCurrentlyLockedLocks_.find(threadId);
 delete currentlyLockedLocksIter->second;
 threadCurrentlyLockedLocks_.erase(currentlyLockedLocksIter);
#endif

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-25 03:57:20 EDT (Sun, 25 Oct 2009)
@@ -140,7 +140,7 @@
             #/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 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 ]

@@ -183,7 +183,7 @@

             ########### fails
             # /bin/sh: line 4: 2656 Segmentation fault (core dumped) "bin/list.test/gcc-3.4.4/debug/threading-multi/list.exe" > "bin/list.test/gcc-3.4.4/debug/threading-multi/list.output" 2>&1
- #[ run ../example/list.cpp ]
+ [ link ../example/list.cpp ]

             [ run ../example/counter.cpp ]
             [ run ../example/numeric.cpp ]

Next message: oliver.kowalke_at_[hidden]: "[Boost-commit] svn:boost r57145 - sandbox/task/boost/task/detail"
Previous message: oliver.kowalke_at_[hidden]: "[Boost-commit] svn:boost r57143 - in sandbox/task: boost/task boost/task/detail libs/task/test"

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