3 #ifndef CDSLIB_CONTAINER_ELLEN_BINTREE_MAP_RCU_H
4 #define CDSLIB_CONTAINER_ELLEN_BINTREE_MAP_RCU_H
6 #include <cds/container/details/ellen_bintree_base.h>
7 #include <cds/intrusive/ellen_bintree_rcu.h>
9 namespace cds { namespace container {
11 /// Map based on Ellen's et al binary search tree (RCU specialization)
12 /** @ingroup cds_nonintrusive_map
13 @ingroup cds_nonintrusive_tree
14 @anchor cds_container_EllenBinTreeMap_rcu
17 - [2010] F.Ellen, P.Fatourou, E.Ruppert, F.van Breugel "Non-blocking Binary Search Tree"
19 %EllenBinTreeMap is an unbalanced leaf-oriented binary search tree that implements the <i>map</i>
20 abstract data type. Nodes maintains child pointers but not parent pointers.
21 Every internal node has exactly two children, and all data of type <tt>std::pair<Key const, T></tt>
22 currently in the tree are stored in the leaves. Internal nodes of the tree are used to direct \p find
23 operation along the path to the correct leaf. The keys (of \p Key type) stored in internal nodes
24 may or may not be in the map.
25 Unlike \ref cds_container_EllenBinTreeSet_rcu "EllenBinTreeSet" keys are not a part of \p T type.
26 The map can be represented as a set containing <tt>std::pair< Key const, T> </tt> values.
28 Due to \p extract_min and \p extract_max member functions the \p %EllenBinTreeMap can act as
29 a <i>priority queue</i>. In this case you should provide unique compound key, for example,
30 the priority value plus some uniformly distributed random value.
32 @warning Recall the tree is <b>unbalanced</b>. The complexity of operations is <tt>O(log N)</tt>
33 for uniformly distributed random keys, but in worst case the complexity is <tt>O(N)</tt>.
35 @note In the current implementation we do not use helping technique described in original paper.
36 So, the current implementation is near to fine-grained lock-based tree.
37 Helping will be implemented in future release
39 <b>Template arguments</b> :
40 - \p RCU - one of \ref cds_urcu_gc "RCU type"
42 - \p T - value type to be stored in tree's leaf nodes.
43 - \p Traits - map traits, default is \p ellen_bintree::traits.
44 It is possible to declare option-based tree with \p ellen_bintree::make_map_traits metafunction
45 instead of \p Traits template argument.
47 @note Before including <tt><cds/container/ellen_bintree_map_rcu.h></tt> you should include appropriate RCU header file,
48 see \ref cds_urcu_gc "RCU type" for list of existing RCU class and corresponding header files.
54 #ifdef CDS_DOXYGEN_INVOKED
55 class Traits = ellen_bintree::traits
60 class EllenBinTreeMap< cds::urcu::gc<RCU>, Key, T, Traits >
61 #ifdef CDS_DOXYGEN_INVOKED
62 : public cds::intrusive::EllenBinTree< cds::urcu::gc<RCU>, Key, T, Traits >
64 : public ellen_bintree::details::make_ellen_bintree_map< cds::urcu::gc<RCU>, Key, T, Traits >::type
68 typedef ellen_bintree::details::make_ellen_bintree_map< cds::urcu::gc<RCU>, Key, T, Traits > maker;
69 typedef typename maker::type base_class;
72 typedef cds::urcu::gc<RCU> gc; ///< RCU Garbage collector
73 typedef Key key_type; ///< type of a key stored in the map
74 typedef T mapped_type; ///< type of value stored in the map
75 typedef std::pair< key_type const, mapped_type > value_type; ///< Key-value pair stored in leaf node of the mp
76 typedef Traits traits; ///< Traits template parameter
78 # ifdef CDS_DOXYGEN_INVOKED
79 typedef implementation_defined key_comparator ; ///< key compare functor based on \p Traits::compare and \p Traits::less
81 typedef typename maker::intrusive_traits::compare key_comparator;
83 typedef typename base_class::item_counter item_counter; ///< Item counting policy
84 typedef typename base_class::memory_model memory_model; ///< Memory ordering, see \p cds::opt::memory_model option
85 typedef typename base_class::node_allocator node_allocator_type; ///< allocator for maintaining internal node
86 typedef typename base_class::stat stat; ///< internal statistics
87 typedef typename base_class::rcu_check_deadlock rcu_check_deadlock; ///< Deadlock checking policy
88 typedef typename traits::copy_policy copy_policy; ///< key copy policy
89 typedef typename traits::back_off back_off; ///< Back-off strategy
91 typedef typename traits::allocator allocator_type; ///< Allocator for leaf nodes
92 typedef typename base_class::node_allocator node_allocator; ///< Internal node allocator
93 typedef typename base_class::update_desc_allocator update_desc_allocator; ///< Update descriptor allocator
95 static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; ///< Group of \p extract_xxx functions do not require external locking
98 typedef cds::container::ellen_bintree::implementation_tag implementation_tag;
103 typedef typename base_class::value_type leaf_node;
104 typedef typename base_class::internal_node internal_node;
105 typedef typename base_class::update_desc update_desc;
107 typedef typename maker::cxx_leaf_node_allocator cxx_leaf_node_allocator;
109 typedef std::unique_ptr< leaf_node, typename maker::leaf_deallocator > scoped_node_ptr;
113 typedef typename gc::scoped_lock rcu_lock ; ///< RCU scoped lock
115 /// pointer to extracted node
116 using exempt_ptr = cds::urcu::exempt_ptr < gc, leaf_node, value_type, typename maker::intrusive_traits::disposer,
117 cds::urcu::details::conventional_exempt_member_cast < leaf_node, value_type >
121 /// Default constructor
130 /// Inserts new node with key and default value
132 The function creates a node with \p key and default value, and then inserts the node created into the map.
135 - The \p key_type should be constructible from a value of type \p K.
136 - The \p mapped_type should be default-constructible.
138 RCU \p synchronize() can be called. RCU should not be locked.
140 Returns \p true if inserting successful, \p false otherwise.
142 template <typename K>
143 bool insert( K const& key )
145 return insert_with( key, [](value_type&){} );
150 The function creates a node with copy of \p val value
151 and then inserts the node created into the map.
154 - The \p key_type should be constructible from \p key of type \p K.
155 - The \p value_type should be constructible from \p val of type \p V.
157 RCU \p synchronize() method can be called. RCU should not be locked.
159 Returns \p true if \p val is inserted into the map, \p false otherwise.
161 template <typename K, typename V>
162 bool insert( K const& key, V const& val )
164 scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key, val ));
165 if ( base_class::insert( *pNode ))
173 /// Inserts new node and initialize it by a functor
175 This function inserts new node with key \p key and if inserting is successful then it calls
176 \p func functor with signature
179 void operator()( value_type& item );
183 The argument \p item of user-defined functor \p func is the reference
184 to the map's item inserted:
185 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
186 - <tt>item.second</tt> is a reference to item's value that may be changed.
188 The key_type should be constructible from value of type \p K.
190 The function allows to split creating of new item into two part:
191 - create item from \p key;
192 - insert new item into the map;
193 - if inserting is successful, initialize the value of item by calling \p func functor
195 This can be useful if complete initialization of object of \p value_type is heavyweight and
196 it is preferable that the initialization should be completed only if inserting is successful.
198 RCU \p synchronize() method can be called. RCU should not be locked.
200 template <typename K, typename Func>
201 bool insert_with( K const& key, Func func )
203 scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
204 if ( base_class::insert( *pNode, [&func]( leaf_node& item ) { func( item.m_Value ); } )) {
211 /// For key \p key inserts data of type \p value_type created in-place from \p args
213 Returns \p true if inserting successful, \p false otherwise.
215 RCU \p synchronize() method can be called. RCU should not be locked.
217 template <typename K, typename... Args>
218 bool emplace( K&& key, Args&&... args )
220 scoped_node_ptr pNode( cxx_leaf_node_allocator().New( std::forward<K>(key), std::forward<Args>(args)... ));
221 if ( base_class::insert( *pNode )) {
230 The operation performs inserting or changing data with lock-free manner.
232 If the item \p val is not found in the map, then \p val is inserted iff \p bAllowInsert is \p true.
233 Otherwise, the functor \p func is called with item found.
234 The functor \p func signature is:
237 void operator()( bool bNew, value_type& item );
242 - \p bNew - \p true if the item has been inserted, \p false otherwise
243 - \p item - item of the map
245 The functor may change any fields of the \p item.second that is \p mapped_type;
246 however, \p func must guarantee that during changing no any other modifications
247 could be made on this item by concurrent threads.
249 RCU \p synchronize() method can be called. RCU should not be locked.
251 Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
252 i.e. the node has been inserted or updated,
253 \p second is \p true if new item has been added or \p false if the item with \p key
256 @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
258 template <typename K, typename Func>
259 std::pair<bool, bool> update( K const& key, Func func, bool bAllowInsert = true )
261 scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
262 std::pair<bool, bool> res = base_class::update( *pNode,
263 [&func](bool bNew, leaf_node& item, leaf_node const& ){ func( bNew, item.m_Value ); },
266 if ( res.first && res.second )
271 // Deprecated, use update()
272 template <typename K, typename Func>
273 std::pair<bool, bool> ensure( K const& key, Func func )
275 return update( key, func, true );
279 /// Delete \p key from the map
280 /**\anchor cds_nonintrusive_EllenBinTreeMap_rcu_erase_val
282 RCU \p synchronize() method can be called. RCU should not be locked.
284 Return \p true if \p key is found and deleted, \p false otherwise
286 template <typename K>
287 bool erase( K const& key )
289 return base_class::erase(key);
292 /// Deletes the item from the map using \p pred predicate for searching
294 The function is an analog of \ref cds_nonintrusive_EllenBinTreeMap_rcu_erase_val "erase(K const&)"
295 but \p pred is used for key comparing.
296 \p Less functor has the interface like \p std::less.
297 \p Less must imply the same element order as the comparator used for building the map.
299 template <typename K, typename Less>
300 bool erase_with( K const& key, Less pred )
303 return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >());
306 /// Delete \p key from the map
307 /** \anchor cds_nonintrusive_EllenBinTreeMap_rcu_erase_func
309 The function searches an item with key \p key, calls \p f functor
310 and deletes the item. If \p key is not found, the functor is not called.
312 The functor \p Func interface:
315 void operator()(value_type& item) { ... }
319 RCU \p synchronize method can be called. RCU should not be locked.
321 Return \p true if key is found and deleted, \p false otherwise
323 template <typename K, typename Func>
324 bool erase( K const& key, Func f )
326 return base_class::erase( key, [&f]( leaf_node& node) { f( node.m_Value ); } );
329 /// Deletes the item from the map using \p pred predicate for searching
331 The function is an analog of \ref cds_nonintrusive_EllenBinTreeMap_rcu_erase_func "erase(K const&, Func)"
332 but \p pred is used for key comparing.
333 \p Less functor has the interface like \p std::less.
334 \p Less must imply the same element order as the comparator used for building the map.
336 template <typename K, typename Less, typename Func>
337 bool erase_with( K const& key, Less pred, Func f )
340 return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
341 [&f]( leaf_node& node) { f( node.m_Value ); } );
344 /// Extracts an item with minimal key from the map
346 Returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the leftmost item.
347 If the set is empty, returns empty \p exempt_ptr.
349 @note Due the concurrent nature of the map, the function extracts <i>nearly</i> minimum key.
350 It means that the function gets leftmost leaf of the tree and tries to unlink it.
351 During unlinking, a concurrent thread may insert an item with key less than leftmost item's key.
352 So, the function returns the item with minimum key at the moment of tree traversing.
354 RCU \p synchronize method can be called. RCU should NOT be locked.
355 The function does not free the item.
356 The deallocator will be implicitly invoked when the returned object is destroyed or when
357 its \p release() member function is called.
359 exempt_ptr extract_min()
361 return exempt_ptr( base_class::extract_min_());
364 /// Extracts an item with maximal key from the map
366 Returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the rightmost item.
367 If the set is empty, returns empty \p exempt_ptr.
369 @note Due the concurrent nature of the map, the function extracts <i>nearly</i> maximal key.
370 It means that the function gets rightmost leaf of the tree and tries to unlink it.
371 During unlinking, a concurrent thread may insert an item with key great than leftmost item's key.
372 So, the function returns the item with maximum key at the moment of tree traversing.
374 RCU \p synchronize method can be called. RCU should NOT be locked.
375 The function does not free the item.
376 The deallocator will be implicitly invoked when the returned object is destroyed or when
377 its \p release() is called.
378 @note Before reusing \p result object you should call its \p release() method.
380 exempt_ptr extract_max()
382 return exempt_ptr( base_class::extract_max_());
385 /// Extracts an item from the map
386 /** \anchor cds_nonintrusive_EllenBinTreeMap_rcu_extract
387 The function searches an item with key equal to \p key in the tree,
388 unlinks it, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to an item found.
389 If \p key is not found the function returns an empty \p exempt_ptr.
391 RCU \p synchronize method can be called. RCU should NOT be locked.
392 The function does not destroy the item found.
393 The dealloctor will be implicitly invoked when the returned object is destroyed or when
394 its \p release() member function is called.
396 template <typename Q>
397 exempt_ptr extract( Q const& key )
399 return exempt_ptr( base_class::extract_( key, typename base_class::node_compare()));
402 /// Extracts an item from the map using \p pred for searching
404 The function is an analog of \p extract(Q const&)
405 but \p pred is used for key compare.
406 \p Less has the interface like \p std::less and should meet \ref cds_container_EllenBinTreeSet_rcu_less
407 "predicate requirements".
408 \p pred must imply the same element order as the comparator used for building the map.
410 template <typename Q, typename Less>
411 exempt_ptr extract_with( Q const& key, Less pred )
414 return exempt_ptr( base_class::extract_with_( key,
415 cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >() ));
418 /// Find the key \p key
419 /** \anchor cds_nonintrusive_EllenBinTreeMap_rcu_find_cfunc
421 The function searches the item with key equal to \p key and calls the functor \p f for item found.
422 The interface of \p Func functor is:
425 void operator()( value_type& item );
428 where \p item is the item found.
430 The functor may change \p item.second.
432 The function applies RCU lock internally.
434 The function returns \p true if \p key is found, \p false otherwise.
436 template <typename K, typename Func>
437 bool find( K const& key, Func f )
439 return base_class::find( key, [&f](leaf_node& item, K const& ) { f( item.m_Value );});
442 /// Finds the key \p val using \p pred predicate for searching
444 The function is an analog of \ref cds_nonintrusive_EllenBinTreeMap_rcu_find_cfunc "find(K const&, Func)"
445 but \p pred is used for key comparing.
446 \p Less functor has the interface like \p std::less.
447 \p Less must imply the same element order as the comparator used for building the map.
449 template <typename K, typename Less, typename Func>
450 bool find_with( K const& key, Less pred, Func f )
453 return base_class::find_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
454 [&f](leaf_node& item, K const& ) { f( item.m_Value );});
457 /// Checks whether the map contains \p key
459 The function searches the item with key equal to \p key
460 and returns \p true if it is found, and \p false otherwise.
462 The function applies RCU lock internally.
464 template <typename K>
465 bool contains( K const& key )
467 return base_class::contains( key );
470 // Deprecated, use contains()
471 template <typename K>
472 bool find( K const& key )
474 return contains( key );
478 /// Checks whether the map contains \p key using \p pred predicate for searching
480 The function is similar to <tt>contains( key )</tt> but \p pred is used for key comparing.
481 \p Less functor has the interface like \p std::less and should meet \ref cds_intrusive_EllenBinTree_rcu_less
482 "Predicate requirements".
483 \p Less must imply the same element order as the comparator used for building the set.
485 template <typename K, typename Less>
486 bool contains( K const& key, Less pred )
489 return base_class::contains( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >() );
492 // Deprecated, use contains()
493 template <typename K, typename Less>
494 bool find_with( K const& key, Less pred )
496 return contains( key, pred );
500 /// Finds \p key and return the item found
501 /** \anchor cds_nonintrusive_EllenBinTreeMap_rcu_get
502 The function searches the item with key equal to \p key and returns the pointer to item found.
503 If \p key is not found it returns \p nullptr.
505 RCU should be locked before call the function.
506 Returned pointer is valid while RCU is locked.
508 template <typename Q>
509 value_type * get( Q const& key ) const
511 leaf_node * pNode = base_class::get( key );
512 return pNode ? &pNode->m_Value : nullptr;
515 /// Finds \p key with \p pred predicate and return the item found
517 The function is an analog of \ref cds_nonintrusive_EllenBinTreeMap_rcu_get "get(Q const&)"
518 but \p pred is used for comparing the keys.
520 \p Less functor has the semantics like \p std::less but should take arguments of type \p key_type
521 and \p Q in any order.
522 \p pred must imply the same element order as the comparator used for building the map.
524 template <typename Q, typename Less>
525 value_type * get_with( Q const& key, Less pred ) const
528 leaf_node * pNode = base_class::get_with( key,
529 cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >());
530 return pNode ? &pNode->m_Value : nullptr;
539 /// Checks if the map is empty
542 return base_class::empty();
545 /// Returns item count in the map
547 Only leaf nodes containing user data are counted.
549 The value returned depends on item counter type provided by \p Traits template parameter.
550 If it is \p atomicity::empty_item_counter this function always returns 0.
552 The function is not suitable for checking the tree emptiness, use \p empty()
553 member function for this purpose.
557 return base_class::size();
560 /// Returns const reference to internal statistics
561 stat const& statistics() const
563 return base_class::statistics();
566 /// Checks internal consistency (not atomic, not thread-safe)
568 The debugging function to check internal consistency of the tree.
570 bool check_consistency() const
572 return base_class::check_consistency();
575 }} // namespace cds::container
577 #endif //#ifndef CDSLIB_CONTAINER_ELLEN_BINTREE_MAP_RCU_H