[Boost-commit] svn:boost r56991 - in sandbox/stm/branches/vbe: boost/stm boost/stm/detail boost/synchro boost/synchro/pthread libs/stm/src

Subject: [Boost-commit] svn:boost r56991 - in sandbox/stm/branches/vbe: boost/stm boost/stm/detail boost/synchro boost/synchro/pthread libs/stm/src
From: vicente.botet_at_[hidden]
Date: 2009-10-18 19:03:03

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

Log:
TBoost.STM vbe: 
* Added implicit_thread_specific_storage (tss.hpp)
* Change current_transaction implementation using implicit_thread_specific_storage
* synchro.hpp cleanup
* pthread mutex robustness
Added:
   sandbox/stm/branches/vbe/boost/synchro/tss.hpp   (contents, props changed)
Text files modified: 
   sandbox/stm/branches/vbe/boost/stm/detail/config.hpp           |     2                                         
   sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp |    14 +++-----                                
   sandbox/stm/branches/vbe/boost/stm/synchro.hpp                 |    53 ++++++++++++---------------------       
   sandbox/stm/branches/vbe/boost/stm/transaction.hpp             |    62 +++++++-------------------------------- 
   sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp       |    11 +++---                                  
   sandbox/stm/branches/vbe/libs/stm/src/transaction.cpp          |    16 +---------                              
   6 files changed, 45 insertions(+), 113 deletions(-)

Modified: sandbox/stm/branches/vbe/boost/stm/detail/config.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/config.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/config.hpp	2009-10-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -34,7 +34,7 @@
 //      OTHER: each TSS data has its specific TSS
 
 #define USE_SINGLE_THREAD_CONTEXT_MAP 1
-#define BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP 1
+//#define BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP 1
 
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/stm/detail/transaction_impl.hpp	2009-10-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -444,8 +444,6 @@
    currentlyLockedLocksRef_(*threadCurrentlyLockedLocks_.find(threadId_)->second),
 #endif
 #endif
-   transactionsRef_(transactions_unsafe(threadId_)),
-
 ////////////////////////////////////////
 #else
 ////////////////////////////////////////
@@ -481,11 +479,9 @@
    currentlyLockedLocksRef_(*threadCurrentlyLockedLocks_.find(threadId_)->second),
 #endif
 ////////////////////////////////////////
-   transactionsRef_(transactions_unsafe(threadId_)),
-
 #endif
-
-   //hasMutex_(0), 
+    transaction_tss_storage_ref_(*transaction_tss_storage_),
+   //hasMutex_(0),
    priority_(0),
    state_(e_no_state),
    reads_(0),
@@ -706,8 +702,8 @@
       return;
    }
 
