00001 #ifndef ACE_PI_MALLOC_CPP
00002 #define ACE_PI_MALLOC_CPP
00003
00004 #include "ace/PI_Malloc.h"
00005
00006 ACE_RCSID (ace,
00007 PI_Malloc,
00008 "$Id: PI_Malloc.cpp 79134 2007-07-31 18:23:50Z johnnyw $")
00009
00010 #if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
00011
00012 #if !defined (__ACE_INLINE__)
00013 #include "ace/PI_Malloc.inl"
00014 #endif
00015
00016 #include "ace/Object_Manager.h"
00017 #include "ace/Process_Mutex.h"
00018 #include "ace/OS_NS_string.h"
00019
00020 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00021
00022 void
00023 ACE_PI_Control_Block::ACE_Malloc_Header::dump (void) const
00024 {
00025 #if defined (ACE_HAS_DUMP)
00026 ACE_TRACE ("ACE_PI_Control_Block::ACE_Malloc_Header::dump");
00027
00028 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00029 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_block = %x"), (ACE_Malloc_Header *) this->next_block_));
00030 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize = %d\n"), this->size_));
00031 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00032 #endif
00033 }
00034
00035 void
00036 ACE_PI_Control_Block::print_alignment_info (void)
00037 {
00038 #if defined (ACE_HAS_DUMP)
00039 ACE_TRACE ("ACE_PI_Control_Block::ACE_Control_Block::print_alignment_info");
00040 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Start ---> ACE_PI_Control_Block::print_alignment_info:\n")));
00041 ACE_DEBUG ((LM_DEBUG,
00042 ACE_TEXT ("Sizeof ptr: %d\n")
00043 ACE_TEXT ("Sizeof size_t: %d\n")
00044 ACE_TEXT ("Sizeof long: %d\n")
00045 ACE_TEXT ("Sizeof double: %d\n")
00046 ACE_TEXT ("Sizeof ACE_MALLOC_ALIGN: %d\n")
00047 ACE_TEXT ("sizeof ACE_MALLOC_PADDING: %d\n")
00048 ACE_TEXT ("Sizeof ACE_MALLOC_HEADER_SIZE: %d\n")
00049 ACE_TEXT ("Sizeof ACE_PI_MALLOC_PADDING_SIZE: %d\n")
00050 ACE_TEXT ("Sizeof ACE_PI_CONTROL_BLOCK_SIZE: %d\n")
00051 ACE_TEXT ("Sizeof ACE_PI_CONTROL_BLOCK_ALIGN_BYTES: %d\n")
00052 ACE_TEXT ("Sizeof (MALLOC_HEADER): %d\n")
00053 ACE_TEXT ("Sizeof (CONTROL_BLOCK): %d\n"),
00054 sizeof (char *),
00055 sizeof (size_t),
00056 sizeof (long),
00057 sizeof (double),
00058 ACE_MALLOC_ALIGN,
00059 ACE_MALLOC_PADDING,
00060 ACE_MALLOC_HEADER_SIZE,
00061 ACE_PI_MALLOC_PADDING_SIZE,
00062 ACE_PI_CONTROL_BLOCK_SIZE,
00063 ACE_PI_CONTROL_BLOCK_ALIGN_BYTES,
00064 sizeof (ACE_Malloc_Header),
00065 sizeof (ACE_PI_Control_Block)
00066 ));
00067 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("End <--- ACE_PI_Control_Block::print_alignment_info:\n")));
00068 #endif
00069 }
00070
00071 void
00072 ACE_PI_Control_Block::dump (void) const
00073 {
00074 #if defined (ACE_HAS_DUMP)
00075 ACE_TRACE ("ACE_PI_Control_Block::dump");
00076
00077 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00078 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Name Node:\n")));
00079 for (ACE_Name_Node *nextn = this->name_head_;
00080 nextn != 0;
00081 nextn = nextn->next_)
00082 nextn->dump ();
00083
00084 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("freep_ = %x"), (ACE_Malloc_Header *) this->freep_));
00085 this->base_.dump ();
00086
00087 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nMalloc Header:\n")));
00088 for (ACE_Malloc_Header *nexth = ((ACE_Malloc_Header *)this->freep_)->next_block_;
00089 nexth != 0 && nexth != &this->base_;
00090 nexth = nexth->next_block_)
00091 nexth->dump ();
00092
00093 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
00094 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00095 #endif
00096 }
00097
00098 ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (void)
00099 {
00100 ACE_TRACE ("ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node");
00101 }
00102
00103 ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (const char *name,
00104 char *name_ptr,
00105 char *pointer,
00106 ACE_Name_Node *next)
00107 : name_ (name_ptr),
00108 pointer_ (pointer),
00109 next_ (next),
00110 prev_ (0)
00111 {
00112 ACE_TRACE ("ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node");
00113 char *n = this->name_;
00114 ACE_OS::strcpy (n, name);
00115 if (next != 0)
00116 next->prev_ = this;
00117 }
00118
00119 ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (const ACE_Name_Node &)
00120 {
00121 ACE_TRACE ("ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node");
00122 ACE_ASSERT (0);
00123 }
00124
00125 const char *
00126 ACE_PI_Control_Block::ACE_Name_Node::name (void) const
00127 {
00128 const char *c = this->name_;
00129 return c;
00130 }
00131
00132 void
00133 ACE_PI_Control_Block::ACE_Name_Node::name (const char *)
00134 {
00135 ACE_ASSERT (0);
00136 }
00137
00138 ACE_PI_Control_Block::ACE_Malloc_Header::ACE_Malloc_Header (void)
00139 : next_block_ (0),
00140 size_ (0)
00141 {
00142 }
00143
00144 void
00145 ACE_PI_Control_Block::ACE_Name_Node::dump (void) const
00146 {
00147 #if defined (ACE_HAS_DUMP)
00148 ACE_TRACE ("ACE_PI_Control_Block::ACE_Name_Node::dump");
00149
00150 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00151 ACE_DEBUG ((LM_DEBUG, ACE_TEXT("pointer = %x"), (const char *) this->pointer_));
00152 ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nnext_ = %x"), (ACE_Name_Node *) this->next_));
00153 ACE_DEBUG ((LM_DEBUG,
00154 ACE_TEXT("\nname_ = (%x, %s)"),
00155 (const char *) this->name_,
00156 (const char *) this->name_));
00157 ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n")));
00158 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00159 #endif
00160 }
00161
00162 ACE_END_VERSIONED_NAMESPACE_DECL
00163
00164 #endif
00165
00166 #endif