ACE/ace/Malloc.cpp

   1 #include "ace/Malloc.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 #include "ace/Malloc.inl"
   5 #endif /* __ACE_INLINE__ */
   6
   7 #include "ace/Object_Manager.h"
   8 #include "ace/Malloc_Base.h"
   9 #include "ace/OS_NS_string.h"
  10
  11
  12 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  13
  14 // Process-wide ACE_Allocator.
  15 ACE_Allocator *ACE_Allocator::allocator_ = 0;
  16
  17 void
  18 ACE_Control_Block::ACE_Malloc_Header::dump (void) const
  19 {
  20 #if defined (ACE_HAS_DUMP)
  21   ACE_TRACE ("ACE_Control_Block::ACE_Malloc_Header::dump");
  22
  23   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  24   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_block = %@"), (ACE_Malloc_Header *) this->next_block_));
  25   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize = %d\n"), this->size_));
  26   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  27 #endif /* ACE_HAS_DUMP */
  28 }
  29
  30 void
  31 ACE_Control_Block::print_alignment_info (void)
  32 {
  33 #if defined (ACE_HAS_DUMP)
  34   ACE_TRACE ("ACE_Control_Block::print_alignment_info");
  35   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("Start ---> ACE_Control_Block::print_alignment_info:\n")));
  36   ACELIB_DEBUG ((LM_DEBUG,
  37               ACE_TEXT ("Sizeof ptr: %d\n")
  38               ACE_TEXT ("Sizeof size_t: %d\n")
  39               ACE_TEXT ("Sizeof long: %d\n")
  40               ACE_TEXT ("Sizeof double: %d\n")
  41               ACE_TEXT ("Sizeof ACE_MALLOC_ALIGN: %d\n")
  42               ACE_TEXT ("Sizeof ACE_MALLOC_PADDING: %d\n")
  43               ACE_TEXT ("Sizeof ACE_MALLOC_HEADER_SIZE: %d\n")
  44               ACE_TEXT ("Sizeof ACE_MALLOC_PADDING_SIZE: %d\n")
  45               ACE_TEXT ("Sizeof ACE_CONTROL_BLOCK_SIZE: %d\n")
  46               ACE_TEXT ("Sizeof ACE_CONTROL_BLOCK_ALIGN_BYTES: %d\n")
  47               ACE_TEXT ("Sizeof (MALLOC_HEADER): %d\n")
  48               ACE_TEXT ("Sizeof (CONTROL_BLOCK): %d\n"),
  49               sizeof (char *),
  50               sizeof (size_t),
  51               sizeof (long),
  52               sizeof (double),
  53               ACE_MALLOC_ALIGN,
  54               ACE_MALLOC_PADDING,
  55               ACE_MALLOC_HEADER_SIZE,
  56               ACE_MALLOC_PADDING_SIZE,
  57               ACE_CONTROL_BLOCK_SIZE,
  58               ACE_CONTROL_BLOCK_ALIGN_BYTES,
  59               sizeof (ACE_Malloc_Header),
  60               sizeof (ACE_Control_Block)
  61               ));
  62   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("End <--- ACE_Control_Block::print_alignment_info:\n")));
  63 #endif /* ACE_HAS_DUMP */
  64 }
  65
  66 void
  67 ACE_Control_Block::dump (void) const
  68 {
  69 #if defined (ACE_HAS_DUMP)
  70   ACE_TRACE ("ACE_Control_Block::dump");
  71
  72   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  73   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("Name Node:\n")));
  74   for (ACE_Name_Node *nextn = this->name_head_;
  75        nextn != 0;
  76        nextn = nextn->next_)
  77     nextn->dump ();
  78
  79   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("freep_ = %@"), (ACE_Malloc_Header *) this->freep_));
  80   this->base_.dump ();
  81
  82   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nMalloc Header:\n")));
  83   for (ACE_Malloc_Header *nexth = ((ACE_Malloc_Header *)this->freep_)->next_block_;
  84        nexth != 0 && nexth != &this->base_;
  85        nexth = nexth->next_block_)
  86     nexth->dump ();
  87
  88   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
  89   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  90 #endif /* ACE_HAS_DUMP */
  91 }
  92
  93 ACE_Control_Block::ACE_Name_Node::ACE_Name_Node (void)
  94   : name_ (0),
  95     pointer_ (0),
  96     next_ (0),
  97     prev_ (0)
  98 {
  99   ACE_TRACE ("ACE_Control_Block::ACE_Name_Node::ACE_Name_Node");
 100 }
 101
 102 ACE_Control_Block::ACE_Name_Node::ACE_Name_Node (const char *name,
 103                                                  char *name_ptr,
 104                                                  char *pointer,
 105                                                  ACE_Name_Node *next)
 106   : name_ (name_ptr),
 107     pointer_ (pointer),
 108     next_ (next),
 109     prev_ (0)
 110 {
 111   ACE_TRACE ("ACE_Control_Block::ACE_Name_Node::ACE_Name_Node");
 112   char *n = this->name_;
 113   ACE_OS::strcpy (n, name);
 114   if (next != 0)
 115     next->prev_ = this;
 116 }
 117
 118 const char *
 119 ACE_Control_Block::ACE_Name_Node::name (void) const
 120 {
 121   return this->name_;
 122 }
 123
 124 ACE_Control_Block::ACE_Malloc_Header::ACE_Malloc_Header (void)
 125   : next_block_ (0),
 126     size_ (0)
 127 {
 128 }
 129
 130 void
 131 ACE_Control_Block::ACE_Name_Node::dump (void) const
 132 {
 133 #if defined (ACE_HAS_DUMP)
 134   ACE_TRACE ("ACE_Control_Block::ACE_Name_Node::dump");
 135
 136   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 137   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("pointer = %@"), (const char *) this->pointer_));
 138   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_ = %@"), (ACE_Name_Node *) this->next_));
 139   ACELIB_DEBUG ((LM_DEBUG,
 140               ACE_TEXT ("\nname_ = (%@, %C)\n"),
 141               (const char *) this->name_,
 142               (const char *) this->name_));
 143   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 144 #endif /* ACE_HAS_DUMP */
 145 }
 146
 147
 148 #if defined (ACE_HAS_MALLOC_STATS)
 149 ACE_Malloc_Stats::ACE_Malloc_Stats (void)
 150   : nchunks_ (0),
 151     nblocks_ (0),
 152     ninuse_ (0)
 153 {
 154   ACE_TRACE ("ACE_Malloc_Stats::ACE_Malloc_Stats");
 155 }
 156
 157 void
 158 ACE_Malloc_Stats::dump (void) const
 159 {
 160 #if defined (ACE_HAS_DUMP)
 161   ACE_TRACE ("ACE_Malloc_Stats::dump");
 162
 163   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 164   int const nblocks = this->nblocks_.value ();
 165   int const ninuse  = this->ninuse_.value ();
 166   int const nchunks = this->nchunks_.value ();
 167
 168   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT("nblocks = %d"), nblocks));
 169   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT("\nninuse = %d"), ninuse));
 170   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT("\nnchunks = %d"), nchunks));
 171   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT("\n")));
 172   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 173 #endif /* ACE_HAS_DUMP */
 174 }
 175
 176 #endif /*ACE_HAS_MALLOC_STATS*/
 177
 178 ACE_END_VERSIONED_NAMESPACE_DECL