-    //if (!hasLock()) 
-    { 
+    //if (!hasLock())
+    {
        synchro::lock_guard<Mutex> lock(*mutex());
         abort();
     }
@@ -813,7 +809,7 @@
       direct_abort();
       //unlock_tx();
       synchro::unlock(*mutex());
-      
+
       //-----------------------------------------------------------------------
       // if this tx was writing, unlock the transaction mutex now
       //-----------------------------------------------------------------------

Modified: sandbox/stm/branches/vbe/boost/stm/synchro.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/synchro.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/stm/synchro.hpp	2009-10-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -14,30 +14,17 @@
 #ifndef BOOST_STM_SYNCHO__HPP
 #define BOOST_STM_SYNCHO__HPP
 
-#include <boost/stm/detail/config.hpp>
-
-#ifdef BOOST_STM_USE_BOOST_SYNCHRO
-#include <boost/synchro.hpp>
-#endif
-
 //-----------------------------------------------------------------------------
-#include <stdarg.h>
 #include <pthread.h>
 //-----------------------------------------------------------------------------
-#include <list>
-#include <stdexcept>
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//#include <boost/stm/exceptions.hpp>
-//-----------------------------------------------------------------------------
-//#include <boost/stm/detail/memory_pool.hpp>
+#include <boost/stm/detail/config.hpp>
 //-----------------------------------------------------------------------------
-
-#ifdef BOOST_STM_USE_BOOST
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread_time.hpp>
+#ifdef BOOST_STM_USE_BOOST_SYNCHRO
+#include <boost/synchro.hpp>
+#else
+#include <stdexcept>
 #endif
+//-----------------------------------------------------------------------------
 
 #ifndef BOOST_STM_USE_BOOST_MUTEX
    typedef pthread_mutex_t Mutex;
@@ -49,7 +36,7 @@
 
 //-----------------------------------------------------------------------------
 
-namespace boost { 
+namespace boost {
 #ifndef BOOST_STM_USE_BOOST_SYNCHRO
 namespace synchro {
 
@@ -60,19 +47,19 @@
         ~lock_error() throw() {}
 
         virtual const char* what() const throw() {return "synchro::lock_error";}
-    };    
-    
+    };
+
     struct defer_lock_t
     {};
     struct try_to_lock_t
     {};
     struct adopt_lock_t
     {};
-    
+
     const defer_lock_t defer_lock={};
     const try_to_lock_t try_to_lock={};
     const adopt_lock_t adopt_lock={};
-        
+
     template< typename Lockable >
     inline void lock(Lockable& lockable) {
         lockable.lock();
@@ -97,7 +84,7 @@
     inline void unlock<pthread_mutex_t>(pthread_mutex_t& lockable) {
         pthread_mutex_unlock(&lockable);
     }
-    
+
     template<>
     inline bool try_lock<pthread_mutex_t>(pthread_mutex_t& lockable) {
         return pthread_mutex_trylock(&lockable);
@@ -124,7 +111,7 @@
         {
             synchro::unlock(m);
         }
-    };    
+    };
 
     template<typename Mutex>
     class lock_guard_if
@@ -150,8 +137,8 @@
         {
             if (cnd_) synchro::unlock(m);
         }
-    };    
-    
+    };
+
     template<typename Mutex>
     class unique_lock
     {
@@ -164,13 +151,13 @@
         unique_lock():
             m(0),is_locked(false)
         {}
-        
+
         explicit unique_lock(Mutex& m_):
             m(&m_),is_locked(false)
         {
             lock();
         }
-        
+
         unique_lock(Mutex& m_,adopt_lock_t):
             m(&m_),is_locked(true)
         {}
@@ -187,7 +174,7 @@
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
-        
+
         ~unique_lock()
         {
             if(owns_lock())
@@ -222,7 +209,7 @@
             synchro::unlock(*m);
             is_locked=false;
         }
-            
+
         typedef void (unique_lock::*bool_type)();
         operator bool_type() const
         {
@@ -255,7 +242,7 @@
     void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
     {
         lhs.swap(rhs);
-    }   
+    }
 }
 #endif
 namespace stm {

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-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -30,6 +30,7 @@
 //-----------------------------------------------------------------------------
 #include <boost/stm/base_transaction.hpp>
 #include <boost/stm/transaction_bookkeeping.hpp>
+#include <boost/synchro/tss.hpp>
 //-----------------------------------------------------------------------------
 #include <boost/stm/detail/datatypes.hpp>
 #include <boost/stm/detail/deleters.hpp>
@@ -130,8 +131,10 @@
    typedef std::list<detail::deleter_type*> MemoryContainerList;
 #endif
 
+   struct transaction_tss_storage {
+       TransactionsStack transactions_;
+   };
 
-   typedef std::map<size_t, TransactionsStack*> ThreadTransactionsStack;
    typedef std::map<size_t, WriteContainer*> ThreadWriteContainer;
    typedef std::map<size_t, TxType*> ThreadTxTypeContainer;
 
@@ -199,7 +202,6 @@
     {
         inline tss_context()
         : tx_()
-        , transactions_()
         #ifndef BOOST_STM_USE_BOOST_MUTEX
         #if WIN32
         , mutex_(PTHREAD_MUTEX_INITIALIZER)
@@ -212,8 +214,6 @@
         , blocked_(false)
         #endif
         {
-            // the current transaction is 0
-            transactions_.push(0);
             #ifndef BOOST_STM_USE_BOOST_MUTEX
             pthread_mutex_init(&mutex_, 0);
             #endif
@@ -223,7 +223,6 @@
         }
 
         tx_context tx_;
-        TransactionsStack transactions_;
         Mutex mutex_;
         #if PERFORMING_LATM
         int blocked_;
@@ -1050,7 +1049,7 @@
       else
       {
          in.transaction_thread(threadId_);
-          
+
          //unlock(&transactionMutex_);
          lock_m.unlock();
          // is this really necessary? in the deferred case it is, but in direct it
@@ -1195,7 +1194,7 @@
          //unlock_tx();
          lock.unlock();
 #else
-         
+
 #endif
 #if PERFORMING_WRITE_BLOOM
          wbloom().set_bv1(bloom().h1());
@@ -1672,20 +1671,6 @@
    inline static MutexSet &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
 #endif
 
-    static ThreadTransactionsStack threadTransactionsStack_;
-    TransactionsStack& transactionsRef_;
-   public:
-    inline TransactionsStack& transactions() {return transactionsRef_;}
-    inline static TransactionsStack &transactions(thread_id_t id) {
-        synchro::lock_guard<Mutex> auto_general_lock_(*general_lock());
-        return *threadTransactionsStack_.find(id)->second;
-    }
-    inline static TransactionsStack &transactions_unsafe(thread_id_t id) {
-        //synchro::lock_guard<Mutex> auto_general_lock_(*general_lock());
-        return *threadTransactionsStack_.find(id)->second;
-    }
-    private:
-
 
 ////////////////////////////////////////
 #else //BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP
@@ -1844,24 +1829,8 @@
     }
 #endif
 
-    TransactionsStack& transactionsRef_;
-   public:
-    inline TransactionsStack& transactions() {return transactionsRef_;}
-    inline static TransactionsStack &transactions(thread_id_t id) {
-        synchro::lock_guard<Mutex> auto_general_lock_(*general_lock());
-        tss_context_map_type::iterator i = tss_context_map_.find(id);
-        return i->second->transactions_;
-    }
-    inline static TransactionsStack &transactions_unsafe(thread_id_t id) {
-        tss_context_map_type::iterator i = tss_context_map_.find(id);
-        return i->second->transactions_;
-    }
-   private:
-
 #endif
 
-
-
 ////////////////////////////////////////
 #else   // USE_SINGLE_THREAD_CONTEXT_MAP
 ////////////////////////////////////////
@@ -1998,23 +1967,15 @@
    inline static MutexSet &currentlyLockedLocksRef(thread_id_t id) {return *threadCurrentlyLockedLocks_.find(id)->second;}
 #endif
 
-    static ThreadTransactionsStack threadTransactionsStack_;
-    TransactionsStack& transactionsRef_;
-   public:
-    inline TransactionsStack& transactions() {return transactionsRef_;}
-    inline static TransactionsStack &transactions(thread_id_t id) {
-        synchro::lock_guard<Mutex> auto_general_lock_(*general_lock());
-        return *threadTransactionsStack_.find(id)->second;
-    }
-    inline static TransactionsStack &transactions_unsafe(thread_id_t id) {
-        return *threadTransactionsStack_.find(id)->second;
-    }
-    private:
 
 ////////////////////////////////////////
 #endif
 
 
+    static synchro::implicit_thread_specific_ptr<transaction_tss_storage> transaction_tss_storage_;
+    transaction_tss_storage & transaction_tss_storage_ref_;
+   public:
+    inline TransactionsStack& transactions() {return transaction_tss_storage_ref_.transactions_;}
 
    // transaction specific data
    //int hasMutex_; // bool - 1 bit
@@ -2031,8 +1992,7 @@
     #endif
 
 public:
-    inline static transaction* current_transaction() {return transactions(THREAD_ID).top();}
-
+    inline static transaction* current_transaction() {return transaction_tss_storage_->transactions_.top();}
 
 };
 

Modified: sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/synchro/pthread/mutex.hpp	2009-10-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -16,6 +16,7 @@
 
 //-----------------------------------------------------------------------------
 #include <pthread.h>
+#include <assert.h>
 //-----------------------------------------------------------------------------
 #include <boost/synchro/detail/config.hpp>
 //-----------------------------------------------------------------------------
@@ -28,15 +29,15 @@
 
     template<>
     inline void lock<pthread_mutex_t>(pthread_mutex_t& lockable) {
-        //int const res=
-        pthread_mutex_lock(&lockable);
+        int const res = pthread_mutex_lock(&lockable);
+        assert(res==0);
         //if (res!=0) throw lock_error();
     }
 
     template<>
     inline void unlock<pthread_mutex_t>(pthread_mutex_t& lockable) {
-        //int const res=
-        pthread_mutex_unlock(&lockable);
+        int const res= pthread_mutex_unlock(&lockable);
+        assert(res==0);
         //if (res!=0) throw lock_error();
     }
 
@@ -53,7 +54,7 @@
                 pthread_mutex_t& lockable, system_time const& abs_time) {
         struct timespec const timeout=detail::get_timespec(abs_time);
         int const res=pthread_mutex_timedlock(&lockable,&timeout);
-        //BOOST_ASSERT(!res || res==ETIMEDOUT);
+        assert(!res || res==ETIMEDOUT);
         return !res;
     }   
 #endif

