From 5a355e0c6f083cdbb3756fa3591d8f8a844ab111 Mon Sep 17 00:00:00 2001 From: schmidt Date: Fri, 9 Jun 2006 14:09:14 +0000 Subject: ChangeLogTag:Fri --- ChangeLog | 35 +++++++++++++++ ace/Hash_Map_Manager_T.cpp | 19 ++++---- ace/Hash_Map_Manager_T.h | 93 ++++++++++++++++++++++++++++++--------- ace/Hash_Map_Manager_T.inl | 24 +++++----- ace/Hash_Map_With_Allocator_T.h | 4 ++ ace/Hash_Map_With_Allocator_T.inl | 23 ++++++---- ace/Local_Name_Space_T.cpp | 15 ++++--- ace/Name_Space.h | 3 +- 8 files changed, 163 insertions(+), 53 deletions(-) diff --git a/ChangeLog b/ChangeLog index 5d4f15c4f0c..59aff3f9b4e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,36 @@ +Fri Jun 9 14:06:52 UTC 2006 Douglas C. Schmidt + + * ace/Hash_Map_With_Allocator_T.{h,inl,cpp}: Enhanced this class + so that it compiles with the new "two allocator" + ACE_Hash_Map_Manager_Ex class. This class needs to be improved + so that it actually leverages the two allocator features, but + that's something for the future. + +Fri Jun 9 13:15:38 UTC 2006 Douglas C. Schmidt + + * ace/Hash_Map_Manager_T.h: Clarified the meaning of the + constructor and open() parameters. + +Fri Jun 9 13:07:40 UTC 2006 Douglas C. Schmidt + + * ace/Hash_Map_Manager_T.cpp (open): If the user doesn't supply an + entry_alloc pointer then use the table_alloc pointer. + +Fri Jun 9 13:00:22 UTC 2006 Douglas C. Schmidt + + * ace/Hash_Map_Manager_T.cpp (open): Zapped the use of ACE_ASSERT + and replaced it with and if statement. We shouldn't be using + ACE_ASSERT in ACE library code.. + +Fri Jun 9 12:53:48 UTC 2006 Douglas C. Schmidt + + * ace/Hash_Map_Manager_T.{h,inl,cpp}: Added support for a separate + allocator for creating the entries in the chain of + ACE_Hash_Map_Entry objects in the buckets. There are now two + allocators, one for the bucket table and the other for the + entries in the buckets. Thanks to Jaroslaw Nozderko for this fix. + Fri Jun 9 14:04:12 UTC 2006 Johnny Willemsen * ace/ace_for_tao.mpc: @@ -16,6 +49,7 @@ Fri Jun 9 13:58:12 UTC 2006 Johnny Willemsen * ace/FILE_IO.cpp: Added static cast from ACE_LOFF_T to size_t +>>>>>>> 4.10437 Fri Jun 9 13:42:12 UTC 2006 Johnny Willemsen * ace/OS_NS_sys_stat.inl: @@ -98,6 +132,7 @@ Fri Jun 9 07:55:12 UTC 2006 Johnny Willemsen of bugzilla bug 2359, thanks to Olivier Brunet for reporting this. +>>>>>>> 4.10432 Thu Jun 8 17:13:42 UTC 2006 Douglas C. Schmidt * ace/String_Base.h, diff --git a/ace/Hash_Map_Manager_T.cpp b/ace/Hash_Map_Manager_T.cpp index 4d20b98e16c..eec765cdbeb 100644 --- a/ace/Hash_Map_Manager_T.cpp +++ b/ace/Hash_Map_Manager_T.cpp @@ -9,7 +9,7 @@ // Hash_Map_Manager_T.cpp // // = AUTHOR -// Doug Schmidt +// Douglas C. Schmidt // // ============================================================================ @@ -87,7 +87,8 @@ ACE_Hash_Map_Manager_Ex::dump ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("total_size_ = %d"), this->total_size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ncur_size_ = %d"), this->cur_size_)); - this->allocator_->dump (); + this->table_allocator_->dump (); + this->entry_allocator_->dump (); this->lock_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ @@ -100,7 +101,7 @@ ACE_Hash_Map_Manager_Ex::creat void *ptr; ACE_ALLOCATOR_RETURN (ptr, - this->allocator_->malloc (bytes), + this->table_allocator_->malloc (bytes), -1); this->table_ = (ACE_Hash_Map_Entry *) ptr; @@ -130,10 +131,10 @@ ACE_Hash_Map_Manager_Ex::open if (alloc == 0) alloc = ACE_Allocator::instance (); - this->allocator_ = alloc; + this->table_allocator_ = alloc; if (entry_alloc == 0) - entry_alloc = ACE_Allocator::instance (); + entry_alloc = alloc; this->entry_allocator_ = entry_alloc; @@ -141,7 +142,8 @@ ACE_Hash_Map_Manager_Ex::open // happen, but did with Sun C++ 4.1 (before a change to this class // was made: it used to have an enum that was supposed to be defined // to be ACE_DEFAULT_MAP_SIZE, but instead was defined to be 0). - ACE_ASSERT (size != 0); + if (size != 0) + return -1; return this->create_buckets (size); } @@ -161,7 +163,8 @@ ACE_Hash_Map_Manager_Ex::close { // Destroy the dummy entry. ACE_Hash_Map_Entry *entry = &this->table_[i]; - // The "if" second argument results in a no-op instead of + + // The second argument results in a no-op instead of // deallocation. ACE_DES_FREE_TEMPLATE2 (entry, ACE_NOOP, ACE_Hash_Map_Entry, EXT_ID, INT_ID); @@ -171,7 +174,7 @@ ACE_Hash_Map_Manager_Ex::close this->total_size_ = 0; // Free table memory. - this->allocator_->free (this->table_); + this->table_allocator_->free (this->table_); // Should be done last... this->table_ = 0; diff --git a/ace/Hash_Map_Manager_T.h b/ace/Hash_Map_Manager_T.h index 5a61f717012..2f496ea107a 100644 --- a/ace/Hash_Map_Manager_T.h +++ b/ace/Hash_Map_Manager_T.h @@ -153,18 +153,50 @@ public: // = Initialization and termination methods. - /// Initialize a with default size. - ACE_Hash_Map_Manager_Ex (ACE_Allocator *alloc = 0, + /** + * Initialize a @c Hash_Map_Manager_Ex with default size elements. + * @param table_alloc is a pointer to a memory allocator used for + * table_, so it should supply size*sizeof (ACE_Hash_Map_Entry). + * @param entry_alloc is a pointer to an additional allocator for + * entries, so it should be able to allocate 'size' / chunks + * of sizeof(ACE_Hash_Map_Entry) bytes each. + * If @c table_alloc is 0 it defaults to @c ACE_Allocator::instance(). + * If @c entry_alloc is 0 then it defaults to the same allocator as + * @c table_alloc. + */ + ACE_Hash_Map_Manager_Ex (ACE_Allocator *table_alloc = 0, ACE_Allocator *entry_alloc = 0); - /// Initialize a with size . + /** + * Initialize a @c Hash_Map_Manager_Ex with @c size elements. + * @param table_alloc is a pointer to a memory allocator used for + * table_, so it should supply size*sizeof (ACE_Hash_Map_Entry). + * @param entry_alloc is a pointer to an additional allocator for + * entries, so it should be able to allocate 'size' / chunks + * of sizeof(ACE_Hash_Map_Entry) bytes each. + * If @c table_alloc is 0 it defaults to @c ACE_Allocator::instance(). + * If @c entry_alloc is 0 then it defaults to the same allocator as + * @c table_alloc. + */ ACE_Hash_Map_Manager_Ex (size_t size, - ACE_Allocator *alloc = 0, + ACE_Allocator *table_alloc = 0, ACE_Allocator *entry_alloc = 0); - /// Initialize a with elements. + /** + * Initialize a @c Hash_Map_Manager_Ex with @c size elements. + * @param table_alloc is a pointer to a memory allocator used for + * table_, so it should supply size*sizeof (ACE_Hash_Map_Entry). + * @param entry_alloc is a pointer to an additional allocator for + * entries, so it should be able to allocate 'size' / chunks + * of sizeof(ACE_Hash_Map_Entry) bytes each. + * If @c table_alloc is 0 it defaults to @c ACE_Allocator::instance(). + * If @c entry_alloc is 0 then it defaults to the same allocator as + * @c table_alloc. + * @return -1 on failure, 0 on success + */ + int open (size_t size = ACE_DEFAULT_MAP_SIZE, - ACE_Allocator *alloc = 0, + ACE_Allocator *table_alloc = 0, ACE_Allocator *entry_alloc = 0); /// Close down a and release dynamically allocated @@ -443,19 +475,17 @@ protected: /// locks held. int unbind_all_i (void); - /// Pointer to a memory allocator. - ACE_Allocator *allocator_; + /// Pointer to a memory allocator used for table_, so it should + /// supply size*sizeof (ACE_Hash_Map_Entry), + ACE_Allocator *table_allocator_; - // - default allocator 'allocator_' is used for table_, so it should - // supply size*sizeof (ACE_Hash_Map_Entry), - // - additional allocator 'entry_allocator_' will be used for entries, - // so it should be able to allocate 'size' - // chunks of sizeof(ACE_Hash_Map_Entry) bytes each. - - // Addidtional allocator for entries: + /// Addidtional allocator for entries, so it should be able to + /// allocate 'size' / chunks of sizeof(ACE_Hash_Map_Entry) bytes each. ACE_Allocator *entry_allocator_; - /// Synchronization variable for the MT_SAFE . + /// Synchronization variable for the MT_SAFE + /// @c ACE_Hash_Map_Manager_Ex. ACE_LOCK lock_; /// Function object used for hashing keys. @@ -889,12 +919,35 @@ template class ACE_Hash_Map_Manager : public ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_LOCK> { public: - /// Initialize a with default size. - ACE_Hash_Map_Manager (ACE_Allocator *alloc = 0); - /// Initialize a with size . + /** + * Initialize a @c Hash_Map_Manager with default size elements. + * @param table_alloc is a pointer to a memory allocator used for + * table_, so it should supply size*sizeof (ACE_Hash_Map_Entry). + * @param entry_alloc is a pointer to an additional allocator for + * entries, so it should be able to allocate 'size' / chunks + * of sizeof(ACE_Hash_Map_Entry) bytes each. + * If @c table_alloc is 0 it defaults to @c ACE_Allocator::instance(). + * If @c entry_alloc is 0 then it defaults to the same allocator as + * @c table_alloc. + */ + ACE_Hash_Map_Manager (ACE_Allocator *table_alloc = 0, + ACE_Allocator *entry_alloc = 0); + + /** + * Initialize a @c Hash_Map_Manager with @c size elements. + * @param table_alloc is a pointer to a memory allocator used for + * table_, so it should supply size*sizeof (ACE_Hash_Map_Entry). + * @param entry_alloc is a pointer to an additional allocator for + * entries, so it should be able to allocate 'size' / chunks + * of sizeof(ACE_Hash_Map_Entry) bytes each. + * If @c table_alloc is 0 it defaults to @c ACE_Allocator::instance(). + * If @c entry_alloc is 0 then it defaults to the same allocator as + * @c table_alloc. + */ ACE_Hash_Map_Manager (size_t size, - ACE_Allocator *alloc = 0); + ACE_Allocator *table_alloc = 0, + ACE_Allocator *entry_alloc = 0); // = The following two are necessary for template specialization of // ACE_Hash_Map_Manager to work. diff --git a/ace/Hash_Map_Manager_T.inl b/ace/Hash_Map_Manager_T.inl index 401a526b08b..e3e14a4a490 100644 --- a/ace/Hash_Map_Manager_T.inl +++ b/ace/Hash_Map_Manager_T.inl @@ -8,28 +8,28 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template ACE_INLINE ACE_Hash_Map_Manager_Ex::ACE_Hash_Map_Manager_Ex (size_t size, - ACE_Allocator *alloc, + ACE_Allocator *table_alloc, ACE_Allocator *entry_alloc) - : allocator_ (alloc), + : table_allocator_ (table_alloc), entry_allocator_ (entry_alloc), table_ (0), total_size_ (0), cur_size_ (0) { - if (this->open (size, alloc, entry_alloc) == -1) + if (this->open (size, table_alloc, entry_alloc) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_Hash_Map_Manager_Ex\n"))); } template ACE_INLINE -ACE_Hash_Map_Manager_Ex::ACE_Hash_Map_Manager_Ex (ACE_Allocator *alloc, +ACE_Hash_Map_Manager_Ex::ACE_Hash_Map_Manager_Ex (ACE_Allocator *table_alloc, ACE_Allocator *entry_alloc) - : allocator_ (alloc), + : table_allocator_ (table_alloc), entry_allocator_ (entry_alloc), table_ (0), total_size_ (0), cur_size_ (0) { - if (this->open (ACE_DEFAULT_MAP_SIZE, alloc, entry_alloc) == -1) + if (this->open (ACE_DEFAULT_MAP_SIZE, table_alloc, entry_alloc) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_Hash_Map_Manager_Ex\n"))); } @@ -924,16 +924,20 @@ ACE_Hash_Map_Reverse_Iterator_Ex -ACE_Hash_Map_Manager::ACE_Hash_Map_Manager (ACE_Allocator *alloc) - : ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_LOCK> (alloc) +ACE_Hash_Map_Manager::ACE_Hash_Map_Manager (ACE_Allocator *table_alloc, + ACE_Allocator *entry_alloc) + : ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_LOCK> (table_alloc, + entry_alloc) { } template ACE_Hash_Map_Manager::ACE_Hash_Map_Manager (size_t size, - ACE_Allocator *alloc) + ACE_Allocator *table_alloc, + ACE_Allocator *entry_alloc) : ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_LOCK> (size, - alloc) + table_alloc, + entry_alloc) { } diff --git a/ace/Hash_Map_With_Allocator_T.h b/ace/Hash_Map_With_Allocator_T.h index 088956b48a1..1c2413ba3f2 100644 --- a/ace/Hash_Map_With_Allocator_T.h +++ b/ace/Hash_Map_With_Allocator_T.h @@ -42,6 +42,10 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL * is meaningful! That is why we need this wrapper, which * insures that appropriate allocator pointer is in place for * each call. + * + * At some point it would be a good idea to update this class to + * use the new "two allocator" technique provided by @c + * ACE_Hash_Map_Manager_Ex. */ template class ACE_Hash_Map_With_Allocator : diff --git a/ace/Hash_Map_With_Allocator_T.inl b/ace/Hash_Map_With_Allocator_T.inl index 67f2f8247f8..4ba51437abf 100644 --- a/ace/Hash_Map_With_Allocator_T.inl +++ b/ace/Hash_Map_With_Allocator_T.inl @@ -1,5 +1,5 @@ // -*- C++ -*- -// + // $Id$ ACE_BEGIN_VERSIONED_NAMESPACE_DECL @@ -8,7 +8,8 @@ template ACE_INLINE int ACE_Hash_Map_With_Allocator::close (ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::close"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->close_i (); } @@ -18,7 +19,8 @@ ACE_Hash_Map_With_Allocator::bind (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::bind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->bind_i (ext_id, int_id); } @@ -28,7 +30,8 @@ ACE_Hash_Map_With_Allocator::unbind (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::unbind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->unbind_i (ext_id, int_id); } @@ -37,7 +40,8 @@ ACE_Hash_Map_With_Allocator::unbind (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::unbind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->unbind_i (ext_id); } @@ -49,7 +53,8 @@ ACE_Hash_Map_With_Allocator::rebind (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::rebind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->rebind_i (ext_id, int_id, old_ext_id, old_int_id); } @@ -59,7 +64,8 @@ ACE_Hash_Map_With_Allocator::find (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::find"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->find_i (ext_id, int_id); } @@ -68,7 +74,8 @@ ACE_Hash_Map_With_Allocator::find (const EXT_ID &ext_id, ACE_Allocator *alloc) { ACE_TRACE ("ACE_Hash_Map_With_Allocator::find"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->find_i (ext_id); } diff --git a/ace/Local_Name_Space_T.cpp b/ace/Local_Name_Space_T.cpp index 28266896f5a..dbc0121f231 100644 --- a/ace/Local_Name_Space_T.cpp +++ b/ace/Local_Name_Space_T.cpp @@ -30,7 +30,8 @@ ACE_Name_Space_Map::close (ALLOCATOR *alloc) { ACE_TRACE ("ACE_Name_Space_Map::close"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->close_i (); } @@ -41,7 +42,8 @@ ACE_Name_Space_Map::bind (const ACE_NS_String &ext_id, { ACE_TRACE ("ACE_Name_Space_Map::bind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->bind_i (ext_id, int_id); } @@ -52,7 +54,8 @@ ACE_Name_Space_Map::unbind (const ACE_NS_String &ext_id, { ACE_TRACE ("ACE_Name_Space_Map::unbind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->unbind_i (ext_id, int_id); } @@ -65,7 +68,8 @@ ACE_Name_Space_Map::rebind (const ACE_NS_String &ext_id, { ACE_TRACE ("ACE_Name_Space_Map::rebind"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->rebind_i (ext_id, int_id, old_ext_id, old_int_id); } @@ -76,7 +80,8 @@ ACE_Name_Space_Map::find (const ACE_NS_String &ext_id, { ACE_TRACE ("ACE_Name_Space_Map::find"); - this->allocator_ = alloc; + this->table_allocator_ = alloc; + this->entry_allocator_ = alloc; return this->find_i (ext_id, int_id); } diff --git a/ace/Name_Space.h b/ace/Name_Space.h index 18bda096326..134d04e8682 100644 --- a/ace/Name_Space.h +++ b/ace/Name_Space.h @@ -6,11 +6,10 @@ * * $Id$ * - * @author Prashant Jain + * @author Prashant Jain */ //========================================================================== - #ifndef ACE_NAME_SPACE_H #define ACE_NAME_SPACE_H -- cgit v1.2.1