[Boost-commit] svn:boost r50252 - in sandbox/thread_safe_signals/trunk/boost/signals2: . detail

Subject: [Boost-commit] svn:boost r50252 - in sandbox/thread_safe_signals/trunk/boost/signals2: . detail
From: fmhess_at_[hidden]
Date: 2008-12-12 16:34:59

Author: fmhess
Date: 2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
New Revision: 50252
URL: http://svn.boost.org/trac/boost/changeset/50252

Log:
Opimized speed with respect to automatic tracking overhead
during signal invocation.

Added:
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/null_output_iterator.hpp   (contents, props changed)
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_allocator.hpp   (contents, props changed)
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_vector.hpp   (contents, props changed)
Text files modified: 
   sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp                |    31 +++++++++++++++++--------------         
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp    |     4 ++--                                    
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp |    26 ++++++++++++++++++--------              
   3 files changed, 37 insertions(+), 24 deletions(-)

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -18,12 +18,12 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
-#include <boost/signals2/slot.hpp>
+#include <boost/signals2/detail/null_output_iterator.hpp>
 #include <boost/signals2/detail/unique_lock.hpp>
+#include <boost/signals2/slot.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/visit_each.hpp>
 #include <boost/weak_ptr.hpp>
-#include <vector>
 
 namespace boost
 {
@@ -93,7 +93,7 @@
         virtual bool connected() const
         {
           unique_lock<mutex_type> lock(_mutex);
-          nolock_grab_tracked_objects();
+          nolock_grab_tracked_objects(detail::null_output_iterator());
           return nolock_nograb_connected();
         }
         const GroupKey& group_key() const {return _group_key;}
@@ -107,19 +107,22 @@
           }
           return expired;
         }
-        typename slot_base::locked_container_type nolock_grab_tracked_objects() const
+        template<typename OutputIterator>
+          void nolock_grab_tracked_objects(OutputIterator inserter) const
         {
-          slot_base::locked_container_type locked_objects;
-          try
-          {
-            locked_objects = slot.lock();
-          }
-          catch(const expired_slot &)
-          {
-            _connected = false;
-            return locked_objects;
+            slot_base::tracked_container_type::const_iterator it;
+            for(it = slot.tracked_objects().begin();
+              it != slot.tracked_objects().end();
+              ++it)
+            {
+              boost::shared_ptr<void> locked_object = it->lock();
+              if(!locked_object)
+              {
+                _connected = false;
+                return;
+              }
+              *inserter++ = it->lock();
           }
-          return locked_objects;
         }
         // expose Lockable concept of mutex
         virtual void lock()

Added: sandbox/thread_safe_signals/trunk/boost/signals2/detail/null_output_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/null_output_iterator.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -0,0 +1,34 @@
+/*
+  An output iterator which simply discards output.
+*/
+// Copyright Frank Mori Hess 2008.
+// 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/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP
+#define BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP
+
+#include <boost/function_output_iterator.hpp>
+
+namespace boost
+{
+  namespace signals2
+  {
+    namespace detail
+    {
+      class does_nothing
+      {
+      public:
+        template<typename T>
+          void operator()(const T&) const
+          {}
+      };
+      typedef boost::function_output_iterator<does_nothing> null_output_iterator;
+    } // namespace detail
+  } // namespace signals2
+} // namespace boost
+
+#endif  // BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -262,7 +262,7 @@
           }
           slot_invoker invoker BOOST_PP_IF(BOOST_SIGNALS_NUM_ARGS, \
             (BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)), );
-          optional<slot_result_type> cache;
+          slot_call_iterator_cache<slot_result_type> cache;
           return local_state->combiner(
             slot_call_iterator(local_state->connection_bodies.begin(), local_state->connection_bodies.end(), invoker, cache),
             slot_call_iterator(local_state->connection_bodies.end(), local_state->connection_bodies.end(), invoker, cache));
@@ -283,7 +283,7 @@
           }
           slot_invoker invoker BOOST_PP_IF(BOOST_SIGNALS_NUM_ARGS, \
             (BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)), );
-          optional<slot_result_type> cache;
+          slot_call_iterator_cache<slot_result_type> cache;
           return const_cast<const combiner_type&>(local_state->combiner)(
             slot_call_iterator(local_state->connection_bodies.begin(), local_state->connection_bodies.end(), invoker, cache),
             slot_call_iterator(local_state->connection_bodies.end(), local_state->connection_bodies.end(), invoker, cache));

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -19,6 +19,7 @@
 #include <boost/scoped_ptr.hpp>
 #include <boost/signals2/connection.hpp>
 #include <boost/signals2/slot_base.hpp>
+#include <boost/signals2/detail/stack_vector.hpp>
 #include <boost/signals2/detail/unique_lock.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/weak_ptr.hpp>