Added: sandbox/stm/branches/vbe/boost/synchro/tss.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/synchro/tss.hpp	2009-10-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -0,0 +1,101 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// Distributed under the Boost
+// Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHO_TSS_HPP
+#define BOOST_SYNCHO_TSS_HPP
+
+//-----------------------------------------------------------------------------
+#include "pthread.h"
+//-----------------------------------------------------------------------------
+#include <boost/synchro/lockers/lock_guard.hpp>
+#include <boost/synchro/pthread/mutex.hpp>
+//-----------------------------------------------------------------------------
+
+namespace boost { namespace synchro {
+
+    template <typename T>
+    class implicit_thread_specific_ptr
+    {
+    private:
+        implicit_thread_specific_ptr(implicit_thread_specific_ptr&);
+        implicit_thread_specific_ptr& operator=(implicit_thread_specific_ptr&);
+
+        typedef pthread_mutex_t mutex_type;
+        // Key that uniquely identifies the 'logically global' object that
+        // 'physically' resides locally in thread-specific storage.
+        mutable pthread_key_t key_;
+
+        // "First time in" flag
+        mutable bool once_;
+
+
+        // Avoid race conditions during initialization.
+        mutable mutex_type keylock_;
+
+        // A static cleanup hook method that deletes dynamically allocated memory.
+        static void cleanup_hook (void *ptr) {
+            // This cast invokes the destructor (if one exists).
+            delete (T*) ptr;
+        }
+
+    public:
+        implicit_thread_specific_ptr()
+            : key_(0) , once_ (false)
+        {
+            int const res=pthread_mutex_init(&keylock_,0);
+            assert(res==0);
+            //if(res) throw thread_resource_error();
+        }
+        ~implicit_thread_specific_ptr() {
+            int const res=pthread_mutex_destroy(&keylock_);
+            assert(res==0);
+        }
+
+        T* get() const {
+            T *tss_data = 0;
+            // Use the Double-Checked Locking Optimization pattern to avoid excessive locking.
+            if (!once_) {
+                // Use Scoped Locking idiom to ensure <keylock_>
+                // is acquired to serialize critical section.
+                synchro::lock_guard<mutex_type> guard (keylock_);
+                if (!once_) {
+                    pthread_key_create (&key_, &cleanup_hook);
+                    // Must come last so that other threads don't use the key until it's created.
+                    once_ = true;
+                }
+                // <Guard> destructor releases the lock.
+            }
+            // Get data from thread-specific storage. Note that no locks are required,
+            // because this thread's own copy of the thread-specific object will be accessed.
+            tss_data = static_cast<T*>(pthread_getspecific (key_));
+            // Check if it's the first time in for this thread.
+            if (tss_data == 0) {
+                // Allocate memory dynamically off the heap,
+                tss_data = new T;
+                // Store pointer in thread-specific storage.
+                pthread_setspecific (key_, (void *)tss_data);
+            }
+            return tss_data;
+        }
+        T* operator->() const
+        {
+            return get();
+        }
+        T& operator*() const
+        {
+            return *get();
+        }
+    };
+}}
+#endif // BOOST_SYNCHO_TAGS_HPP
+

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-18 19:03:02 EDT (Sun, 18 Oct 2009)
@@ -24,6 +24,8 @@
 
 }
 
