[Boost-commit] svn:boost r78454 - sandbox/pool/boost/pool

Subject: [Boost-commit] svn:boost r78454 - sandbox/pool/boost/pool
From: svart.riddare_at_[hidden]
Date: 2012-05-13 12:41:26

Author: edupuis
Date: 2012-05-13 12:41:26 EDT (Sun, 13 May 2012)
New Revision: 78454
URL: http://svn.boost.org/trac/boost/changeset/78454

Log:
Added methods release_memory() and purge_memory() to object_pool. This complete and fixes #6610, as the remaining part of this ticket was addressed by #3789.
Text files modified: 
   sandbox/pool/boost/pool/object_pool.hpp |   124 ++++++++++++++++++++++++--------------- 
   1 files changed, 75 insertions(+), 49 deletions(-)

Modified: sandbox/pool/boost/pool/object_pool.hpp
==============================================================================
--- sandbox/pool/boost/pool/object_pool.hpp	(original)
+++ sandbox/pool/boost/pool/object_pool.hpp	2012-05-13 12:41:26 EDT (Sun, 13 May 2012)
@@ -99,7 +99,17 @@
       allocated = 0;
     }
 
-    ~object_pool_base();
+    ~object_pool_base()
+    {
+      purge_memory();
+    }
+
+    bool release_memory()
+    {
+      return Pool::release_memory();
+    }
+
+    bool purge_memory();
 
     // Returns 0 if out-of-memory.
     element_type * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
@@ -140,6 +150,11 @@
       return store().is_from(chunk);
     }
 
+    size_type get_size() const
+    {
+      return store().get_size();
+    }
+
     element_type * construct()
     { //! \returns A pointer to an object of type T, allocated in memory from the underlying pool
       //! and default constructed.  The returned objected can be freed by a call to \ref destroy.
@@ -211,62 +226,56 @@
 };
 
 template <typename T, typename Pool>
-object_pool_base<T, Pool>::~object_pool_base()
+bool object_pool_base<T, Pool>::purge_memory()
 {
   // handle trivial case of invalid list.
   if (!this->list.valid())
-    return;
-
-  // do not do useless work
-  if (!allocated)
-    return;
-
-  // sort store
-  store().order();
+    return false;
 
-  details::PODptr<size_type> iter = this->list;
-  details::PODptr<size_type> next = iter;
+  // delete all objects that are not freed
+  if (allocated)
+  {
+    // sort store
+    store().order();
 
-  // Start 'freed_iter' at beginning of free list
-  void * freed_iter = this->first;
+    details::PODptr<size_type> iter = this->list;
+    details::PODptr<size_type> next = iter;
 
-  const size_type partition_size = this->alloc_size();
+    // Start 'freed_iter' at beginning of free list
+    void * freed_iter = this->first;
 
-  do
-  {
-    // increment next
-    next = next.next();
+    const size_type partition_size = this->alloc_size();
 
-    // delete all contained objects that aren't freed.
-
-    // Iterate 'i' through all chunks in the memory block.
-    for (char * i = iter.begin(); i != iter.end(); i += partition_size)
+    do
     {
-      // If this chunk is free,
-      if (i == freed_iter)
-      {
-        // Increment freed_iter to point to next in free list.
-        freed_iter = nextof(freed_iter);
+      // increment next
+      next = next.next();
 
-        // Continue searching chunks in the memory block.
-        continue;
+      // Iterate 'i' through all chunks in the memory block.
+      for (char * i = iter.begin(); i != iter.end(); i += partition_size)
+      {
+        // If this chunk is free,
+        if (i == freed_iter)
+        {
+          // Increment freed_iter to point to next in free list.
+          freed_iter = nextof(freed_iter);
+
+          // Continue searching chunks in the memory block.
+          continue;
+        }
+
+        // This chunk is not free (allocated), so call its destructor,
+        static_cast<T *>(static_cast<void *>(i))->~T();
+        // and continue searching chunks in the memory block.
       }
 
-      // This chunk is not free (allocated), so call its destructor,
-      static_cast<T *>(static_cast<void *>(i))->~T();
-      // and continue searching chunks in the memory block.
-    }
-
-    // free storage.
-    (Pool::free)(iter.begin());
-
-    // increment iter.
-    iter = next;
-  } while (iter.valid());
+      // increment iter.
+      iter = next;
+    } while (iter.valid());
+  }
 
-  // Make the block list empty so that the inherited destructor doesn't try to
-  // free it again.
-  this->list.invalidate();
+  // Call inherited purge function
+  return Pool::purge_memory();
 }
 
 /*! \brief A template class
@@ -340,11 +349,6 @@
     { //! Set max_size.
       pool<UserAllocator>::set_max_size(nmax_size);
     }
-
-    size_type get_size() const
-    {
-      return pool<UserAllocator>::get_size();
-    }
 };
 
 /*! \brief A template class
@@ -387,6 +391,17 @@
       //! \param arg_requested_objects Number of memory chunks to allocate at initialization. 
       //!  It defines the maximum number of objects that can be malloc'ed from this pool.
     }
+
+  protected :
+    bool release_memory()
+    {
+      return false;
+    }
+
+    bool purge_memory()
+    {
+      return false;
+    }
 };
 
 /*! \brief A template class
@@ -427,6 +442,17 @@
     object_pool_base<T, array_pool<sizeof(T), PoolSize> >(PoolSize)
     { //! Constructs a new (empty by default) ArrayObjectPool.
     }
+
+  protected :
+    bool release_memory()
+    {
+      return false;
+    }
+
+    bool purge_memory()
+    {
+      return false;
+    }
 };
 
 } // namespace boost