[Boost-commit] svn:boost r55689 - in sandbox/fmhess: boost/generic_ptr libs/generic_ptr/test

Subject: [Boost-commit] svn:boost r55689 - in sandbox/fmhess: boost/generic_ptr libs/generic_ptr/test
From: fmhess_at_[hidden]
Date: 2009-08-20 14:51:52

Author: fmhess
Date: 2009-08-20 14:51:51 EDT (Thu, 20 Aug 2009)
New Revision: 55689
URL: http://svn.boost.org/trac/boost/changeset/55689

Log:
Optimized generic_ptr::cloning to only perform a single heap
allocation on copying.  generic_ptr::cloning no longer takes 
ownership of the pointer it was initially constructed from.

Text files modified: 
   sandbox/fmhess/boost/generic_ptr/cloning.hpp          |   111 ++++++++++++++++++++++++++++----------- 
   sandbox/fmhess/boost/generic_ptr/monitor.hpp          |     8 +-                                      
   sandbox/fmhess/libs/generic_ptr/test/cloning_test.cpp |    81 ++++++++++++----------------            
   3 files changed, 118 insertions(+), 82 deletions(-)

Modified: sandbox/fmhess/boost/generic_ptr/cloning.hpp
==============================================================================
--- sandbox/fmhess/boost/generic_ptr/cloning.hpp	(original)
+++ sandbox/fmhess/boost/generic_ptr/cloning.hpp	2009-08-20 14:51:51 EDT (Thu, 20 Aug 2009)
@@ -15,6 +15,7 @@
 #define BOOST_GENERIC_PTR_CLONING_HPP_INCLUDED
 
 #include <boost/config.hpp>
+#include <boost/aligned_storage.hpp>
 #include <boost/generic_ptr/detail/util.hpp>
 #include <boost/generic_ptr/pointer_cast.hpp>
 #include <boost/generic_ptr/pointer_traits.hpp>
@@ -23,8 +24,10 @@
 #include <boost/noncopyable.hpp>
 #include <boost/ptr_container/clone_allocator.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <boost/type_traits/alignment_of.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/addressof.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/utility/swap.hpp>
 
@@ -33,16 +36,45 @@
   namespace generic_ptr
   {
     template<typename T>
-    T* new_clone(T *p)
+    T* construct_clone(void *location, T *p)
     {
       if(p == 0) return 0;
-      using boost::new_clone;
-      return new_clone(*p);
+      // based on boost::new_clone
+      T* result = new(location) T(*p);
+      BOOST_ASSERT
+      (
+        typeid(*p) == typeid(*result) &&
+        "Default construct_clone() sliced object!"
+      );
+      return result;
     }
     template<typename GenericPointer>
-    GenericPointer new_clone(const GenericPointer &p, typename pointer_traits<GenericPointer>::value_type * = 0)
+    GenericPointer construct_clone
+    (
+      void *location,
+      const GenericPointer &p,
+      typename pointer_traits<GenericPointer>::value_type * = 0
+    )
     {
-      return GenericPointer(new_clone(get_pointer(p)));
+      return GenericPointer(construct_clone(location, get_pointer(p)));
+    }
+    template<typename T>
+    void destroy_clone(T *p)
+    {
+      if(p == 0) return;
+      // make sure type is complete: based on boost::checked_delete
+      typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+      (void) sizeof(type_must_be_complete);
+      p->~T();
+    }
+    template<typename GenericPointer>
+    void destroy_clone
+    (
+      const GenericPointer &p,
+      typename pointer_traits<GenericPointer>::value_type * = 0
+    )
+    {
+      return destroy_clone(get_pointer(p));
     }
 
     namespace detail
@@ -56,19 +88,21 @@
         virtual clone_factory_impl_base* make_clone() = 0;
       };
 
