X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=cds%2Fintrusive%2Fsplit_list.h;h=9a7e198e55a61d31bacc2671a1557cb0b22b074c;hb=cd515d6402be81b84e2eb0c9d4cf0a1ca9e4d95a;hp=4a560c57681620d89414b2387477051e60767951;hpb=e76a6bdaaeceb88c2b496e3c404db55f3c6b0939;p=libcds.git diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h index 4a560c57..9a7e198e 100644 --- a/cds/intrusive/split_list.h +++ b/cds/intrusive/split_list.h @@ -1,8 +1,37 @@ -//$$CDS-header$$ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ #ifndef CDSLIB_INTRUSIVE_SPLIT_LIST_H #define CDSLIB_INTRUSIVE_SPLIT_LIST_H +#include #include namespace cds { namespace intrusive { @@ -24,23 +53,23 @@ namespace cds { namespace intrusive { [from [2003] Ori Shalev, Nir Shavit "Split-Ordered Lists - Lock-free Resizable Hash Tables"] The algorithm keeps all the items in one lock-free linked list, and gradually assigns the bucket pointers to - the places in the list where a sublist of “correct” items can be found. A bucket is initialized upon first - access by assigning it to a new “dummy” node (dashed contour) in the list, preceding all items that should be - in that bucket. A newly created bucket splits an older bucket’s chain, reducing the access cost to its items. The - table uses a modulo 2**i hash (there are known techniques for “pre-hashing” before a modulo 2**i hash + the places in the list where a sublist of 'correct' items can be found. A bucket is initialized upon first + access by assigning it to a new 'dummy' node (dashed contour) in the list, preceding all items that should be + in that bucket. A newly created bucket splits an older bucket's chain, reducing the access cost to its items. The + table uses a modulo 2**i hash (there are known techniques for 'pre-hashing' before a modulo 2**i hash to overcome possible binary correlations among values). The table starts at size 2 and repeatedly doubles in size. Unlike moving an item, the operation of directing a bucket pointer can be done - in a single CAS operation, and since items are not moved, they are never “lost”. + in a single CAS operation, and since items are not moved, they are never 'lost'. However, to make this approach work, one must be able to keep the items in the - list sorted in such a way that any bucket’s sublist can be “split” by directing a new + list sorted in such a way that any bucket's sublist can be 'split' by directing a new bucket pointer within it. This operation must be recursively repeatable, as every split bucket may be split again and again as the hash table grows. To achieve this goal the authors introduced recursive split-ordering, a new ordering on keys that keeps items in a given bucket adjacent in the list throughout the repeated splitting process. Magically, yet perhaps not surprisingly, recursive split-ordering is achieved by - simple binary reversal: reversing the bits of the hash key so that the new key’s + simple binary reversal: reversing the bits of the hash key so that the new key's most significant bits (MSB) are those that were originally its least significant. The split-order keys of regular nodes are exactly the bit-reverse image of the original keys after turning on their MSB. For example, items 9 and 13 are in the 1 mod @@ -49,7 +78,7 @@ namespace cds { namespace intrusive { To insert (respectively delete or search for) an item in the hash table, hash its key to the appropriate bucket using recursive split-ordering, follow the pointer to - the appropriate location in the sorted items list, and traverse the list until the key’s + the appropriate location in the sorted items list, and traverse the list until the key's proper location in the split-ordering (respectively until the key or a key indicating the item is not in the list is found). Because of the combinatorial structure induced by the split-ordering, this will require traversal of no more than an expected constant number of items. @@ -195,10 +224,6 @@ namespace cds { namespace intrusive { typedef GC gc; ///< Garbage collector typedef Traits traits; ///< Set traits - //@cond - typedef cds::intrusive::split_list::implementation_tag implementation_tag; - //@endcond - protected: //@cond typedef split_list::details::rebind_list_traits wrapped_ordered_list; @@ -271,11 +296,11 @@ namespace cds { namespace intrusive { } template - std::pair ensure_at( dummy_node_type * pHead, value_type& val, Func func ) + std::pair update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert ) { assert( pHead != nullptr ); bucket_head_type h(pHead); - return base_class::ensure_at( h, val, func ); + return base_class::update_at( h, val, func, bAllowInsert ); } bool unlink_at( dummy_node_type * pHead, value_type& val ) @@ -349,6 +374,7 @@ namespace cds { namespace intrusive { ordered_list_wrapper m_List; ///< Ordered list containing split-list items bucket_table m_Buckets; ///< bucket table atomics::atomic m_nBucketCountLog2; ///< log2( current bucket count ) + atomics::atomic m_nMaxItemCount; ///< number of items container can hold, before we have to resize item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor stat m_Stat; ///< Internal statistics @@ -383,7 +409,7 @@ namespace cds { namespace intrusive { static size_t parent_bucket( size_t nBucket ) { assert( nBucket > 0 ); - return nBucket & ~( 1 << bitop::MSBnz( nBucket ) ); + return nBucket & ~( 1 << bitop::MSBnz( nBucket )); } dummy_node_type * init_bucket( size_t nBucket ) @@ -401,8 +427,8 @@ namespace cds { namespace intrusive { // Allocate a dummy node for new bucket { - dummy_node_type * pBucket = alloc_dummy_node( split_list::dummy_hash( nBucket ) ); - if ( m_List.insert_aux_node( pParentBucket, pBucket ) ) { + dummy_node_type * pBucket = alloc_dummy_node( split_list::dummy_hash( nBucket )); + if ( m_List.insert_aux_node( pParentBucket, pBucket )) { m_Buckets.bucket( nBucket, pBucket ); m_Stat.onNewBucket(); return pBucket; @@ -434,7 +460,7 @@ namespace cds { namespace intrusive { if ( pHead == nullptr ) pHead = init_bucket( nBucket ); - assert( pHead->is_dummy() ); + assert( pHead->is_dummy()); return pHead; } @@ -457,13 +483,31 @@ namespace cds { namespace intrusive { m_Buckets.bucket( 0, pNode ); } + static size_t max_item_count( size_t nBucketCount, size_t nLoadFactor ) + { + return nBucketCount * nLoadFactor; + } + void inc_item_count() { + size_t nMaxCount = m_nMaxItemCount.load(memory_model::memory_order_relaxed); + if ( ++m_ItemCounter <= nMaxCount ) + return; + size_t sz = m_nBucketCountLog2.load(memory_model::memory_order_relaxed); - if ( ( ++m_ItemCounter >> sz ) > m_Buckets.load_factor() && ((size_t)(1 << sz )) < m_Buckets.capacity() ) - { + const size_t nBucketCount = static_cast(1) << sz; + if ( nBucketCount < m_Buckets.capacity()) { + // we may grow the bucket table + const size_t nLoadFactor = m_Buckets.load_factor(); + if ( nMaxCount < max_item_count( nBucketCount, nLoadFactor )) + return; // someone already have updated m_nBucketCountLog2, so stop here + + m_nMaxItemCount.compare_exchange_strong( nMaxCount, max_item_count( nBucketCount << 1, nLoadFactor ), + memory_model::memory_order_relaxed, atomics::memory_order_relaxed ); m_nBucketCountLog2.compare_exchange_strong( sz, sz + 1, memory_model::memory_order_relaxed, atomics::memory_order_relaxed ); } + else + m_nMaxItemCount.store( std::numeric_limits::max(), memory_model::memory_order_relaxed ); } template @@ -539,7 +583,7 @@ namespace cds { namespace intrusive { dummy_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); - if ( m_List.erase_at( pHead, sv, cmp ) ) { + if ( m_List.erase_at( pHead, sv, cmp )) { --m_ItemCounter; m_Stat.onEraseSuccess(); return true; @@ -556,7 +600,7 @@ namespace cds { namespace intrusive { dummy_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); - if ( m_List.extract_at( pHead, guard, sv, cmp ) ) { + if ( m_List.extract_at( pHead, guard, sv, cmp )) { --m_ItemCounter; m_Stat.onExtractSuccess(); return true; @@ -574,7 +618,7 @@ namespace cds { namespace intrusive { template bool extract_with_( typename guarded_ptr::native_guard& guard, Q const& key, Less ) { - return extract_( guard, key, typename wrapped_ordered_list::template make_compare_from_less() ); + return extract_( guard, key, typename wrapped_ordered_list::template make_compare_from_less()); } //@endcond @@ -587,6 +631,7 @@ namespace cds { namespace intrusive { */ SplitListSet() : m_nBucketCountLog2(1) + , m_nMaxItemCount( max_item_count(2, m_Buckets.load_factor())) { init(); } @@ -598,6 +643,7 @@ namespace cds { namespace intrusive { ) : m_Buckets( nItemCount, nLoadFactor ) , m_nBucketCountLog2(1) + , m_nMaxItemCount( max_item_count(2, m_Buckets.load_factor())) { init(); } @@ -665,11 +711,12 @@ namespace cds { namespace intrusive { return false; } - /// Ensures that the \p val exists in the set + /// Updates the node /** The operation performs inserting or changing data with lock-free manner. - If the item \p val is not found in the set, then \p val is inserted into the set. + If the item \p val is not found in the set, then \p val is inserted + iff \p bAllowInsert is \p true. Otherwise, the functor \p func is called with item found. The functor signature is: \code @@ -678,22 +725,22 @@ namespace cds { namespace intrusive { with arguments: - \p bNew - \p true if the item has been inserted, \p false otherwise - \p item - item of the set - - \p val - argument \p val passed into the \p ensure function + - \p val - argument \p val passed into the \p update() function If new item has been inserted (i.e. \p bNew is \p true) then \p item and \p val arguments refers to the same thing. - The functor can change non-key fields of the \p item. + The functor may change non-key fields of the \p item. Returns std::pair where \p first is \p true if operation is successfull, - \p second is \p true if new item has been added or \p false if the item with \p key - already is in the set. + \p second is \p true if new item has been added or \p false if the item with \p val + already is in the list. @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting". \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level synchronization. */ template - std::pair ensure( value_type& val, Func func ) + std::pair update( value_type& val, Func func, bool bAllowInsert = true ) { size_t nHash = hash_value( val ); dummy_node_type * pHead = get_bucket( nHash ); @@ -701,7 +748,7 @@ namespace cds { namespace intrusive { node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash ); - std::pair bRet = m_List.ensure_at( pHead, val, func ); + std::pair bRet = m_List.update_at( pHead, val, func, bAllowInsert ); if ( bRet.first && bRet.second ) { inc_item_count(); m_Stat.onEnsureNew(); @@ -710,6 +757,14 @@ namespace cds { namespace intrusive { m_Stat.onEnsureExist(); return bRet; } + //@cond + template + CDS_DEPRECATED("ensure() is deprecated, use update()") + std::pair ensure( value_type& val, Func func ) + { + return update( val, func, true ); + } + //@endcond /// Unlinks the item \p val from the set /** @@ -729,7 +784,7 @@ namespace cds { namespace intrusive { dummy_node_type * pHead = get_bucket( nHash ); assert( pHead != nullptr ); - if ( m_List.unlink_at( pHead, val ) ) { + if ( m_List.unlink_at( pHead, val )) { --m_ItemCounter; m_Stat.onEraseSuccess(); return true; @@ -754,7 +809,7 @@ namespace cds { namespace intrusive { template bool erase( Q const& key ) { - return erase_( key, key_comparator() ); + return erase_( key, key_comparator()); } /// Deletes the item from the set with comparing functor \p pred @@ -769,7 +824,7 @@ namespace cds { namespace intrusive { bool erase_with( const Q& key, Less pred ) { CDS_UNUSED( pred ); - return erase_( key, typename wrapped_ordered_list::template make_compare_from_less() ); + return erase_( key, typename wrapped_ordered_list::template make_compare_from_less()); } /// Deletes the item from the set @@ -918,34 +973,49 @@ namespace cds { namespace intrusive { } //@endcond - /// Finds the key \p key - /** \anchor cds_intrusive_SplitListSet_hp_find_val + /// Checks whether the set contains \p key + /** The function searches the item with key equal to \p key and returns \p true if it is found, and \p false otherwise. Note the hash functor specified for class \p Traits template parameter should accept a parameter of type \p Q that can be not the same as \p value_type. - Otherwise, you may use \p find_with functions with explicit predicate for key comparing. + Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing. */ template + bool contains( Q const& key ) + { + return find_( key, key_comparator()); + } + //@cond + template + CDS_DEPRECATED("deprecated, use contains()") bool find( Q const& key ) { - return find_( key, key_comparator() ); + return contains( key ); } + //@endcond - /// Finds the key \p key with \p pred predicate for comparing + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_intrusive_SplitListSet_hp_find_val "find(Q const&)" - but \p cmp is used for key compare. - \p Less has the interface like \p std::less. - \p cmp must imply the same element order as the comparator used for building the set. + The function is an analog of contains( key ) but \p pred is used for key comparing. + \p Less functor has the interface like \p std::less. + \p Less must imply the same element order as the comparator used for building the set. */ template - bool find_with( Q const& key, Less pred ) + bool contains( Q const& key, Less pred ) { CDS_UNUSED( pred ); - return find_( key, typename wrapped_ordered_list::template make_compare_from_less() ); + return find_( key, typename wrapped_ordered_list::template make_compare_from_less()); + } + //@cond + template + CDS_DEPRECATED("deprecated, use contains()") + bool find_with( Q const& key, Less pred ) + { + return contains( key, pred ); } + //@endcond /// Finds the key \p key and return the item found /** \anchor cds_intrusive_SplitListSet_hp_get @@ -1027,7 +1097,7 @@ namespace cds { namespace intrusive { void clear() { iterator it = begin(); - while ( it != end() ) { + while ( it != end()) { iterator i(it); ++i; unlink( *it ); @@ -1090,7 +1160,7 @@ namespace cds { namespace intrusive { */ iterator begin() { - return iterator( m_List.begin(), m_List.end() ); + return iterator( m_List.begin(), m_List.end()); } /// Returns an iterator that addresses the location succeeding the last element in a split-list @@ -1102,7 +1172,7 @@ namespace cds { namespace intrusive { */ iterator end() { - return iterator( m_List.end(), m_List.end() ); + return iterator( m_List.end(), m_List.end()); } /// Returns a forward const iterator addressing the first element in a split-list @@ -1113,7 +1183,7 @@ namespace cds { namespace intrusive { /// Returns a forward const iterator addressing the first element in a split-list const_iterator cbegin() const { - return const_iterator( m_List.cbegin(), m_List.cend() ); + return const_iterator( m_List.cbegin(), m_List.cend()); } /// Returns an const iterator that addresses the location succeeding the last element in a split-list @@ -1124,7 +1194,7 @@ namespace cds { namespace intrusive { /// Returns an const iterator that addresses the location succeeding the last element in a split-list const_iterator cend() const { - return const_iterator( m_List.cend(), m_List.cend() ); + return const_iterator( m_List.cend(), m_List.cend()); } };