2 This file is a part of libcds - Concurrent Data Structures library
4 (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
6 Source code repo: http://github.com/khizmax/libcds/
7 Download: http://sourceforge.net/projects/libcds/files/
9 Redistribution and use in source and binary forms, with or without
10 modification, are permitted provided that the following conditions are met:
12 * Redistributions of source code must retain the above copyright notice, this
13 list of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright notice,
16 this list of conditions and the following disclaimer in the documentation
17 and/or other materials provided with the distribution.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
23 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 #ifndef CDSLIB_CONTAINER_IMPL_ITERABLE_KVLIST_H
32 #define CDSLIB_CONTAINER_IMPL_ITERABLE_KVLIST_H
35 #include <cds/container/details/guarded_ptr_cast.h>
37 namespace cds { namespace container {
39 /// Iterable ordered list for key-value pair
40 /** @ingroup cds_nonintrusive_list
41 \anchor cds_nonintrusive_IterableKVList_gc
43 This is key-value variation of non-intrusive \p IterableList.
44 Like standard container, this implementation split a value stored into two part -
45 constant key and alterable value.
47 Usually, ordered single-linked list is used as a building block for the hash table implementation.
48 Iterable list is suitable for almost append-only hash table because the list doesn't delete
49 its internal node when erasing a key but it is marked them as empty to be reused in the future.
50 However, plenty of empty nodes degrades performance.
52 The complexity of searching is <tt>O(N)</tt>.
55 - \p GC - garbage collector used
56 - \p Key - key type of an item stored in the list. It should be copy-constructible
57 - \p Value - value type stored in a list
58 - \p Traits - type traits, default is \p iterable_list::traits
60 It is possible to declare option-based list with \p cds::container::iterable_list::make_traits metafunction instead of \p Traits template
61 argument. For example, the following traits-based declaration of \p gc::HP iterable list
63 #include <cds/container/iterable_kvlist_hp.h>
64 // Declare comparator for the item
66 int operator ()( int i1, int i2 )
73 struct my_traits: public cds::container::iterable_list::traits
75 typedef my_compare compare;
78 // Declare traits-based list
79 typedef cds::container::IterableKVList< cds::gc::HP, int, int, my_traits > traits_based_list;
81 is equivalent for the following option-based list
83 #include <cds/container/iterable_kvlist_hp.h>
85 // my_compare is the same
87 // Declare option-based list
88 typedef cds::container::IterableKVList< cds::gc::HP, int, int,
89 typename cds::container::iterable_list::make_traits<
90 cds::container::opt::compare< my_compare > // item comparator option
96 There are different specializations of this template for each garbage collecting schema used.
97 You should include appropriate .h-file depending on GC you are using:
98 - for gc::HP: \code #include <cds/container/iterable_kvlist_hp.h> \endcode
99 - for gc::DHP: \code #include <cds/container/iterable_kvlist_dhp.h> \endcode
100 - for \ref cds_urcu_desc "RCU": \code #include <cds/container/iterable_kvlist_rcu.h> \endcode
106 #ifdef CDS_DOXYGEN_INVOKED
107 typename Traits = iterable_list::traits
112 class IterableKVList:
113 #ifdef CDS_DOXYGEN_INVOKED
114 protected container::IterableList< GC, std::pair<Key, Value>, Traits >
116 protected details::make_iterable_kvlist< GC, Key, Value, Traits >::type
120 typedef details::make_iterable_kvlist< GC, Key, Value, Traits > maker;
121 typedef typename maker::type base_class;
125 #ifdef CDS_DOXYGEN_INVOKED
126 typedef Key key_type; ///< Key type
127 typedef Value mapped_type; ///< Type of value stored in the list
128 typedef std::pair<key_type const, mapped_type> value_type; ///< key/value pair stored in the list
130 typedef typename maker::key_type key_type;
131 typedef typename maker::mapped_type mapped_type;
132 typedef typename maker::value_type value_type;
134 typedef Traits traits; ///< List traits
135 typedef typename base_class::gc gc; ///< Garbage collector used
136 typedef typename base_class::back_off back_off; ///< Back-off strategy used
137 typedef typename maker::data_allocator_type allocator_type; ///< Allocator type used for allocate/deallocate data
138 typedef typename base_class::item_counter item_counter; ///< Item counting policy used
139 typedef typename maker::key_comparator key_comparator; ///< key comparison functor
140 typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option
141 typedef typename base_class::stat stat; ///< Internal statistics
143 static constexpr const size_t c_nHazardPtrCount = base_class::c_nHazardPtrCount; ///< Count of hazard pointer required for the algorithm
146 typedef typename base_class::guarded_ptr guarded_ptr;
149 // Rebind traits (split-list support)
150 template <typename... Options>
151 struct rebind_traits {
152 typedef IterableKVList<
154 , key_type, mapped_type
155 , typename cds::opt::make_options< traits, Options...>::type
160 template <typename Stat>
161 using select_stat_wrapper = typename base_class::template select_stat_wrapper< Stat >;
166 typedef typename base_class::head_type head_type;
167 typedef typename maker::cxx_data_allocator cxx_data_allocator;
169 template <typename Less>
170 using less_wrapper = typename maker::template less_wrapper< Less >;
172 template <bool IsConst>
173 using iterator_type = typename base_class::template iterator_type<IsConst>;
179 The forward iterator for iterable list has some features:
180 - it has no post-increment operator
181 - to protect the value, the iterator contains a GC-specific guard.
182 For some GC (like as \p gc::HP), a guard is a limited resource per thread, so an exception (or assertion) "no free guard"
183 may be thrown if the limit of guard count per thread is exceeded.
184 - The iterator cannot be moved across thread boundary since it contains thread-private GC's guard.
185 - Iterator is thread-safe: even if an element the iterator points to is removed, the iterator stays valid because
186 it contains the guard keeping the value from to be recycled.
188 The iterator interface:
192 // Default constructor
196 iterator( iterator const& src );
198 // Dereference operator
199 value_type * operator ->() const;
201 // Dereference operator
202 value_type& operator *() const;
204 // Preincrement operator
205 iterator& operator ++();
207 // Assignment operator
208 iterator& operator = (iterator const& src);
210 // Equality operators
211 bool operator ==(iterator const& i ) const;
212 bool operator !=(iterator const& i ) const;
216 @note For two iterators pointed to the same element the value can be different;
220 assert( &(*it1) == &(*it2));
222 can throw assertion. The point is that the iterator stores the value of element which can be modified later by other thread.
223 The guard inside the iterator prevents recycling that value so the iterator's value remains valid even after such changing.
224 Other iterator can observe modified value of the element.
226 using typename base_class::iterator;
227 using typename base_class::const_iterator;
228 using base_class::begin;
229 using base_class::end;
230 using base_class::cbegin;
231 using base_class::cend;
234 /// Default constructor
236 Initializes empty list
242 template <typename Stat, typename = std::enable_if<std::is_same<stat, iterable_list::wrapped_stat<Stat>>::value >>
243 explicit IterableKVList( Stat& st )
255 /// Inserts new node with key and default value
257 The function creates a node with \p key and default value, and then inserts the node created into the list.
260 - The \p key_type should be constructible from value of type \p K. In trivial case, \p K is equal to \p key_type.
261 - The \p mapped_type should be default-constructible.
263 Returns \p true if inserting successful, \p false otherwise.
265 @note The function is supported only if \ref mapped_type is default constructible
267 template <typename K>
268 bool insert( K&& key )
270 return base_class::emplace( key_type( std::forward<K>( key )), mapped_type());
273 /// Inserts new node with a key and a value
275 The function creates a node with \p key and value \p val, and then inserts the node created into the list.
278 - The \p key_type should be constructible from \p key of type \p K.
279 - The \p mapped_type should be constructible from \p val of type \p V.
281 Returns \p true if inserting successful, \p false otherwise.
283 template <typename K, typename V>
284 bool insert( K&& key, V&& val )
286 return base_class::emplace( key_type( std::forward<K>( key )), mapped_type( std::forward<V>( val )));
289 /// Inserts new node and initialize it by a functor
291 This function inserts new node with key \p key and if inserting is successful then it calls
292 \p func functor with signature
295 void operator()( value_type& item );
299 The argument \p item of user-defined functor \p func is the reference
300 to the item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
301 User-defined functor \p func should guarantee that during changing item's value no any other changes
302 could be made on this list's item by concurrent threads.
303 The user-defined functor is called only if inserting is successful.
305 The \p key_type should be constructible from value of type \p K.
307 The function allows to split creating of new item into two part:
308 - create a new item from \p key;
309 - insert the new item into the list;
310 - if inserting is successful, initialize the value of item by calling \p func functor
312 This can be useful if complete initialization of object of \p mapped_type is heavyweight and
313 it is preferable that the initialization should be completed only if inserting is successful.
315 @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
317 @note The function is supported only if \ref mapped_type is default constructible
319 template <typename K, typename Func>
320 bool insert_with( K&& key, Func func )
322 return base_class::insert( value_type( key_type( std::forward<K>( key )), mapped_type()), func );
325 /// Updates data by \p key
327 The operation performs inserting or replacing the element with lock-free manner.
329 If the \p key not found in the list, then the new item created from \p key
330 will be inserted iff \p bAllowInsert is \p true.
331 (note that in this case the \ref key_type should be constructible from type \p K).
332 Otherwise, if \p key is found, the functor \p func is called with item found.
334 The functor \p func is called after inserting or replacing, it signature is:
336 void func( value_type& val, value_type* old );
339 - \p val - a new data constructed from \p key
340 - \p old - old value that will be retired. If new item has been inserted then \p old is \p nullptr.
342 The functor may change non-key fields of \p val; however, \p func must guarantee
343 that during changing no any other modifications could be made on this item by concurrent threads.
345 @return <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successful,
346 \p second is true if new item has been added or \p false if the item with such \p key
349 @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
351 @note The function is supported only if \ref mapped_type is default constructible
353 template <typename K, typename Func>
354 std::pair<bool, bool> update( K&& key, Func f, bool bAllowInsert = true )
356 return base_class::update( value_type( key_type( std::forward<K>( key )), mapped_type()), f, bAllowInsert );
361 The operation performs inserting or updating data with lock-free manner.
363 If the item \p key is not found in the list, then \p key is inserted
364 iff \p bInsert is \p true.
365 Otherwise, the current element is changed to <tt> value_type( key, val )</tt>,
366 the old element will be retired later.
368 Returns std::pair<bool, bool> where \p first is \p true if operation is successful,
369 \p second is \p true if \p key has been added or \p false if the item with that key
372 template <typename Q, typename V >
373 std::pair<bool, bool> upsert( Q&& key, V&& val, bool bInsert = true )
375 return base_class::upsert( value_type( key_type( std::forward<Q>( key )), mapped_type( std::forward<V>( val ))), bInsert );
378 /// Inserts a new node using move semantics
380 \p key_type field of new item is constructed from \p key argument,
381 \p mapped_type field is done from \p args.
383 Returns \p true if inserting successful, \p false otherwise.
385 template <typename K, typename... Args>
386 bool emplace( K&& key, Args&&... args )
388 return base_class::emplace( key_type( std::forward<K>( key )), mapped_type( std::forward<Args>( args )... ));
391 /// Deletes \p key from the list
394 Returns \p true if \p key is found and has been deleted, \p false otherwise
396 template <typename K>
397 bool erase( K const& key )
399 return base_class::erase( key );
402 /// Deletes the item from the list using \p pred predicate for searching
404 The function is an analog of \p erase(K const&) but \p pred is used for key comparing.
405 \p Less functor has the interface like \p std::less.
406 \p pred must imply the same element order as the comparator used for building the list.
408 template <typename K, typename Less>
409 bool erase_with( K const& key, Less pred )
412 return base_class::erase_with( key, less_wrapper<Less>());
415 /// Deletes \p key from the list
417 The function searches an item with key \p key, calls \p f functor
418 and deletes the item. If \p key is not found, the functor is not called.
420 The functor \p Func interface:
423 void operator()(value_type& val) { ... }
427 Return \p true if key is found and deleted, \p false otherwise
429 template <typename K, typename Func>
430 bool erase( K const& key, Func f )
432 return base_class::erase( key, f );
435 /// Deletes the item from the list using \p pred predicate for searching
437 The function is an analog of \p erase(K const&, Func) but \p pred is used for key comparing.
438 \p Less functor has the interface like \p std::less.
439 \p pred must imply the same element order as the comparator used for building the list.
441 template <typename K, typename Less, typename Func>
442 bool erase_with( K const& key, Less pred, Func f )
445 return base_class::erase_with( key, less_wrapper<Less>(), f );
448 /// Deletes the item pointed by iterator \p iter
450 Returns \p true if the operation is successful, \p false otherwise.
451 The function can return \p false if the node the iterator points to has already been deleted
454 The function does not invalidate the iterator, it remains valid and can be used for further traversing.
456 bool erase_at( iterator const& iter )
458 return base_class::erase_at( iter );
461 /// Extracts the item from the list with specified \p key
463 The function searches an item with key equal to \p key,
464 unlinks it from the list, and returns it as \p guarded_ptr.
465 If \p key is not found the function returns an empty guarded pointer.
467 Note the compare functor should accept a parameter of type \p K that can be not the same as \p key_type.
469 The \p disposer specified in \p Traits class template parameter is called automatically
470 by garbage collector \p GC specified in class' template parameters when returned \p guarded_ptr object
471 will be destroyed or released.
472 @note Each \p guarded_ptr object uses the GC's guard that can be limited resource.
476 typedef cds::container::IterableKVList< cds::gc::HP, int, foo, my_traits > ord_list;
480 ord_list::guarded_ptr gp(theList.extract( 5 ));
485 // Destructor of gp releases internal HP guard
489 template <typename K>
490 guarded_ptr extract( K const& key )
492 return base_class::extract( key );
495 /// Extracts the item from the list with comparing functor \p pred
497 The function is an analog of \p extract(K const&) but \p pred predicate is used for key comparing.
499 \p Less functor has the semantics like \p std::less but should take arguments of type \ref key_type and \p K
501 \p pred must imply the same element order as the comparator used for building the list.
503 template <typename K, typename Less>
504 guarded_ptr extract_with( K const& key, Less pred )
507 return base_class::extract_with( key, less_wrapper<Less>());
510 /// Checks whether the list contains \p key
512 The function searches the item with key equal to \p key
513 and returns \p true if it is found, and \p false otherwise.
515 template <typename Q>
516 bool contains( Q const& key ) const
518 return base_class::contains( key );
521 /// Checks whether the map contains \p key using \p pred predicate for searching
523 The function is an analog of <tt>contains( key )</tt> but \p pred is used for key comparing.
524 \p Less functor has the interface like \p std::less.
525 \p Less must imply the same element order as the comparator used for building the list.
527 template <typename Q, typename Less>
528 bool contains( Q const& key, Less pred ) const
531 return base_class::contains( key, less_wrapper<Less>());
534 /// Finds the key \p key and performs an action with it
536 The function searches an item with key equal to \p key and calls the functor \p f for the item found.
537 The interface of \p Func functor is:
540 void operator()( value_type& item );
543 where \p item is the item found.
545 The functor may change <tt>item.second</tt> that is reference to value of node.
546 Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
547 The function does not serialize simultaneous access to the list \p item. If such access is
548 possible you must provide your own synchronization schema to exclude unsafe item modifications.
550 The function returns \p true if \p key is found, \p false otherwise.
552 template <typename Q, typename Func>
553 bool find( Q const& key, Func f ) const
555 return base_class::find( key, [&f]( value_type& v, Q const& ) { f( v ); } );
558 /// Finds \p key in the list and returns iterator pointed to the item found
560 If \p key is not found the function returns \p end().
562 template <typename Q>
563 iterator find( Q const& key ) const
565 return base_class::find( key );
568 /// Finds the key \p val using \p pred predicate for searching
570 The function is an analog of \p find(Q&, Func) but \p pred is used for key comparing.
571 \p Less functor has the interface like \p std::less.
572 \p pred must imply the same element order as the comparator used for building the list.
574 template <typename Q, typename Less, typename Func>
575 bool find_with( Q const& key, Less pred, Func f ) const
578 return base_class::find_with( key, less_wrapper<Less>(), [&f]( value_type& v, Q const& ) { f( v ); } );
581 /// Finds \p key in the list using \p pred predicate for searching and returns iterator pointed to the item found
583 The function is an analog of \p find(Q&) but \p pred is used for key comparing.
584 \p Less functor has the interface like \p std::less.
585 \p pred must imply the same element order as the comparator used for building the list.
587 If \p key is not found the function returns \p end().
589 template <typename Q, typename Less>
590 iterator find_with( Q const& key, Less pred ) const
593 return base_class::find_with( key, less_wrapper<Less>());
596 /// Finds the \p key and return the item found
598 The function searches the item with key equal to \p key
599 and returns it as \p guarded_ptr.
600 If \p key is not found the function returns an empty guarded pointer.
602 @note Each \p guarded_ptr object uses one GC's guard which can be limited resource.
606 typedef cds::container::IterableKVList< cds::gc::HP, int, foo, my_traits > ord_list;
610 ord_list::guarded_ptr gp(theList.get( 5 ));
615 // Destructor of guarded_ptr releases internal HP guard
619 Note the compare functor specified for class \p Traits template parameter
620 should accept a parameter of type \p K that can be not the same as \p key_type.
622 template <typename K>
623 guarded_ptr get( K const& key ) const
625 return base_class::get( key );
628 /// Finds the \p key and return the item found
630 The function is an analog of \p get( guarded_ptr& ptr, K const&)
631 but \p pred is used for comparing the keys.
633 \p Less functor has the semantics like \p std::less but should take arguments of type \ref key_type and \p K
635 \p pred must imply the same element order as the comparator used for building the list.
637 template <typename K, typename Less>
638 guarded_ptr get_with( K const& key, Less pred ) const
641 return base_class::get_with( key, less_wrapper<Less>());
644 /// Checks if the list is empty
646 Emptiness is checked by item counting: if item count is zero then the set is empty.
647 Thus, if you need to use \p %empty() you should provide appropriate (non-empty) \p iterable_list::traits::item_counter
652 return base_class::empty();
655 /// Returns list's item count
657 The value returned depends on item counter provided by \p Traits. For \p atomicity::empty_item_counter,
658 this function always returns 0.
662 return base_class::size();
671 /// Returns const reference to internal statistics
672 stat const& statistics() const
674 return base_class::statistics();
679 // Split-list support
681 template <typename K>
682 bool insert_at( head_type& refHead, K&& key )
684 return base_class::insert_at( refHead, value_type( key_type( std::forward<K>( key )), mapped_type()));
687 template <typename K, typename V>
688 bool insert_at( head_type& refHead, K&& key, V&& val )
690 return base_class::insert_at( refHead, value_type( key_type( std::forward<K>( key )), std::forward<V>( val )));
693 template <typename K, typename Func>
694 bool insert_with_at( head_type& refHead, K&& key, Func f )
696 return base_class::insert_at( refHead, value_type( key_type( std::forward<K>( key )), mapped_type()), f );
699 template <typename K, typename... Args>
700 bool emplace_at( head_type& refHead, K&& key, Args&&... args )
702 return base_class::emplace_at( refHead, std::forward<K>(key), std::forward<Args>(args)... );
705 template <typename K, typename Func>
706 std::pair<bool, bool> update_at( head_type& refHead, K&& key, Func f, bool bAllowInsert )
708 return base_class::update_at( refHead, value_type( key_type( std::forward<K>( key )), mapped_type()), f, bAllowInsert );
711 template <typename K, typename Compare>
712 bool erase_at( head_type& refHead, K const& key, Compare cmp )
714 return base_class::erase_at( refHead, key, cmp );
717 template <typename K, typename Compare, typename Func>
718 bool erase_at( head_type& refHead, K const& key, Compare cmp, Func f )
720 return base_class::erase_at( refHead, key, cmp, f );
722 template <typename K, typename Compare>
723 guarded_ptr extract_at( head_type& refHead, K const& key, Compare cmp )
725 return base_class::extract_at( refHead, key, cmp );
728 template <typename K, typename Compare>
729 bool find_at( head_type& refHead, K const& key, Compare cmp )
731 return base_class::find_at( refHead, key, cmp );
734 template <typename K, typename Compare, typename Func>
735 bool find_at( head_type& refHead, K& key, Compare cmp, Func f )
737 return base_class::find_at( refHead, key, cmp, f );
740 template <typename K, typename Compare>
741 guarded_ptr get_at( head_type& refHead, K const& key, Compare cmp )
743 return base_class::get_at( refHead, key, cmp );
749 }} // namespace cds::container
751 #endif // #ifndef CDSLIB_CONTAINER_IMPL_ITERABLE_KVLIST_H