+synchro::implicit_thread_specific_ptr<transaction::transaction_tss_storage> transaction::transaction_tss_storage_;
+
 ///////////////////////////////////////////////////////////////////////////////
 // Static initialization
 ///////////////////////////////////////////////////////////////////////////////
@@ -33,9 +35,6 @@
 transaction::MutexThreadMap transaction::latmLockedLocksOfThreadMap_;
 transaction::MutexSet transaction::tmConflictingLocks_;
 transaction::DeletionBuffer transaction::deletionBuffer_;
-#ifndef BOOST_STM_HAVE_SINGLE_TSS_CONTEXT_MAP
-transaction::ThreadTransactionsStack transaction::threadTransactionsStack_;
-#endif
 
 size_t transaction::global_clock_ = 0;
 size_t transaction::stalls_ = 0;
@@ -235,11 +234,6 @@
       threadCurrentlyLockedLocks_[threadId] = new MutexSet;
    }
 #endif
-   ThreadTransactionsStack::iterator transactionsdIter = threadTransactionsStack_.find(threadId);
-   if (threadTransactionsStack_.end() == transactionsdIter)
-   {
-      threadTransactionsStack_[threadId] = new TransactionsStack;
-   }
 
    ThreadBoolContainer::iterator blockedIter = threadBlockedLists_.find(threadId);
 
@@ -334,12 +328,6 @@
    }
 #endif
 
-   ThreadTransactionsStack::iterator transactionsdIter = threadTransactionsStack_.find(threadId);
-   if (threadTransactionsStack_.end() == transactionsdIter)
-   {
-      threadTransactionsStack_[threadId] = new TransactionsStack;
-   }
-
    if (threadMutexes_.end() == mutexIter)
    {
       Mutex *mutex = new Mutex;