-      template<typename GenericPointer, typename Deleter, typename Cloner>
-      class clone_factory_pdc_impl: public
+      template<typename GenericPointer, typename Cloner>
+      class clone_factory_impl: public
         clone_factory_impl_base
         <
           typename rebind<GenericPointer, void>::other
         >
       {
       public:
-        clone_factory_pdc_impl(GenericPointer p, Deleter d, Cloner c): px(p), deleter(d), cloner(c)
+        clone_factory_impl(GenericPointer p, Cloner c):
+          cloner(c),
+          px(cloner.allocate_clone(p))
         {}
-        ~clone_factory_pdc_impl()
+        ~clone_factory_impl()
         {
-          deleter(px);
+          cloner.deallocate_clone(px);
         }
         virtual typename rebind<GenericPointer, void>::other get_pointer()
         {
@@ -80,14 +114,13 @@
               >::type
             >(px);
         }
-        virtual clone_factory_pdc_impl* make_clone()
+        virtual clone_factory_impl* make_clone()
         {
-          return new clone_factory_pdc_impl(cloner(px), deleter, cloner);
+          return new clone_factory_impl(px, cloner);
         }
       private:
-        GenericPointer px;
-        Deleter deleter;
         Cloner cloner;
+        GenericPointer px;
       };
 
       template<typename GenericVoidPointer>
@@ -96,8 +129,8 @@
       public:
         clone_factory(): _impl()
         {}
-        template<typename T, typename Deleter, typename Cloner>
-        clone_factory(T p, Deleter d, Cloner c): _impl(new clone_factory_pdc_impl<T, Deleter, Cloner>(p, d, c))
+        template<typename T, typename Cloner>
+        clone_factory(T p, Cloner c): _impl(new clone_factory_impl<T, Cloner>(p, c))
         {}
         clone_factory(const clone_factory &other): _impl(other._impl->make_clone())
         {}
@@ -128,25 +161,40 @@
       }
     }
 
-    class default_cloning_deleter
+    template<typename T>
+    class default_cloner
     {
     public:
+      default_cloner(): _allocated(false)
+      {}
+      default_cloner(const default_cloner &): _allocated(false)
+      {}
+      default_cloner & operator=(const default_cloner &)
+      {}
       template<typename GenericPointer>
-      void operator()(const GenericPointer &p) const
+      GenericPointer allocate_clone(const GenericPointer & p)
       {
-        delete_clone(get_plain_old_pointer(p));
+        BOOST_ASSERT(_allocated == false);
+        using boost::generic_ptr::construct_clone;
+        GenericPointer result(construct_clone(storage(), p));
+        _allocated = true;
+        return result;
       }
-    };
-
-    class default_cloner
-    {
-    public:
       template<typename GenericPointer>
-      GenericPointer operator()(const GenericPointer & p) const
+      void deallocate_clone(const GenericPointer & p)
       {
-        if(get_plain_old_pointer(p) == 0) return p;
-        return new_clone(p);
+        typename pointer_traits<GenericPointer>::value_type *pop = get_plain_old_pointer(p);
+        if(pop == 0) return;
+        BOOST_ASSERT(pop == storage());
+        BOOST_ASSERT(_allocated);
+        _allocated = false;
+        using boost::generic_ptr::destroy_clone;
+        destroy_clone(p);
       }
+    private:
+      void * storage() {return boost::addressof(_storage);}
+      boost::aligned_storage<sizeof(T), boost::alignment_of<T>::value> _storage;
+      bool _allocated;
     };
 
     template<typename T>
