From eb9f6566c16b481e1ac6bb516097fc0bdc2a55c6 Mon Sep 17 00:00:00 2001 From: khizmax Date: Wed, 7 Sep 2016 23:36:04 +0300 Subject: [PATCH] dummy_node renamed to aux_node --- cds/intrusive/split_list.h | 76 ++++++++++++++++----------------- cds/intrusive/split_list_nogc.h | 54 +++++++++++------------ cds/intrusive/split_list_rcu.h | 76 ++++++++++++++++----------------- 3 files changed, 103 insertions(+), 103 deletions(-) diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h index 8adce76a..303f7e9e 100644 --- a/cds/intrusive/split_list.h +++ b/cds/intrusive/split_list.h @@ -257,7 +257,7 @@ namespace cds { namespace intrusive { //@cond typedef typename ordered_list::node_type list_node_type; ///< Node type as declared in ordered list typedef split_list::node node_type; ///< split-list node type - typedef node_type dummy_node_type; ///< dummy node type + typedef node_type aux_node_type; ///< dummy node type /// Split-list node traits /** @@ -270,12 +270,12 @@ namespace cds { namespace intrusive { typedef typename split_list::details::bucket_table_selector< traits::dynamic_bucket_table , gc - , dummy_node_type + , aux_node_type , opt::allocator< typename traits::allocator > , opt::memory_model< memory_model > >::type bucket_table; - typedef cds::details::Allocator< dummy_node_type, typename traits::allocator > dummy_node_allocator; + typedef cds::details::Allocator< aux_node_type, typename traits::allocator > aux_node_allocator; //@endcond protected: @@ -287,7 +287,7 @@ namespace cds { namespace intrusive { typedef typename base_class::auxiliary_head bucket_head_type; public: - bool insert_at( dummy_node_type * pHead, value_type& val ) + bool insert_at( aux_node_type * pHead, value_type& val ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -295,7 +295,7 @@ namespace cds { namespace intrusive { } template - bool insert_at( dummy_node_type * pHead, value_type& val, Func f ) + bool insert_at( aux_node_type * pHead, value_type& val, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -303,14 +303,14 @@ namespace cds { namespace intrusive { } template - std::pair update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) + std::pair update_at( aux_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) { assert( pHead != nullptr ); bucket_head_type h(pHead); return base_class::update_at( h, val, func, bAllowInsert ); } - bool unlink_at( dummy_node_type * pHead, value_type& val ) + bool unlink_at( aux_node_type * pHead, value_type& val ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -318,7 +318,7 @@ namespace cds { namespace intrusive { } template - bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp, Func f ) + bool erase_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -326,7 +326,7 @@ namespace cds { namespace intrusive { } template - bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) + bool erase_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -334,7 +334,7 @@ namespace cds { namespace intrusive { } template - guarded_ptr extract_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) + guarded_ptr extract_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -342,7 +342,7 @@ namespace cds { namespace intrusive { } template - bool find_at( dummy_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) + bool find_at( aux_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -350,7 +350,7 @@ namespace cds { namespace intrusive { } template - bool find_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) + bool find_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -358,18 +358,18 @@ namespace cds { namespace intrusive { } template - guarded_ptr get_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) + guarded_ptr get_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); return base_class::get_at( h, val, cmp ); } - bool insert_aux_node( dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pNode ) { return base_class::insert_aux_node( pNode ); } - bool insert_aux_node( dummy_node_type * pHead, dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pHead, aux_node_type * pNode ) { bucket_head_type h(pHead); return base_class::insert_aux_node( h, pNode ); @@ -414,7 +414,7 @@ namespace cds { namespace intrusive { bool insert( value_type& val ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -452,7 +452,7 @@ namespace cds { namespace intrusive { bool insert( value_type& val, Func f ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -498,7 +498,7 @@ namespace cds { namespace intrusive { std::pair update( value_type& val, Func func, bool bAllowInsert = true ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -536,7 +536,7 @@ namespace cds { namespace intrusive { bool unlink( value_type& val ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.unlink_at( pHead, val )) { @@ -950,14 +950,14 @@ namespace cds { namespace intrusive { protected: //@cond - dummy_node_type * alloc_dummy_node( size_t nHash ) + aux_node_type * alloc_aux_node( size_t nHash ) { m_Stat.onHeadNodeAllocated(); - return dummy_node_allocator().New( nHash ); + return aux_node_allocator().New( nHash ); } - void free_dummy_node( dummy_node_type * p ) + void free_aux_node( aux_node_type * p ) { - dummy_node_allocator().Delete( p ); + aux_node_allocator().Delete( p ); m_Stat.onHeadNodeFreed(); } @@ -979,12 +979,12 @@ namespace cds { namespace intrusive { return nBucket & ~(1 << bitop::MSBnz( nBucket )); } - dummy_node_type * init_bucket( size_t nBucket ) + aux_node_type * init_bucket( size_t nBucket ) { assert( nBucket > 0 ); size_t nParent = parent_bucket( nBucket ); - dummy_node_type * pParentBucket = m_Buckets.bucket( nParent ); + aux_node_type * pParentBucket = m_Buckets.bucket( nParent ); if ( pParentBucket == nullptr ) { pParentBucket = init_bucket( nParent ); m_Stat.onRecursiveInitBucket(); @@ -994,13 +994,13 @@ namespace cds { namespace intrusive { // Allocate a dummy node for new bucket { - dummy_node_type * pBucket = alloc_dummy_node( split_list::dummy_hash( nBucket ) ); + aux_node_type * pBucket = alloc_aux_node( split_list::dummy_hash( nBucket ) ); if ( m_List.insert_aux_node( pParentBucket, pBucket ) ) { m_Buckets.bucket( nBucket, pBucket ); m_Stat.onNewBucket(); return pBucket; } - free_dummy_node( pBucket ); + free_aux_node( pBucket ); } // Another thread set the bucket. Wait while it done @@ -1011,19 +1011,19 @@ namespace cds { namespace intrusive { m_Stat.onBucketInitContenton(); back_off bkoff; while ( true ) { - dummy_node_type volatile * p = m_Buckets.bucket( nBucket ); + aux_node_type volatile * p = m_Buckets.bucket( nBucket ); if ( p != nullptr ) - return const_cast(p); + return const_cast(p); bkoff(); m_Stat.onBusyWaitBucketInit(); } } - dummy_node_type * get_bucket( size_t nHash ) + aux_node_type * get_bucket( size_t nHash ) { size_t nBucket = bucket_no( nHash ); - dummy_node_type * pHead = m_Buckets.bucket( nBucket ); + aux_node_type * pHead = m_Buckets.bucket( nBucket ); if ( pHead == nullptr ) pHead = init_bucket( nBucket ); @@ -1042,7 +1042,7 @@ namespace cds { namespace intrusive { "cds::atomicity::empty_item_counter is not allowed as a item counter"); // Initialize bucket 0 - dummy_node_type * pNode = alloc_dummy_node( 0 /*split_list::dummy_hash(0)*/ ); + aux_node_type * pNode = alloc_aux_node( 0 /*split_list::dummy_hash(0)*/ ); // insert_aux_node cannot return false for empty list CDS_VERIFY( m_List.insert_aux_node( pNode ) ); @@ -1082,7 +1082,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); return m_Stat.onFind( @@ -1096,7 +1096,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); return m_Stat.onFind( m_List.find_at( pHead, sv, cmp ) ); @@ -1107,7 +1107,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); guarded_ptr gp = m_List.get_at( pHead, sv, cmp ); @@ -1132,7 +1132,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.erase_at( pHead, sv, cmp, f ) ) { @@ -1149,7 +1149,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.erase_at( pHead, sv, cmp ) ) { @@ -1166,7 +1166,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash ) ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); guarded_ptr gp = m_List.extract_at( pHead, sv, cmp ); diff --git a/cds/intrusive/split_list_nogc.h b/cds/intrusive/split_list_nogc.h index 7729950d..a1bb3be7 100644 --- a/cds/intrusive/split_list_nogc.h +++ b/cds/intrusive/split_list_nogc.h @@ -90,7 +90,7 @@ namespace cds { namespace intrusive { protected: typedef typename ordered_list::node_type list_node_type; ///< Node type as declared in ordered list typedef split_list::node node_type; ///< split-list node type - typedef node_type dummy_node_type; ///< dummy node type + typedef node_type aux_node_type; ///< dummy node type /// Split-list node traits /** @@ -104,7 +104,7 @@ namespace cds { namespace intrusive { typedef typename split_list::details::bucket_table_selector< traits::dynamic_bucket_table , gc - , dummy_node_type + , aux_node_type , opt::allocator< typename traits::allocator > , opt::memory_model< memory_model > >::type bucket_table; @@ -122,7 +122,7 @@ namespace cds { namespace intrusive { typedef typename base_class::auxiliary_head bucket_head_type; public: - list_iterator insert_at_( dummy_node_type * pHead, value_type& val ) + list_iterator insert_at_( aux_node_type * pHead, value_type& val ) { assert( pHead != nullptr ); bucket_head_type h(static_cast(pHead)); @@ -130,7 +130,7 @@ namespace cds { namespace intrusive { } template - std::pair update_at_( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) + std::pair update_at_( aux_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) { assert( pHead != nullptr ); bucket_head_type h(static_cast(pHead)); @@ -138,7 +138,7 @@ namespace cds { namespace intrusive { } template - bool find_at( dummy_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) + bool find_at( aux_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) { assert( pHead != nullptr ); bucket_head_type h(static_cast(pHead)); @@ -146,18 +146,18 @@ namespace cds { namespace intrusive { } template - list_iterator find_at_( dummy_node_type * pHead, split_list::details::search_value_type const & val, Compare cmp ) + list_iterator find_at_( aux_node_type * pHead, split_list::details::search_value_type const & val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(static_cast(pHead)); return base_class::find_at_( h, val, cmp ); } - bool insert_aux_node( dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pNode ) { return base_class::insert_aux_node( pNode ); } - bool insert_aux_node( dummy_node_type * pHead, dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pHead, aux_node_type * pNode ) { bucket_head_type h(static_cast(pHead)); return base_class::insert_aux_node( h, pNode ); @@ -183,16 +183,16 @@ namespace cds { namespace intrusive { protected: //@cond - typedef cds::details::Allocator< dummy_node_type, typename traits::allocator > dummy_node_allocator; + typedef cds::details::Allocator< aux_node_type, typename traits::allocator > aux_node_allocator; - dummy_node_type * alloc_dummy_node( size_t nHash ) + aux_node_type * alloc_aux_node( size_t nHash ) { m_Stat.onHeadNodeAllocated(); - return dummy_node_allocator().New( nHash ); + return aux_node_allocator().New( nHash ); } - void free_dummy_node( dummy_node_type * p ) + void free_aux_node( aux_node_type * p ) { - dummy_node_allocator().Delete( p ); + aux_node_allocator().Delete( p ); m_Stat.onHeadNodeFreed(); } @@ -214,12 +214,12 @@ namespace cds { namespace intrusive { return nBucket & ~( 1 << bitop::MSBnz( nBucket ) ); } - dummy_node_type * init_bucket( size_t nBucket ) + aux_node_type * init_bucket( size_t nBucket ) { assert( nBucket > 0 ); size_t nParent = parent_bucket( nBucket ); - dummy_node_type * pParentBucket = m_Buckets.bucket( nParent ); + aux_node_type * pParentBucket = m_Buckets.bucket( nParent ); if ( pParentBucket == nullptr ) { pParentBucket = init_bucket( nParent ); m_Stat.onRecursiveInitBucket(); @@ -229,13 +229,13 @@ namespace cds { namespace intrusive { // Allocate a dummy node for new bucket { - dummy_node_type * pBucket = alloc_dummy_node( split_list::dummy_hash( nBucket ) ); + aux_node_type * pBucket = alloc_aux_node( split_list::dummy_hash( nBucket ) ); if ( m_List.insert_aux_node( pParentBucket, pBucket ) ) { m_Buckets.bucket( nBucket, pBucket ); m_Stat.onNewBucket(); return pBucket; } - free_dummy_node( pBucket ); + free_aux_node( pBucket ); } // Another thread set the bucket. Wait while it done @@ -247,19 +247,19 @@ namespace cds { namespace intrusive { m_Stat.onBucketInitContenton(); back_off bkoff; while ( true ) { - dummy_node_type volatile * p = m_Buckets.bucket( nBucket ); + aux_node_type volatile * p = m_Buckets.bucket( nBucket ); if ( p && p != nullptr ) - return const_cast( p ); + return const_cast( p ); bkoff(); m_Stat.onBusyWaitBucketInit(); } } - dummy_node_type * get_bucket( size_t nHash ) + aux_node_type * get_bucket( size_t nHash ) { size_t nBucket = bucket_no( nHash ); - dummy_node_type * pHead = m_Buckets.bucket( nBucket ); + aux_node_type * pHead = m_Buckets.bucket( nBucket ); if ( pHead == nullptr ) pHead = init_bucket( nBucket ); @@ -278,7 +278,7 @@ namespace cds { namespace intrusive { "cds::atomicity::empty_item_counter is not allowed as a item counter"); // Initialize bucket 0 - dummy_node_type * pNode = alloc_dummy_node( 0 /*split_list::dummy_hash(0)*/ ); + aux_node_type * pNode = alloc_aux_node( 0 /*split_list::dummy_hash(0)*/ ); // insert_aux_node cannot return false for empty list CDS_VERIFY( m_List.insert_aux_node( pNode )); @@ -632,7 +632,7 @@ namespace cds { namespace intrusive { iterator insert_( value_type& val ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -651,7 +651,7 @@ namespace cds { namespace intrusive { std::pair update_( value_type& val, Func func, bool bAllowInsert ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -675,7 +675,7 @@ namespace cds { namespace intrusive { CDS_UNUSED( pred ); size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); auto it = m_List.find_at_( pHead, sv, typename wrapped_ordered_list::template make_compare_from_less() ); @@ -688,7 +688,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); auto it = m_List.find_at_( pHead, sv, key_comparator() ); @@ -701,7 +701,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); return m_Stat.onFind( m_List.find_at( pHead, sv, cmp, [&f](value_type& item, split_list::details::search_value_type& val){ f(item, val.val ); })); diff --git a/cds/intrusive/split_list_rcu.h b/cds/intrusive/split_list_rcu.h index ba461df6..6f264cce 100644 --- a/cds/intrusive/split_list_rcu.h +++ b/cds/intrusive/split_list_rcu.h @@ -126,7 +126,7 @@ namespace cds { namespace intrusive { protected: typedef typename ordered_list::node_type list_node_type; ///< Node type as declared in ordered list typedef split_list::node node_type; ///< split-list node type - typedef node_type dummy_node_type; ///< dummy node type + typedef node_type aux_node_type; ///< dummy node type /// Split-list node traits /** @@ -140,7 +140,7 @@ namespace cds { namespace intrusive { typedef typename split_list::details::bucket_table_selector< traits::dynamic_bucket_table , gc - , dummy_node_type + , aux_node_type , opt::allocator< typename traits::allocator > , opt::memory_model< memory_model > >::type bucket_table; @@ -156,7 +156,7 @@ namespace cds { namespace intrusive { typedef typename base_class::auxiliary_head bucket_head_type; public: - bool insert_at( dummy_node_type * pHead, value_type& val ) + bool insert_at( aux_node_type * pHead, value_type& val ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -164,7 +164,7 @@ namespace cds { namespace intrusive { } template - bool insert_at( dummy_node_type * pHead, value_type& val, Func f ) + bool insert_at( aux_node_type * pHead, value_type& val, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -172,14 +172,14 @@ namespace cds { namespace intrusive { } template - std::pair update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) + std::pair update_at( aux_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) { assert( pHead != nullptr ); bucket_head_type h(pHead); return base_class::update_at( h, val, func, bAllowInsert ); } - bool unlink_at( dummy_node_type * pHead, value_type& val ) + bool unlink_at( aux_node_type * pHead, value_type& val ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -187,7 +187,7 @@ namespace cds { namespace intrusive { } template - bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp, Func f ) + bool erase_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -195,7 +195,7 @@ namespace cds { namespace intrusive { } template - bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) + bool erase_at( aux_node_type * pHead, split_list::details::search_value_type const& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -203,7 +203,7 @@ namespace cds { namespace intrusive { } template - value_type * extract_at( dummy_node_type * pHead, split_list::details::search_value_type& val, Compare cmp ) + value_type * extract_at( aux_node_type * pHead, split_list::details::search_value_type& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -211,7 +211,7 @@ namespace cds { namespace intrusive { } template - bool find_at( dummy_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) + bool find_at( aux_node_type * pHead, split_list::details::search_value_type& val, Compare cmp, Func f ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -219,7 +219,7 @@ namespace cds { namespace intrusive { } template - bool find_at( dummy_node_type * pHead, split_list::details::search_value_type const & val, Compare cmp ) + bool find_at( aux_node_type * pHead, split_list::details::search_value_type const & val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); @@ -227,18 +227,18 @@ namespace cds { namespace intrusive { } template - raw_ptr get_at( dummy_node_type * pHead, split_list::details::search_value_type& val, Compare cmp ) + raw_ptr get_at( aux_node_type * pHead, split_list::details::search_value_type& val, Compare cmp ) { assert( pHead != nullptr ); bucket_head_type h(pHead); return base_class::get_at( h, val, cmp ); } - bool insert_aux_node( dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pNode ) { return base_class::insert_aux_node( pNode ); } - bool insert_aux_node( dummy_node_type * pHead, dummy_node_type * pNode ) + bool insert_aux_node( aux_node_type * pHead, aux_node_type * pNode ) { bucket_head_type h(pHead); return base_class::insert_aux_node( h, pNode ); @@ -275,16 +275,16 @@ namespace cds { namespace intrusive { protected: //@cond - typedef cds::details::Allocator< dummy_node_type, typename traits::allocator > dummy_node_allocator; + typedef cds::details::Allocator< aux_node_type, typename traits::allocator > aux_node_allocator; - dummy_node_type * alloc_dummy_node( size_t nHash ) + aux_node_type * alloc_aux_node( size_t nHash ) { m_Stat.onHeadNodeAllocated(); - return dummy_node_allocator().New( nHash ); + return aux_node_allocator().New( nHash ); } - void free_dummy_node( dummy_node_type * p ) + void free_aux_node( aux_node_type * p ) { - dummy_node_allocator().Delete( p ); + aux_node_allocator().Delete( p ); m_Stat.onHeadNodeFreed(); } @@ -306,12 +306,12 @@ namespace cds { namespace intrusive { return nBucket & ~( 1 << bitop::MSBnz( nBucket ) ); } - dummy_node_type * init_bucket( size_t nBucket ) + aux_node_type * init_bucket( size_t nBucket ) { assert( nBucket > 0 ); size_t nParent = parent_bucket( nBucket ); - dummy_node_type * pParentBucket = m_Buckets.bucket( nParent ); + aux_node_type * pParentBucket = m_Buckets.bucket( nParent ); if ( pParentBucket == nullptr ) { pParentBucket = init_bucket( nParent ); m_Stat.onRecursiveInitBucket(); @@ -321,13 +321,13 @@ namespace cds { namespace intrusive { // Allocate a dummy node for new bucket { - dummy_node_type * pBucket = alloc_dummy_node( split_list::dummy_hash( nBucket ) ); + aux_node_type * pBucket = alloc_aux_node( split_list::dummy_hash( nBucket ) ); if ( m_List.insert_aux_node( pParentBucket, pBucket ) ) { m_Buckets.bucket( nBucket, pBucket ); m_Stat.onNewBucket(); return pBucket; } - free_dummy_node( pBucket ); + free_aux_node( pBucket ); } // Another thread set the bucket. Wait while it done @@ -339,19 +339,19 @@ namespace cds { namespace intrusive { m_Stat.onBucketInitContenton(); back_off bkoff; while ( true ) { - dummy_node_type volatile * p = m_Buckets.bucket( nBucket ); + aux_node_type volatile * p = m_Buckets.bucket( nBucket ); if ( p != nullptr ) - return const_cast( p ); + return const_cast( p ); bkoff(); m_Stat.onBusyWaitBucketInit(); } } - dummy_node_type * get_bucket( size_t nHash ) + aux_node_type * get_bucket( size_t nHash ) { size_t nBucket = bucket_no( nHash ); - dummy_node_type * pHead = m_Buckets.bucket( nBucket ); + aux_node_type * pHead = m_Buckets.bucket( nBucket ); if ( pHead == nullptr ) pHead = init_bucket( nBucket ); @@ -370,7 +370,7 @@ namespace cds { namespace intrusive { "cds::atomicity::empty_item_counter is not allowed as a item counter"); // Initialize bucket 0 - dummy_node_type * pNode = alloc_dummy_node( 0 /*split_list::dummy_hash(0)*/ ); + aux_node_type * pNode = alloc_aux_node( 0 /*split_list::dummy_hash(0)*/ ); // insert_aux_node cannot return false for empty list CDS_VERIFY( m_List.insert_aux_node( pNode )); @@ -410,7 +410,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); return m_Stat.onFind( m_List.find_at( pHead, sv, cmp, @@ -422,7 +422,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); return m_Stat.onFind( m_List.find_at( pHead, sv, cmp )); @@ -433,7 +433,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); raw_ptr p = m_List.get_at( pHead, sv, cmp ); @@ -446,7 +446,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); value_type * pNode = m_List.extract_at( pHead, sv, cmp ); @@ -471,7 +471,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.erase_at( pHead, sv, cmp ) ) { @@ -488,7 +488,7 @@ namespace cds { namespace intrusive { { size_t nHash = hash_value( val ); split_list::details::search_value_type sv( val, split_list::regular_hash( nHash )); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.erase_at( pHead, sv, cmp, f )) { @@ -541,7 +541,7 @@ namespace cds { namespace intrusive { bool insert( value_type& val ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -580,7 +580,7 @@ namespace cds { namespace intrusive { bool insert( value_type& val, Func f ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -628,7 +628,7 @@ namespace cds { namespace intrusive { std::pair update( value_type& val, Func func, bool bAllowInsert = true ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); @@ -668,7 +668,7 @@ namespace cds { namespace intrusive { bool unlink( value_type& val ) { size_t nHash = hash_value( val ); - dummy_node_type * pHead = get_bucket( nHash ); + aux_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); if ( m_List.unlink_at( pHead, val ) ) { -- 2.34.1