ACE/ace/Malloc_Base.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Malloc_Base.h
   6  *
   7  *  @author Doug Schmidt and Irfan Pyarali
   8  */
   9 //=============================================================================
  10
  11
  12 #ifndef ACE_MALLOC_BASE_H
  13 #define ACE_MALLOC_BASE_H
  14 #include /**/ "ace/pre.h"
  15
  16 #include /**/ "ace/ACE_export.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 #include "ace/os_include/sys/os_types.h"
  23 #include "ace/os_include/sys/os_mman.h"
  24 #include "ace/os_include/sys/os_types.h"
  25 #include <limits>
  26 #include <new>
  27
  28 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  29
  30 // The definition of this class is located in Malloc.cpp.
  31
  32 /**
  33  * @class ACE_Allocator
  34  *
  35  * @brief Interface for a dynamic memory allocator that uses inheritance
  36  * and dynamic binding to provide extensible mechanisms for
  37  * allocating and deallocating memory.
  38  */
  39 class ACE_Export ACE_Allocator
  40 {
  41 public:
  42
  43   /// Unsigned integer type used for specifying memory block lengths.
  44   typedef size_t size_type;
  45
  46   // = Memory Management
  47
  48   /// Get pointer to a default ACE_Allocator.
  49   static ACE_Allocator *instance (void);
  50
  51   /// Set pointer to a process-wide ACE_Allocator and return existing
  52   /// pointer.
  53   static ACE_Allocator *instance (ACE_Allocator *);
  54
  55   /// Delete the dynamically allocated Singleton
  56   static void close_singleton (void);
  57
  58   /// "No-op" constructor (needed to make certain compilers happy).
  59   ACE_Allocator (void);
  60
  61   /// Virtual destructor
  62   virtual ~ACE_Allocator (void);
  63
  64   /// Allocate @a nbytes, but don't give them any initial value.
  65   virtual void *malloc (size_type nbytes) = 0;
  66
  67   /// Allocate @a nbytes, giving them @a initial_value.
  68   virtual void *calloc (size_type nbytes, char initial_value = '\0') = 0;
  69
  70   /// Allocate @a n_elem each of size @a elem_size, giving them
  71   /// @a initial_value.
  72   virtual void *calloc (size_type n_elem,
  73                         size_type elem_size,
  74                         char initial_value = '\0') = 0;
  75
  76   /// Free @a ptr (must have been allocated by ACE_Allocator::malloc()).
  77   virtual void free (void *ptr) = 0;
  78
  79   /// Remove any resources associated with this memory manager.
  80   virtual int remove (void) = 0;
  81
  82   // = Map manager like functions
  83
  84   /**
  85    * Associate @a name with @a pointer.  If @a duplicates == 0 then do
  86    * not allow duplicate @a name/@a pointer associations, else if
  87    * @a duplicates != 0 then allow duplicate @a name/@a pointer
  88    * associations.  Returns 0 if successfully binds (1) a previously
  89    * unbound @a name or (2) @a duplicates != 0, returns 1 if trying to
  90    * bind a previously bound @a name and @a duplicates == 0, else
  91    * returns -1 if a resource failure occurs.
  92    */
  93   virtual int bind (const char *name, void *pointer, int duplicates = 0) = 0;
  94
  95   /**
  96    * Associate @a name with @a pointer.  Does not allow duplicate
  97    * @a name/@a pointer associations.  Returns 0 if successfully binds
  98    * (1) a previously unbound @a name, 1 if trying to bind a previously
  99    * bound @a name, or returns -1 if a resource failure occurs.  When
 100    * this call returns @a pointer's value will always reference the
 101    * void * that @a name is associated with.  Thus, if the caller needs
 102    * to use @a pointer (e.g., to free it) a copy must be maintained by
 103    * the caller.
 104    */
 105   virtual int trybind (const char *name, void *&pointer) = 0;
 106
 107   /// Locate @a name and pass out parameter via pointer.  If found,
 108   /// return 0, returns -1 if failure occurs.
 109   virtual int find (const char *name, void *&pointer) = 0;
 110
 111   /// Returns 0 if the name is in the mapping. -1, otherwise.
 112   virtual int find (const char *name) = 0;
 113
 114   /// Unbind (remove) the name from the map.  Don't return the pointer
 115   /// to the caller
 116   virtual int unbind (const char *name) = 0;
 117
 118   /// Break any association of name.  Returns the value of pointer in
 119   /// case the caller needs to deallocate memory.
 120   virtual int unbind (const char *name, void *&pointer) = 0;
 121
 122   // = Protection and "sync" (i.e., flushing memory to persistent
 123   // backing store).
 124
 125   /**
 126    * Sync @a len bytes of the memory region to the backing store
 127    * starting at @c this->base_addr_.  If @a len == -1 then sync the
 128    * whole region.
 129    */
 130   virtual int sync (ssize_t len = -1, int flags = MS_SYNC) = 0;
 131
 132   /// Sync @a len bytes of the memory region to the backing store
 133   /// starting at @a addr.
 134   virtual int sync (void *addr, size_type len, int flags = MS_SYNC) = 0;
 135
 136   /**
 137    * Change the protection of the pages of the mapped region to @a prot
 138    * starting at <this->base_addr_> up to @a len bytes.  If @a len == -1
 139    * then change protection of all pages in the mapped region.
 140    */
 141   virtual int protect (ssize_t len = -1, int prot = PROT_RDWR) = 0;
 142
 143   /// Change the protection of the pages of the mapped region to @a prot
 144   /// starting at @a addr up to @a len bytes.
 145   virtual int protect (void *addr, size_type len, int prot = PROT_RDWR) = 0;
 146
 147 #if defined (ACE_HAS_MALLOC_STATS)
 148   /// Dump statistics of how malloc is behaving.
 149   virtual void print_stats (void) const = 0;
 150 #endif /* ACE_HAS_MALLOC_STATS */
 151
 152   /// Dump the state of the object.
 153   virtual void dump (void) const = 0;
 154 private:
 155   // DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!!  See the
 156   // <ACE_Allocator::instance> implementation for explanation.
 157
 158   /// Pointer to a process-wide ACE_Allocator instance.
 159   static ACE_Allocator *allocator_;
 160 };
 161
 162 /**
 163  * @class ACE_Allocator_Std_Adapter
 164  *
 165  * @brief Model of std::allocator that forwards requests to
 166 #  ACE_Allocator::instance.  To be used with STL containers.
 167  */
 168
 169 template <typename T>
 170 class ACE_Export ACE_Allocator_Std_Adapter
 171 {
 172 public:
 173   typedef T value_type;
 174   typedef T* pointer;
 175   typedef const T* const_pointer;
 176   typedef T& reference;
 177   typedef const T& const_reference;
 178   typedef std::size_t size_type;
 179   typedef std::ptrdiff_t difference_type;
 180   template <typename U> struct rebind { typedef ACE_Allocator_Std_Adapter<U> other; };
 181
 182   ACE_Allocator_Std_Adapter() {}
 183
 184   template <typename U>
 185   ACE_Allocator_Std_Adapter(const ACE_Allocator_Std_Adapter<U>&) {}
 186
 187   static T* allocate(std::size_t n)
 188   {
 189     void* raw_mem = ACE_Allocator::instance()->malloc(n * sizeof(T));
 190     if (!raw_mem) throw std::bad_alloc();
 191     return static_cast<T*>(raw_mem);
 192   }
 193
 194   static void deallocate(T* ptr, std::size_t)
 195   {
 196     ACE_Allocator::instance()->free(ptr);
 197   }
 198
 199   static void construct(T* ptr, const T& value)
 200   {
 201     new (static_cast<void*>(ptr)) T(value);
 202   }
 203
 204   static void destroy(T* ptr)
 205   {
 206     ptr->~T();
 207   }
 208
 209   static size_type max_size()
 210   {
 211     return (std::numeric_limits<size_type>::max)();
 212   }
 213 };
 214
 215 template <typename T, typename U>
 216 bool operator==(const ACE_Allocator_Std_Adapter<T>&, const ACE_Allocator_Std_Adapter<U>&)
 217 {
 218   return true;
 219 }
 220
 221 template <typename T, typename U>
 222 bool operator!=(const ACE_Allocator_Std_Adapter<T>&, const ACE_Allocator_Std_Adapter<U>&)
 223 {
 224   return false;
 225 }
 226
 227 ACE_END_VERSIONED_NAMESPACE_DECL
 228
 229 #include /**/ "ace/post.h"
 230 #endif /* ACE_MALLOC_BASE_H */