dummy_node renamed to aux_node

[libcds.git] / cds / intrusive / split_list.h

diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h
index 8adce76abdb68be061054d3ac0dc30e057c57171..303f7e9eaf246f0ed52970c8eb525f7fff687ebe 100644 (file)
--- 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<list_node_type>    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 <typename Func>
-            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 <typename Func>
-            std::pair<bool, bool> update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert )
+            std::pair<bool, bool> 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 <typename Q, typename Compare, typename Func>
-            bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp, Func f )
+            bool erase_at( aux_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp, Func f )
             {
                 assert( pHead != nullptr );
                 bucket_head_type h(pHead);
@@ -326,7 +326,7 @@ namespace cds { namespace intrusive {
             }
 
             template <typename Q, typename Compare>
-            bool erase_at( dummy_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
+            bool erase_at( aux_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
             {
                 assert( pHead != nullptr );
                 bucket_head_type h(pHead);
@@ -334,7 +334,7 @@ namespace cds { namespace intrusive {
             }
 
             template <typename Q, typename Compare>
-            guarded_ptr extract_at( dummy_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
+            guarded_ptr extract_at( aux_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
             {
                 assert( pHead != nullptr );
                 bucket_head_type h(pHead);
@@ -342,7 +342,7 @@ namespace cds { namespace intrusive {
             }
 
             template <typename Q, typename Compare, typename Func>
-            bool find_at( dummy_node_type * pHead, split_list::details::search_value_type<Q>& val, Compare cmp, Func f )
+            bool find_at( aux_node_type * pHead, split_list::details::search_value_type<Q>& val, Compare cmp, Func f )
             {
                 assert( pHead != nullptr );
                 bucket_head_type h(pHead);
@@ -350,7 +350,7 @@ namespace cds { namespace intrusive {
             }
 
             template <typename Q, typename Compare>
-            bool find_at( dummy_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
+            bool find_at( aux_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
             {
                 assert( pHead != nullptr );
                 bucket_head_type h(pHead);
@@ -358,18 +358,18 @@ namespace cds { namespace intrusive {
             }
 
             template <typename Q, typename Compare>
-            guarded_ptr get_at( dummy_node_type * pHead, split_list::details::search_value_type<Q> const& val, Compare cmp )
+            guarded_ptr get_at( aux_node_type * pHead, split_list::details::search_value_type<Q> 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<bool, bool> 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<dummy_node_type *>(p);
+                    return const_cast<aux_node_type *>(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<Q>  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<Q const>  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<Q const>  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<Q const>  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<Q const>  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<Q const> 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 );