Cascaded allocator

ACE/ace/Malloc_T.cpp

@@ -177,6 +177,171 @@ ACE_Dynamic_Cached_Allocator<ACE_LOCK>::free (void * ptr)
     this->free_list_.add ((ACE_Cached_Mem_Pool_Node<char> *) ptr);
 }
 
+template <class ACE_LOCK>
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::ACE_Cascaded_Dynamic_Cached_Allocator
+  (size_t initial_n_chunks, size_t chunk_size)
+    : initial_n_chunks_ (initial_n_chunks),
+      chunk_size_ (chunk_size)
+{
+  ACE_ASSERT (chunk_size_ > 0);
+
+  comb_alloc_ptr tmp;
+  // If ACE_NEW fails, the hierarchy_ will be reconstructed when malloc API is called.
+  ACE_NEW (tmp, comb_alloc_type(this->initial_n_chunks_, this->chunk_size_));
+  hierarchy_.push_back(tmp);
+}
+
+template <class ACE_LOCK>
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::~ACE_Cascaded_Dynamic_Cached_Allocator ()
+{
+  for (size_t c = 0;
+       c < hierarchy_.size();
+       c++)
+  {
+          delete hierarchy_[c];
+  }
+
+  hierarchy_.clear();
+}
+
+template <class ACE_LOCK> void *
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::malloc (size_t nbytes)
+{
+  // Check if size requested fits within pre-determined size.
+  if (nbytes > chunk_size_)
+    return nullptr;
+
+  ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, nullptr));
+
+  void * ptr = nullptr;
+
+  for (size_t c = 0;
+       c < hierarchy_.size();
+       c++)
+  {
+       ptr = hierarchy_[c]->malloc(nbytes);
+       if(ptr != nullptr)
+           break;
+  }
+
+  if(ptr == nullptr)
+  {
+       comb_alloc_ptr tmp;
+       ACE_NEW_RETURN (tmp, comb_alloc_type(this->initial_n_chunks_ * 2 * hierarchy_.size(), this->chunk_size_), nullptr);
+       hierarchy_.push_back(tmp);
+       ptr = tmp->malloc(nbytes);
+  }
+
+  return ptr;
+}
+
+template <class ACE_LOCK> void *
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t nbytes,
+                                                char initial_value)
+{
+  // Check if size requested fits within pre-determined size.
+  if (nbytes > chunk_size_)
+      return nullptr;
+
+  // No need any lock.
+  void *ptr = malloc(nbytes);
+  if (ptr != nullptr)
+      ACE_OS::memset (ptr, initial_value, chunk_size_);
+
+  return ptr;
+}
+
+template <class ACE_LOCK> void *
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t, size_t, char)
+{
+  ACE_NOTSUP_RETURN (0);
+}
+
+template <class ACE_LOCK> void
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::free (void * ptr)
+{
+  ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));
+
+  ACE_ASSERT (hierarchy_.size () > 0);
+
+  // Use first allocator as a free chunk manager for all allocators when chunk freed.
+  if (ptr != nullptr && hierarchy_.size () > 0)
+      hierarchy_[0]->free(ptr);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::remove ()
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::bind (const char *, void *, int)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::trybind (const char *, void *&)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::find (const char *, void *&)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::find (const char *)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::unbind (const char *)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::unbind (const char *, void *&)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::sync (ssize_t, int)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::sync (void *, size_t, int)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::protect (ssize_t, int)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> int
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::protect (void *, size_t, int)
+{
+  ACE_NOTSUP_RETURN (-1);
+}
+
+template <class ACE_LOCK> void
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::dump () const
+{
+#if defined (ACE_HAS_DUMP)
+#endif /* ACE_HAS_DUMP */
+}
+
 ACE_ALLOC_HOOK_DEFINE_Tmcc (ACE_Malloc_T)
 
 template <class MALLOC> void *

ACE/ace/Malloc_T.h

@@ -5,7 +5,8 @@
  *  @file    Malloc_T.h
  *
  *  @author Douglas C. Schmidt <[email protected]> and
- *          Irfan Pyarali <[email protected]>
+ *          Irfan Pyarali <[email protected]> and
+            smithAchang <[email protected]>
  */
 //==========================================================================
 
@@ -15,6 +16,7 @@
 
 #include "ace/Malloc.h"               /* Need ACE_Control_Block */
 #include "ace/Malloc_Base.h"          /* Need ACE_Allocator */
+#include "ace/Null_Mutex.h"           /* Need ACE_Null_Mutex */
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -24,6 +26,8 @@
 #include "ace/Free_List.h"
 #include "ace/Guard_T.h"
 