@@ -26,6 +27,15 @@
 namespace boost {
   namespace signals2 {
     namespace detail {
+      template<typename ResultType>
+        class slot_call_iterator_cache
+      {
+      public:
+        optional<ResultType> result;
+        typedef stack_vector<boost::shared_ptr<void>, 10> tracked_ptrs_type;
+        tracked_ptrs_type tracked_ptrs;
+      };
+
       // Generates a slot call iterator. Essentially, this is an iterator that:
       //   - skips over disconnected slots in the underlying list
       //   - calls the connected slots when dereferenced
@@ -49,7 +59,7 @@
 
       public:
         slot_call_iterator_t(Iterator iter_in, Iterator end_in, Function f,
-          boost::optional<result_type> &c):
+          slot_call_iterator_cache<result_type> &c):
           iter(iter_in), end(end_in), f(f),
           cache(&c), callable_iter(end_in)
         {
@@ -59,10 +69,10 @@
         typename inherited::reference
         dereference() const
         {
-          if (!(*cache)) {
+          if (!cache->result) {
             try
             {
-              cache->reset(f(*iter));
+              cache->result.reset(f(*iter));
             }
             catch(expired_slot &)
             {
@@ -70,14 +80,14 @@
               throw;
             }
           }
-          return cache->get();
+          return cache->result.get();
         }
 
         void increment()
         {
           ++iter;
           lock_next_callable();
-          cache->reset();
+          cache->result.reset();
         }
 
         bool equal(const slot_call_iterator_t& other) const
@@ -97,7 +107,8 @@
           for(;iter != end; ++iter)
           {
             lock_type lock(**iter);
-            tracked_ptrs = (*iter)->nolock_grab_tracked_objects();
+            cache->tracked_ptrs.clear();
+            (*iter)->nolock_grab_tracked_objects(std::back_inserter(cache->tracked_ptrs));
             if((*iter)->nolock_nograb_blocked() == false)
             {
               callable_iter = iter;
@@ -113,9 +124,8 @@
         mutable Iterator iter;
         Iterator end;
         Function f;
-        optional<result_type>* cache;
+        slot_call_iterator_cache<result_type> *cache;
         mutable Iterator callable_iter;
-        mutable typename slot_base::locked_container_type tracked_ptrs;
       };
     } // end namespace detail
   } // end namespace BOOST_SIGNALS_NAMESPACE

Added: sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_allocator.hpp
==============================================================================
--- (empty file)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_allocator.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -0,0 +1,90 @@
+/*
+	An allocator which first allocates from the stack, before falling
+	back on usual std::allocator behavior.  Used by signals2 to
+	optimize the vector of tracked shared_ptr created during signal
+	invocation.
+
+	Example usage:
+
+	static const std::size_t n = 10;
+	stack_storage<T, n> storage;
+	stack_allocator<T, n> a(&storage);
+	std::vector<T, stack_allocator<T, n> > v(a);
+
+*/
+// Copyright Frank Mori Hess 2008.
+// 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/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_STACK_ALLOCATOR_HPP
+#define BOOST_SIGNALS2_STACK_ALLOCATOR_HPP
+
+#include <memory>
+#include <boost/noncopyable.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+namespace boost
+{
+  namespace signals2
+  {
+    namespace detail
+    {
+      template<typename T, std::size_t n_stack_elements>
+        class stack_storage: public boost::noncopyable
+      {
+      public:
+        typedef typename boost::aligned_storage<sizeof(T), boost::alignment_of<T>::value>::type storage_type;
+        stack_storage(): is_reserved(false)
+        {
+        }
+        storage_type array[n_stack_elements];
+        bool is_reserved;
+      };
+      template<typename T, std::size_t n_stack_elements>
+        class stack_allocator: public std::allocator<T>
+      {
+        typedef std::allocator<T> base_class;
+      public:
+        template<typename U>
+          struct rebind
+        {
+          typedef stack_allocator<U, n_stack_elements> other;
+        };
+        stack_allocator(stack_storage<T, n_stack_elements> *storage = 0):
+          _storage(storage)
+        {
+        }
+        typename base_class::pointer allocate(typename base_class::size_type n_elements,
+          std::allocator<void>::const_pointer hint = 0)
+        {
+          if(_storage && _storage->is_reserved == false &&
+            n_elements <= n_stack_elements)
+          {
+            _storage->is_reserved = true;
+            return reinterpret_cast<typename base_class::pointer>(&_storage->array[0]);
+          }
+          return base_class::allocate(n_elements, hint);
+        }
+        void deallocate(typename base_class::pointer p, typename base_class::size_type n)
+        {
+          if(_storage &&
+            p == reinterpret_cast<typename base_class::pointer>(&_storage->array[0]))
+          {
+            _storage->is_reserved = false;
+          }else
+          {
+            base_class::deallocate(p, n);
+          }
+        }
+      private:
+        stack_storage<T, n_stack_elements> *_storage;
+      };
+    } // namespace detail
+  } // namespace signals2
+} // namespace boost
+
+#endif  // BOOST_SIGNALS2_STACK_ALLOCATOR_HPP

Added: sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_vector.hpp
==============================================================================
--- (empty file)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/stack_vector.hpp	2008-12-12 16:34:58 EST (Fri, 12 Dec 2008)
@@ -0,0 +1,48 @@
+/*
+	A non-copyable vector which first allocates from the stack, before falling
+	back on usual std::allocator behavior.
+
+*/
+// Copyright Frank Mori Hess 2008.
+// 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/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_STACK_VECTOR_HPP
+#define BOOST_SIGNALS2_STACK_VECTOR_HPP
+
+#include <boost/noncopyable.hpp>
+#include <boost/signals2/detail/stack_allocator.hpp>
+#include <vector>
+
+namespace boost
+{
+  namespace signals2
+  {
+    namespace detail
+    {
+      template<typename T, std::size_t NumStackElements>
+        class stack_vector:
+        public std::vector<T, stack_allocator<T, NumStackElements> >,
+        public boost::noncopyable
+      {
+        typedef std::vector<T, stack_allocator<T, NumStackElements> > base_vector_type;
+      public:
+        static const std::size_t num_stack_elements = NumStackElements;
+        stack_vector(): base_vector_type(stack_allocator<T, num_stack_elements>(&_storage))
+        {
+          base_vector_type::reserve(num_stack_elements);
+        }
+      private:
+        stack_storage<T, num_stack_elements> _storage;
+      };
+      template<typename T, std::size_t NumStackElements>
+        const std::size_t stack_vector<T, NumStackElements>::num_stack_elements;
+
+    } // namespace detail
+  } // namespace signals2
+} // namespace boost
+
+#endif  // BOOST_SIGNALS2_STACK_VECTOR_HPP