summaryrefslogtreecommitdiff
path: root/ace/Malloc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'ace/Malloc.cpp')
-rw-r--r--ace/Malloc.cpp458
1 files changed, 0 insertions, 458 deletions
diff --git a/ace/Malloc.cpp b/ace/Malloc.cpp
deleted file mode 100644
index 82307dc12ed..00000000000
--- a/ace/Malloc.cpp
+++ /dev/null
@@ -1,458 +0,0 @@
-// $Id$
-
-#if !defined (ACE_MALLOC_CPP)
-#define ACE_MALLOC_CPP
-
-#include "ace/Malloc.h"
-#include "ace/Object_Manager.h"
-
-#if !defined (__ACE_INLINE__)
-#include "ace/Malloc.i"
-#endif /* __ACE_INLINE__ */
-
-#include "ace/Synch_T.h"
-
-ACE_RCSID(ace, Malloc, "$Id$")
-
-// Process-wide ACE_Allocator.
-ACE_Allocator *ACE_Allocator::allocator_ = 0;
-
-// Controls whether the Allocator is deleted when we shut down (we can
-// only delete it safely if we created it!) This is no longer used;
-// see ACE_Allocator::instance (void).
-int ACE_Allocator::delete_allocator_ = 0;
-
-void
-ACE_Control_Block::ACE_Malloc_Header::dump (void) const
-{
- ACE_TRACE ("ACE_Malloc_Header::dump");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_block = %x"), (ACE_Malloc_Header *) this->next_block_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize = %d\n"), this->size_));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-void
-ACE_Control_Block::print_alignment_info (void)
-{
- ACE_TRACE ("ACE_Control_Block::print_alignment_info");
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Start ---> ACE_Control_Block::print_alignment_info:\n")));
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT ("Sizeof ptr: %d\n")
- ACE_TEXT ("Sizeof size_t: %d\n")
- ACE_TEXT ("Sizeof long: %d\n")
- ACE_TEXT ("Sizeof double: %d\n")
- ACE_TEXT ("Sizeof ACE_MALLOC_ALIGN: %d\n")
- ACE_TEXT ("sizeof ACE_MALLOC_PADDING: %d\n")
- ACE_TEXT ("Sizeof ACE_MALLOC_HEADER_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_MALLOC_PADDING_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_CONTROL_BLOCK_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_CONTROL_BLOCK_ALIGN_LONGS: %d\n")
- ACE_TEXT ("Sizeof (MALLOC_HEADER): %d\n")
- ACE_TEXT ("Sizeof (CONTROL_BLOCK): %d\n"),
- sizeof (char *),
- sizeof (size_t),
- sizeof (long),
- sizeof (double),
- ACE_MALLOC_ALIGN,
- ACE_MALLOC_PADDING,
- ACE_MALLOC_HEADER_SIZE,
- ACE_MALLOC_PADDING_SIZE,
- ACE_CONTROL_BLOCK_SIZE,
- ACE_CONTROL_BLOCK_ALIGN_LONGS,
- sizeof (ACE_Malloc_Header),
- sizeof (ACE_Control_Block)
- ));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("End <--- ACE_Control_Block::print_alignment_info:\n")));
-}
-
-void
-ACE_Control_Block::dump (void) const
-{
- ACE_TRACE ("ACE_Control_Block::dump");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Name Node:\n")));
- for (ACE_Name_Node *nextn = this->name_head_;
- nextn != 0;
- nextn = nextn->next_)
- nextn->dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("freep_ = %x"), (ACE_Malloc_Header *) this->freep_));
- this->base_.dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nMalloc Header:\n")));
- for (ACE_Malloc_Header *nexth = ((ACE_Malloc_Header *)this->freep_)->next_block_;
- nexth != 0 && nexth != &this->base_;
- nexth = nexth->next_block_)
- nexth->dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-ACE_Control_Block::ACE_Name_Node::ACE_Name_Node (void)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
-}
-
-ACE_Control_Block::ACE_Name_Node::ACE_Name_Node (const char *name,
- char *name_ptr,
- char *pointer,
- ACE_Name_Node *next)
- : name_ (name_ptr),
- pointer_ (pointer),
- next_ (next),
- prev_ (0)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
- char *n = this->name_;
- ACE_OS::strcpy (n, name);
- if (next != 0)
- next->prev_ = this;
-}
-
-ACE_Control_Block::ACE_Name_Node::ACE_Name_Node (const ACE_Name_Node &)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
-#if !defined (ACE_PSOS)
- ACE_ASSERT (0 == "not implemented!");
-#endif /* ! ACE_PSOS */
-}
-
-const char *
-ACE_Control_Block::ACE_Name_Node::name (void) const
-{
- const char *c = this->name_;
- return c;
-}
-
-void
-ACE_Control_Block::ACE_Name_Node::name (const char *)
-{
-#if !defined (ACE_PSOS)
- ACE_ASSERT (0 == "not implemented!");
-#endif /* ! ACE_PSOS */
-}
-
-ACE_Control_Block::ACE_Malloc_Header::ACE_Malloc_Header (void)
- : next_block_ (0),
- size_ (0)
-{
-}
-
-void
-ACE_Control_Block::ACE_Name_Node::dump (void) const
-{
- ACE_TRACE ("ACE_Name_Node");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("pointer = %x"), (const char *) this->pointer_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nnext_ = %x"), (ACE_Name_Node *) this->next_));
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT("\nname_ = (%x, %s)"),
- (const char *) this->name_,
- (const char *) this->name_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-#if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
-void
-ACE_PI_Control_Block::ACE_Malloc_Header::dump (void) const
-{
- ACE_TRACE ("ACE_Malloc_Header::dump");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_block = %x"), (ACE_Malloc_Header *) this->next_block_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize = %d\n"), this->size_));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-void
-ACE_PI_Control_Block::print_alignment_info (void)
-{
- ACE_TRACE ("ACE_Control_Block::print_alignment_info");
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Start ---> ACE_PI_Control_Block::print_alignment_info:\n")));
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT ("Sizeof ptr: %d\n")
- ACE_TEXT ("Sizeof size_t: %d\n")
- ACE_TEXT ("Sizeof long: %d\n")
- ACE_TEXT ("Sizeof double: %d\n")
- ACE_TEXT ("Sizeof ACE_MALLOC_ALIGN: %d\n")
- ACE_TEXT ("sizeof ACE_MALLOC_PADDING: %d\n")
- ACE_TEXT ("Sizeof ACE_MALLOC_HEADER_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_PI_MALLOC_PADDING_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_PI_CONTROL_BLOCK_SIZE: %d\n")
- ACE_TEXT ("Sizeof ACE_PI_CONTROL_BLOCK_ALIGN_LONGS: %d\n")
- ACE_TEXT ("Sizeof (MALLOC_HEADER): %d\n")
- ACE_TEXT ("Sizeof (CONTROL_BLOCK): %d\n"),
- sizeof (char *),
- sizeof (size_t),
- sizeof (long),
- sizeof (double),
- ACE_MALLOC_ALIGN,
- ACE_MALLOC_PADDING,
- ACE_MALLOC_HEADER_SIZE,
- ACE_PI_MALLOC_PADDING_SIZE,
- ACE_PI_CONTROL_BLOCK_SIZE,
- ACE_PI_CONTROL_BLOCK_ALIGN_LONGS,
- sizeof (ACE_Malloc_Header),
- sizeof (ACE_PI_Control_Block)
- ));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("End <--- ACE_PI_Control_Block::print_alignment_info:\n")));
-}
-
-void
-ACE_PI_Control_Block::dump (void) const
-{
- ACE_TRACE ("ACE_Control_Block::dump");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Name Node:\n")));
- for (ACE_Name_Node *nextn = this->name_head_;
- nextn != 0;
- nextn = nextn->next_)
- nextn->dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("freep_ = %x"), (ACE_Malloc_Header *) this->freep_));
- this->base_.dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nMalloc Header:\n")));
- for (ACE_Malloc_Header *nexth = ((ACE_Malloc_Header *)this->freep_)->next_block_;
- nexth != 0 && nexth != &this->base_;
- nexth = nexth->next_block_)
- nexth->dump ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (void)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
-}
-
-ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (const char *name,
- char *name_ptr,
- char *pointer,
- ACE_Name_Node *next)
- : name_ (name_ptr),
- pointer_ (pointer),
- next_ (next),
- prev_ (0)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
- char *n = this->name_;
- ACE_OS::strcpy (n, name);
- if (next != 0)
- next->prev_ = this;
-}
-
-ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node (const ACE_Name_Node &)
-{
- ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
- ACE_ASSERT (0); // not implemented!
-}
-
-const char *
-ACE_PI_Control_Block::ACE_Name_Node::name (void) const
-{
- const char *c = this->name_;
- return c;
-}
-
-void
-ACE_PI_Control_Block::ACE_Name_Node::name (const char *)
-{
- ACE_ASSERT (0); // not implemented yet.
-}
-
-ACE_PI_Control_Block::ACE_Malloc_Header::ACE_Malloc_Header (void)
- : next_block_ (0),
- size_ (0)
-{
-}
-
-void
-ACE_PI_Control_Block::ACE_Name_Node::dump (void) const
-{
- ACE_TRACE ("ACE_Name_Node");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("pointer = %x"), (const char *) this->pointer_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nnext_ = %x"), (ACE_Name_Node *) this->next_));
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT("\nname_ = (%x, %s)"),
- (const char *) this->name_,
- (const char *) this->name_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-#endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */
-
-ACE_Allocator *
-ACE_Allocator::instance (void)
-{
- // ACE_TRACE ("ACE_Allocator::instance");
-
- if (ACE_Allocator::allocator_ == 0)
- {
- // Perform Double-Checked Locking Optimization.
- ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
- *ACE_Static_Object_Lock::instance (), 0));
-
- if (ACE_Allocator::allocator_ == 0)
- {
- // Have a seat. We want to avoid ever having to delete the
- // ACE_Allocator instance, to avoid shutdown order
- // dependencies. ACE_New_Allocator never needs to be
- // destroyed: its destructor is empty and its instance
- // doesn't have any state. Therefore, sizeof
- // ACE_New_Allocator is equal to sizeof void *. It's
- // instance just contains a pointer to its virtual function
- // table.
- //
- // So, we allocate space for the ACE_New_Allocator instance
- // in the data segment. Because its size is the same as
- // that of a pointer, we allocate it as a pointer so that it
- // doesn't get constructed statically. We never bother to
- // destroy it.
- static void *allocator_instance = 0;
-
- // Check this critical assumption. We put it in a variable
- // first to avoid stupid compiler warnings that the
- // condition may always be true/false.
-# if !defined (ACE_NDEBUG)
- int assertion = (sizeof allocator_instance ==
- sizeof (ACE_New_Allocator));
- ACE_ASSERT (assertion);
-# endif /* !ACE_NDEBUG */
-
- // Initialize the allocator_instance by using a placement
- // new. The ACE_NEW_RETURN below doesn't actually allocate
- // a new instance. It just initializes it in place.
- ACE_NEW_RETURN (ACE_Allocator::allocator_,
- (&allocator_instance) ACE_New_Allocator,
- 0);
- // If we ever need to cast the address of
- // allocator_instance, then expand the ACE_NEW_RETURN above
- // as follows . . .
- //
- // ACE_Allocator::allocator_ =
- // (ACE_New_Allocator *)
- // new (&allocator_instance) ACE_New_Allocator;
- }
- }
-
- return ACE_Allocator::allocator_;
-}
-
-ACE_Allocator *
-ACE_Allocator::instance (ACE_Allocator *r)
-{
- ACE_TRACE ("ACE_Allocator::instance");
- ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
- *ACE_Static_Object_Lock::instance (), 0));
- ACE_Allocator *t = ACE_Allocator::allocator_;
-
- // We can't safely delete it since we don't know who created it!
- ACE_Allocator::delete_allocator_ = 0;
-
- ACE_Allocator::allocator_ = r;
- return t;
-}
-
-void
-ACE_Allocator::close_singleton (void)
-{
- ACE_TRACE ("ACE_Allocator::close_singleton");
-
- ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon,
- *ACE_Static_Object_Lock::instance ()));
-
- if (ACE_Allocator::delete_allocator_)
- {
- // This should never be executed.... See the
- // ACE_Allocator::instance (void) method for an explanation.
- delete ACE_Allocator::allocator_;
- ACE_Allocator::allocator_ = 0;
- ACE_Allocator::delete_allocator_ = 0;
- }
-}
-
-ACE_Allocator::~ACE_Allocator (void)
-{
- ACE_TRACE ("ACE_Allocator::~ACE_Allocator");
-}
-
-ACE_Allocator::ACE_Allocator (void)
-{
- ACE_TRACE ("ACE_Allocator::ACE_Allocator");
-}
-
-void
-ACE_Static_Allocator_Base::dump (void) const
-{
- ACE_TRACE ("ACE_Static_Base_Allocator::dump");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\noffset_ = %d"), this->offset_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize_ = %d\n"), this->size_));
- ACE_HEX_DUMP ((LM_DEBUG, this->buffer_, this->size_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
-
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-#if defined (ACE_HAS_MALLOC_STATS)
-ACE_Malloc_Stats::ACE_Malloc_Stats (void)
- : nblocks_ (0),
- nchunks_ (0),
- ninuse_ (0)
-{
- ACE_TRACE ("ACE_Malloc_Stats::ACE_Malloc_Stats");
-}
-
-void
-ACE_Malloc_Stats::dump (void) const
-{
- ACE_TRACE ("ACE_Malloc_Stats::print");
-
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- int nblocks = this->nblocks_.value ();
- int ninuse = this->ninuse_.value ();
- int nchunks = this->nchunks_.value ();
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("nblocks = %d"), nblocks));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nninuse = %d"), ninuse));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nnchunks = %d"), nchunks));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Atomic_Op<ACE_PROCESS_MUTEX, int>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Atomic_Op<ACE_PROCESS_MUTEX, int>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_HAS_MALLOC_STATS */
-
-#if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Based_Pointer_Basic<ACE_PI_Control_Block::ACE_Malloc_Header>;
-template class ACE_Based_Pointer_Basic<ACE_PI_Control_Block::ACE_Name_Node>;
-template class ACE_Based_Pointer_Basic<char>;
-template class ACE_Based_Pointer<ACE_PI_Control_Block::ACE_Malloc_Header>;
-template class ACE_Based_Pointer<ACE_PI_Control_Block::ACE_Name_Node>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Based_Pointer_Basic<ACE_PI_Control_Block::ACE_Malloc_Header>
-#pragma instantiate ACE_Based_Pointer_Basic<ACE_PI_Control_Block::ACE_Name_Node>
-#pragma instantiate ACE_Based_Pointer_Basic<char>
-#pragma instantiate ACE_Based_Pointer<ACE_PI_Control_Block::ACE_Malloc_Header>
-#pragma instantiate ACE_Based_Pointer<ACE_PI_Control_Block::ACE_Name_Node>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1*/
-
-#endif /* ACE_MALLOC_CPP */