+#include <vector>
+
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 /**
@@ -203,6 +207,101 @@ class ACE_Dynamic_Cached_Allocator : public ACE_New_Allocator
   size_t chunk_size_;
 };
 
+/**
+ * @class ACE_Cascaded_Dynamic_Cached_Allocator
+ *
+ * @brief A fixed-size-based allocator that caches blocks for quicker access,
+ * but with a hierarchy of cascaded, nested allocators
+ *
+ * This class enables caching of dynamically allocated,
+ * fixed-size chunks. Notice that the @a chunk_size
+ * must be greater than or equal to <code> sizeof (void*) </code> for
+ * this to work properly.
+ *
+ * Notice that when the latest allocator is empty, the allocator will create a fresh
+ * @a ACE_Dynamic_Cached_Allocator allocator again with
+ * <code> init_n_chunks* the sum of current allocators </code> as it's constructor parameter,
+ * so all the allocators will form a cascaded hierarchy.
+
+ * This class can be configured flexibly with different types of
+ * ACE_LOCK strategies that support the @a ACE_Thread_Mutex and @a
+ * ACE_Process_Mutex constructor API.
+ *
+ * @sa ACE_Dynamic_Cached_Allocator
+ */
+template <class ACE_LOCK>
+class ACE_Cascaded_Dynamic_Cached_Allocator : public ACE_Allocator
+{
+public:
+  /// Create a cached memory pool with @a n_chunks chunks
+  /// each with @a chunk_size size.
+  ACE_Cascaded_Dynamic_Cached_Allocator (size_t initial_n_chunks, size_t chunk_size);
+
+  /// Clear things up.
+  ~ACE_Cascaded_Dynamic_Cached_Allocator ();
+
+  /**
+   * Get a chunk of memory from free list cache.  Note that @a nbytes is
+   * only checked to make sure that it's less or equal to @a chunk_size,
+   * and is otherwise ignored since malloc() always returns a pointer to an
+   * item of @a chunk_size size.
+   */
+  virtual void *malloc (size_t nbytes);
+
+  /**
+   * Get a chunk of memory from free list cache, giving them
+   * @a initial_value.  Note that @a nbytes is only checked to make sure
+   * that it's less or equal to @a chunk_size, and is otherwise ignored
+   * since calloc() always returns a pointer to an item of @a chunk_size.
+   */
+  virtual void *calloc (size_t nbytes, char initial_value = '\0');
+
+  /// This method is a no-op and just returns 0 since the free list
+  /// only works with fixed sized entities.
+  virtual void *calloc (size_t n_elem, size_t elem_size, char initial_value = '\0');
+
+  /// Return a chunk of memory back to free list cache.
+  virtual void free (void *ptr);
+
+  /// These methods are no-ops.
+  virtual int remove ();
+  virtual int bind (const char *name, void *pointer, int duplicates = 0);
+  virtual int trybind (const char *name, void *&pointer);
+  virtual int find (const char *name, void *&pointer);
+  virtual int find (const char *name);
+  virtual int unbind (const char *name);
+  virtual int unbind (const char *name, void *&pointer);
+  virtual int sync (ssize_t len = -1, int flags = MS_SYNC);
+  virtual int sync (void *addr, size_t len, int flags = MS_SYNC);
+  virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);
+  virtual int protect (void *addr, size_t len, int prot = PROT_RDWR);
+  virtual void dump () const;
+
+  /// Return the number of chunks available in the hierarchy.
+  size_t pool_depth ();
+
+  /// Returns a reference to the lock used to provide mutual exclusion to
+  /// the allocator hierarchy.
+  ACE_LOCK &mutex ();
+
+private:
+  // Useful STL-style traits.
+  using comb_alloc_type = ACE_Dynamic_Cached_Allocator<ACE_Null_Mutex>;
+  using comb_alloc_ptr  = comb_alloc_type*;
+
+  /// Synchronization variable for API.
+  ACE_LOCK mutex_;
+
+  /// Remember how we allocate the memory so we can clear things up later.
+  std::vector<comb_alloc_ptr> hierarchy_;
+
+  /// Remember the size of initial n_chunks for creating fresh allocator in future.
+  const size_t initial_n_chunks_;
+
+  /// Remember the size of our chunks for creating fresh allocator in future.
+  const size_t chunk_size_;
+};
+
 /**
  * @class ACE_Allocator_Adapter
  *

ACE/ace/Malloc_T.inl

@@ -38,6 +38,29 @@ ACE_Dynamic_Cached_Allocator<ACE_LOCK>::pool_depth ()
   return this->free_list_.size ();
 }
 
+template <class ACE_LOCK> ACE_INLINE size_t
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::pool_depth ()
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0));
+
+  size_t pool_depth = 0;
+
+  for (size_t c = 0;
+       c < hierarchy_.size();
+       c++)
+  {
+       pool_depth += hierarchy_[c]->pool_depth();
+  }
+
+  return pool_depth;
+}
+
+template <class ACE_LOCK> ACE_INLINE ACE_LOCK &
+ACE_Cascaded_Dynamic_Cached_Allocator<ACE_LOCK>::mutex ()
+{
+  return this->mutex_;
+}
+
 template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_INLINE int
 ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ref_counter ()
 {