dep/ACE_wrappers/ace/Malloc_Allocator.cpp

   1 // $Id: Malloc_Allocator.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/Malloc_Allocator.h"
   4 #include "ace/Object_Manager.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 #include "ace/Malloc_Allocator.inl"
   8 #endif /* __ACE_INLINE__ */
   9
  10 #include "ace/Guard_T.h"
  11 #include "ace/Recursive_Thread_Mutex.h"
  12 #include "ace/Log_Msg.h"  // for ACE_ASSERT
  13 #include "ace/OS_NS_string.h"
  14
  15 ACE_RCSID (ace, Malloc_Allocator, "$Id: Malloc_Allocator.cpp 80826 2008-03-04 14:51:23Z wotte $")
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 ACE_Allocator *
  20 ACE_Allocator::instance (void)
  21 {
  22   //  ACE_TRACE ("ACE_Allocator::instance");
  23
  24   if (ACE_Allocator::allocator_ == 0)
  25     {
  26       // Perform Double-Checked Locking Optimization.
  27       ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
  28                                 *ACE_Static_Object_Lock::instance (), 0));
  29
  30       if (ACE_Allocator::allocator_ == 0)
  31         {
  32           // Have a seat.  We want to avoid ever having to delete the
  33           // ACE_Allocator instance, to avoid shutdown order
  34           // dependencies.  ACE_New_Allocator never needs to be
  35           // destroyed:  its destructor is empty and its instance
  36           // doesn't have any state.  Therefore, sizeof
  37           // ACE_New_Allocator is equal to sizeof void *.  It's
  38           // instance just contains a pointer to its virtual function
  39           // table.
  40           //
  41           // So, we allocate space for the ACE_New_Allocator instance
  42           // in the data segment.  Because its size is the same as
  43           // that of a pointer, we allocate it as a pointer so that it
  44           // doesn't get constructed statically.  We never bother to
  45           // destroy it.
  46           static void *allocator_instance = 0;
  47
  48           // Check this critical assumption.  We put it in a variable
  49           // first to avoid stupid compiler warnings that the
  50           // condition may always be true/false.
  51 #         if !defined (ACE_NDEBUG)
  52           int assertion = (sizeof allocator_instance ==
  53                            sizeof (ACE_New_Allocator));
  54           ACE_ASSERT (assertion);
  55 #         endif /* !ACE_NDEBUG */
  56
  57           // Initialize the allocator_instance by using a placement
  58           // new.
  59           ACE_Allocator::allocator_ =
  60             new (&allocator_instance) ACE_New_Allocator;
  61         }
  62     }
  63
  64   return ACE_Allocator::allocator_;
  65 }
  66
  67 ACE_Allocator *
  68 ACE_Allocator::instance (ACE_Allocator *r)
  69 {
  70   ACE_TRACE ("ACE_Allocator::instance");
  71   ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
  72                             *ACE_Static_Object_Lock::instance (), 0));
  73   ACE_Allocator *t = ACE_Allocator::allocator_;
  74
  75   // We can't safely delete it since we don't know who created it!
  76   ACE_Allocator::delete_allocator_ = 0;
  77
  78   ACE_Allocator::allocator_ = r;
  79   return t;
  80 }
  81
  82 void
  83 ACE_Allocator::close_singleton (void)
  84 {
  85   ACE_TRACE ("ACE_Allocator::close_singleton");
  86
  87   ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon,
  88                      *ACE_Static_Object_Lock::instance ()));
  89
  90   if (ACE_Allocator::delete_allocator_)
  91     {
  92       // This should never be executed....  See the
  93       // ACE_Allocator::instance (void) method for an explanation.
  94       delete ACE_Allocator::allocator_;
  95       ACE_Allocator::allocator_ = 0;
  96       ACE_Allocator::delete_allocator_ = 0;
  97     }
  98 }
  99
 100 ACE_Allocator::~ACE_Allocator (void)
 101 {
 102   ACE_TRACE ("ACE_Allocator::~ACE_Allocator");
 103 }
 104
 105 ACE_Allocator::ACE_Allocator (void)
 106 {
 107   ACE_TRACE ("ACE_Allocator::ACE_Allocator");
 108 }
 109
 110 /******************************************************************************/
 111
 112 void *
 113 ACE_New_Allocator::malloc (size_t nbytes)
 114 {
 115   char *ptr = 0;
 116
 117   if (nbytes > 0)
 118     ACE_NEW_RETURN (ptr, char[nbytes], 0);
 119   return (void *) ptr;
 120 }
 121
 122 void *
 123 ACE_New_Allocator::calloc (size_t nbytes,
 124                            char initial_value)
 125 {
 126   char *ptr = 0;
 127
 128   ACE_NEW_RETURN (ptr, char[nbytes], 0);
 129
 130   ACE_OS::memset (ptr, initial_value, nbytes);
 131   return (void *) ptr;
 132 }
 133
 134 void *
 135 ACE_New_Allocator::calloc (size_t n_elem, size_t elem_size, char initial_value)
 136 {
 137   return ACE_New_Allocator::calloc (n_elem * elem_size, initial_value);
 138 }
 139
 140 void
 141 ACE_New_Allocator::free (void *ptr)
 142 {
 143   delete [] (char *) ptr;
 144 }
 145
 146 int
 147 ACE_New_Allocator::remove (void)
 148 {
 149   ACE_NOTSUP_RETURN (-1);
 150 }
 151
 152 int
 153 ACE_New_Allocator::bind (const char *, void *, int)
 154 {
 155   ACE_NOTSUP_RETURN (-1);
 156 }
 157
 158 int
 159 ACE_New_Allocator::trybind (const char *, void *&)
 160 {
 161   ACE_NOTSUP_RETURN (-1);
 162 }
 163
 164 int
 165 ACE_New_Allocator::find (const char *, void *&)
 166 {
 167   ACE_NOTSUP_RETURN (-1);
 168 }
 169
 170 int
 171 ACE_New_Allocator::find (const char *)
 172 {
 173   ACE_NOTSUP_RETURN (-1);
 174 }
 175
 176 int
 177 ACE_New_Allocator::unbind (const char *)
 178 {
 179   ACE_NOTSUP_RETURN (-1);
 180 }
 181
 182 int
 183 ACE_New_Allocator::unbind (const char *, void *&)
 184 {
 185   ACE_NOTSUP_RETURN (-1);
 186 }
 187
 188 int
 189 ACE_New_Allocator::sync (ssize_t, int)
 190 {
 191   ACE_NOTSUP_RETURN (-1);
 192 }
 193
 194 int
 195 ACE_New_Allocator::sync (void *, size_t, int)
 196 {
 197   ACE_NOTSUP_RETURN (-1);
 198 }
 199
 200 int
 201 ACE_New_Allocator::protect (ssize_t, int)
 202 {
 203   ACE_NOTSUP_RETURN (-1);
 204 }
 205
 206 int
 207 ACE_New_Allocator::protect (void *, size_t, int)
 208 {
 209   ACE_NOTSUP_RETURN (-1);
 210 }
 211
 212 #if defined (ACE_HAS_MALLOC_STATS)
 213 void
 214 ACE_New_Allocator::print_stats (void) const
 215 {
 216 }
 217 #endif /* ACE_HAS_MALLOC_STATS */
 218
 219 void
 220 ACE_New_Allocator::dump (void) const
 221 {
 222 #if defined (ACE_HAS_DUMP)
 223 #endif /* ACE_HAS_DUMP */
 224 }
 225
 226 /******************************************************************************/
 227
 228 void *
 229 ACE_Static_Allocator_Base::malloc (size_t nbytes)
 230 {
 231   if (this->offset_ + nbytes > this->size_)
 232     {
 233       errno = ENOMEM;
 234       return 0;
 235     }
 236   else
 237     {
 238       // Record the current offset, increment the offset by the number
 239       // of bytes requested, and return the original offset.
 240       char *ptr = &this->buffer_[this->offset_];
 241       this->offset_ += nbytes;
 242       return (void *) ptr;
 243     }
 244 }
 245
 246 void *
 247 ACE_Static_Allocator_Base::calloc (size_t nbytes,
 248                                    char initial_value)
 249 {
 250   void *ptr = this->malloc (nbytes);
 251
 252   ACE_OS::memset (ptr, initial_value, nbytes);
 253   return (void *) ptr;
 254 }
 255
 256 void *
 257 ACE_Static_Allocator_Base::calloc (size_t n_elem,
 258                                    size_t elem_size,
 259                                    char initial_value)
 260 {
 261   return this->calloc (n_elem * elem_size, initial_value);
 262 }
 263
 264 void
 265 ACE_Static_Allocator_Base::free (void *ptr)
 266 {
 267   // Check to see if ptr is within our pool?!
 268   ACE_UNUSED_ARG (ptr);
 269   ACE_ASSERT (ptr >= this->buffer_ && ptr < this->buffer_ + this->size_);
 270 }
 271
 272 int
 273 ACE_Static_Allocator_Base::remove (void)
 274 {
 275   return -1;
 276 }
 277
 278 int
 279 ACE_Static_Allocator_Base::bind (const char *, void *, int)
 280 {
 281   return -1;
 282 }
 283
 284 int
 285 ACE_Static_Allocator_Base::trybind (const char *, void *&)
 286 {
 287   return -1;
 288 }
 289
 290 int
 291 ACE_Static_Allocator_Base::find (const char *, void *&)
 292 {
 293   return -1;
 294 }
 295
 296 int
 297 ACE_Static_Allocator_Base::find (const char *)
 298 {
 299   return -1;
 300 }
 301
 302 int
 303 ACE_Static_Allocator_Base::unbind (const char *)
 304 {
 305   return -1;
 306 }
 307
 308 int
 309 ACE_Static_Allocator_Base::unbind (const char *, void *&)
 310 {
 311   return -1;
 312 }
 313
 314 int
 315 ACE_Static_Allocator_Base::sync (ssize_t, int)
 316 {
 317   return -1;
 318 }
 319
 320 int
 321 ACE_Static_Allocator_Base::sync (void *, size_t, int)
 322 {
 323   return -1;
 324 }
 325
 326 int
 327 ACE_Static_Allocator_Base::protect (ssize_t, int)
 328 {
 329   return -1;
 330 }
 331
 332 int
 333 ACE_Static_Allocator_Base::protect (void *, size_t, int)
 334 {
 335   return -1;
 336 }
 337
 338 #if defined (ACE_HAS_MALLOC_STATS)
 339 void
 340 ACE_Static_Allocator_Base::print_stats (void) const
 341 {
 342 }
 343 #endif /* ACE_HAS_MALLOC_STATS */
 344
 345 void
 346 ACE_Static_Allocator_Base::dump (void) const
 347 {
 348 #if defined (ACE_HAS_DUMP)
 349   ACE_TRACE ("ACE_Static_Allocator_Base::dump");
 350
 351   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 352   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\noffset_ = %d"), this->offset_));
 353   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize_ = %d\n"), this->size_));
 354   ACE_HEX_DUMP ((LM_DEBUG, this->buffer_, this->size_));
 355   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
 356
 357   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 358 #endif /* ACE_HAS_DUMP */
 359 }
 360
 361 ACE_END_VERSIONED_NAMESPACE_DECL