@@ -180,8 +228,7 @@
         _clone_factory
         (
           typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
-          default_cloning_deleter(),
-          default_cloner()
+          default_cloner<typename pointer_traits<U>::value_type>()
         ),
         px
         (
@@ -201,8 +248,7 @@
         _clone_factory
         (
           typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
-          default_cloning_deleter(),
-          default_cloner()
+          default_cloner<typename pointer_traits<U>::value_type>()
         ),
         px
         (
@@ -223,7 +269,7 @@
         (
           typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
           d,
-          default_cloner()
+          default_cloner<typename pointer_traits<U>::value_type>()
         ),
         px
         (
@@ -238,7 +284,6 @@
         _clone_factory
         (
           typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
-          d,
           c
         ),
         px

Modified: sandbox/fmhess/boost/generic_ptr/monitor.hpp
==============================================================================
--- sandbox/fmhess/boost/generic_ptr/monitor.hpp	(original)
+++ sandbox/fmhess/boost/generic_ptr/monitor.hpp	2009-08-20 14:51:51 EDT (Thu, 20 Aug 2009)
@@ -247,14 +247,14 @@
       return std::less<typename monitor<T, Mutex>::pointer>()(a.get(), b.get());
     }
 
-    // new_clone overload for safe (mutex locked) use with generic_ptr::cloning
+    // construct_clone overload for safe (mutex locked) use with generic_ptr::cloning
     template<typename GenericPointer, typename Mutex>
-    monitor<GenericPointer, Mutex> new_clone(const monitor<GenericPointer, Mutex> &p)
+    monitor<GenericPointer, Mutex> construct_clone(void *location, const monitor<GenericPointer, Mutex> &p)
     {
       if(get_plain_old_pointer(p) == 0) return p;
       monitor_unique_lock<monitor<GenericPointer, Mutex> > lock(p);
-      using boost::generic_ptr::new_clone;
-      return monitor<GenericPointer, Mutex>(new_clone(p.get()));
+      using boost::generic_ptr::construct_clone;
+      return monitor<GenericPointer, Mutex>(construct_clone(location, p.get()));
     }
   } // namespace generic_ptr
 } // namespace boost

Modified: sandbox/fmhess/libs/generic_ptr/test/cloning_test.cpp
==============================================================================
--- sandbox/fmhess/libs/generic_ptr/test/cloning_test.cpp	(original)
+++ sandbox/fmhess/libs/generic_ptr/test/cloning_test.cpp	2009-08-20 14:51:51 EDT (Thu, 20 Aug 2009)
@@ -43,54 +43,61 @@
 void clone_test()
 {
   BOOST_TEST(X::instances == 0);
-  boost::generic_ptr::cloning<X*> cp(new X());
+  X obj;
   BOOST_TEST(X::instances == 1);
-  boost::generic_ptr::cloning<X*> cp2(cp);
+  boost::generic_ptr::cloning<X*> cp(&obj);
   BOOST_TEST(X::instances == 2);
+  boost::generic_ptr::cloning<X*> cp2(cp);
+  BOOST_TEST(X::instances == 3);
   BOOST_TEST(cp != cp2);
   boost::generic_ptr::cloning<const X*> cp3;
-  BOOST_TEST(X::instances == 2);
-  cp3 = cp2;
   BOOST_TEST(X::instances == 3);
+  cp3 = cp2;
+  BOOST_TEST(X::instances == 4);
   BOOST_TEST(cp3->num_instances() == X::instances);
   BOOST_TEST(cp2 != cp3);
 
-  const X* p_to_const = new X();
-  cp3.reset(p_to_const);
-  BOOST_TEST(X::instances == 3);
+  {
+    const X const_obj;
+    cp3.reset(&const_obj);
+  }
+  BOOST_TEST(X::instances == 4);
 }
 
 void move_test()
 {
 #ifndef BOOST_NO_RVALUE_REFERENCES
   BOOST_TEST(X::instances == 0);
-  X * plain_x = new X();
-  boost::generic_ptr::cloning<X*> cp(plain_x);
+  X plain_x;
   BOOST_TEST(X::instances == 1);
-  BOOST_TEST(cp == plain_x);
+  boost::generic_ptr::cloning<X*> cp(&plain_x);
+  X* original_p = cp.get();
+  BOOST_TEST(X::instances == 2);
   boost::generic_ptr::cloning<X*> cp2(std::move(cp));
-  BOOST_TEST(X::instances == 1);
+  BOOST_TEST(X::instances == 2);
   BOOST_TEST(cp.get() == 0);
-  BOOST_TEST(cp2 == plain_x);
+  BOOST_TEST(cp2 == original_p);
   boost::generic_ptr::cloning<X*> cp3;
   cp3 = std::move(cp2);
-  BOOST_TEST(X::instances == 1);
-  BOOST_TEST(cp3 == plain_x);
+  BOOST_TEST(X::instances == 2);
+  BOOST_TEST(cp3 == original_p);
 #endif // BOOST_NO_RVALUE_REFERENCES
 }
 
 void no_slice_test()
 {
   BOOST_TEST(X::instances == 0);
-  boost::generic_ptr::cloning<X*> cp(new X());
+  X obj;
   BOOST_TEST(X::instances == 1);
-  boost::generic_ptr::cloning<X_base*> cp2(cp);
+  boost::generic_ptr::cloning<X*> cp(&obj);
   BOOST_TEST(X::instances == 2);
+  boost::generic_ptr::cloning<X_base*> cp2(cp);
+  BOOST_TEST(X::instances == 3);
   BOOST_TEST(cp != cp2);
   boost::generic_ptr::cloning<X_base*> cp3;
-  BOOST_TEST(X::instances == 2);
-  cp3 = cp;
   BOOST_TEST(X::instances == 3);
+  cp3 = cp;
+  BOOST_TEST(X::instances == 4);
   BOOST_TEST(cp3->f() == 0);
   BOOST_TEST(cp != cp3);
 }
@@ -98,46 +105,31 @@
 void cast_test()
 {
   BOOST_TEST(X::instances == 0);
-  boost::generic_ptr::cloning<X_base*> cp(new X());
+  X obj;
   BOOST_TEST(X::instances == 1);
-  boost::generic_ptr::cloning<X*> cp2 = boost::generic_ptr::static_pointer_cast<X>(cp);
+  boost::generic_ptr::cloning<X_base*> cp(&obj);
   BOOST_TEST(X::instances == 2);
+  boost::generic_ptr::cloning<X*> cp2 = boost::generic_ptr::static_pointer_cast<X>(cp);
+  BOOST_TEST(X::instances == 3);
   BOOST_TEST(cp != cp2);
   boost::generic_ptr::cloning<X_base*> cp3(boost::generic_ptr::static_pointer_cast<X_base>(cp2));
-  BOOST_TEST(X::instances == 3);
+  BOOST_TEST(X::instances == 4);
   BOOST_TEST(cp2 != cp3);
 }
 
-void deleter_test()
-{
-  BOOST_TEST(X::instances == 0);
-  X *x0 = new X();
-  X *x1 = 0;
-  {
-    boost::generic_ptr::cloning<X*> cp0(x0, boost::generic_ptr::null_deleter());
-    BOOST_TEST(X::instances == 1);
-    {
-      boost::generic_ptr::cloning<X*> cp1(cp0);
-      BOOST_TEST(X::instances == 2);
-      x1 = get_plain_old_pointer(cp1);
-    }
-    BOOST_TEST(X::instances == 2);
-  }
-  BOOST_TEST(X::instances == 2);
-  using boost::delete_clone;
-  delete_clone(x0);
-  delete_clone(x1);
-  BOOST_TEST(X::instances == 0);
-}
-
 class null_cloner
 {
 public:
   template<typename GenericPointer>
-  GenericPointer operator()(const GenericPointer &p)
+  GenericPointer allocate_clone(const GenericPointer &p)
   {
     return p;
   }
+  template<typename GenericPointer>
+  void deallocate_clone(const GenericPointer &p)
+  {
+    return;
+  }
 };
 
 void custom_cloner_test()
@@ -162,7 +154,6 @@
   move_test();
   no_slice_test();
   cast_test();
-  deleter_test();
   custom_cloner_test();
   return boost::report_errors();
 }