X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=cds%2Fcontainer%2Fmichael_list_rcu.h;h=cfece032357391ee5d3ed5ba2ed88e035ead094a;hb=cd515d6402be81b84e2eb0c9d4cf0a1ca9e4d95a;hp=65a8351e0a8dcd0beb328bf63bc5e5adab070925;hpb=1c4e300439ce894a5a861c6db8ac04d6b1a90318;p=libcds.git diff --git a/cds/container/michael_list_rcu.h b/cds/container/michael_list_rcu.h index 65a8351e..cfece032 100644 --- a/cds/container/michael_list_rcu.h +++ b/cds/container/michael_list_rcu.h @@ -1,7 +1,35 @@ -//$$CDS-header$$ - -#ifndef __CDS_CONTAINER_MICHAEL_LIST_RCU_H -#define __CDS_CONTAINER_MICHAEL_LIST_RCU_H +/* + 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_CONTAINER_MICHAEL_LIST_RCU_H +#define CDSLIB_CONTAINER_MICHAEL_LIST_RCU_H #include #include @@ -111,7 +139,7 @@ namespace cds { namespace container { //@endcond public: - typedef cds::urcu::gc gc; ///< RCU + typedef cds::urcu::gc gc; ///< RCU typedef T value_type; ///< Type of value stored in the list typedef Traits traits; ///< List traits @@ -123,7 +151,7 @@ namespace cds { namespace container { typedef typename base_class::rcu_check_deadlock rcu_check_deadlock ; ///< RCU deadlock checking policy typedef typename gc::scoped_lock rcu_lock ; ///< RCU scoped lock - static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; ///< Group of \p extract_xxx functions require external locking + static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; ///< Group of \p extract_xxx functions do not require external locking protected: //@cond @@ -136,7 +164,32 @@ namespace cds { namespace container { //@endcond public: - typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer > exempt_ptr; ///< pointer to extracted node + using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer >; ///< pointer to extracted node + + private: + //@cond + struct raw_ptr_converter + { + value_type * operator()( node_type * p ) const + { + return p ? &p->m_Value : nullptr; + } + + value_type& operator()( node_type& n ) const + { + return n.m_Value; + } + + value_type const& operator()( node_type const& n ) const + { + return n.m_Value; + } + }; + //@endcond + + public: + /// Result of \p get(), \p get_with() functions - pointer to the node found + typedef cds::urcu::raw_ptr_adaptor< value_type, typename base_class::raw_ptr, raw_ptr_converter > raw_ptr; private: //@cond @@ -278,7 +331,7 @@ namespace cds { namespace container { { return const_iterator( head() ); } - const_iterator cbegin() + const_iterator cbegin() const { return const_iterator( head() ); } @@ -290,7 +343,7 @@ namespace cds { namespace container { { return const_iterator(); } - const_iterator cend() + const_iterator cend() const { return const_iterator(); } @@ -341,8 +394,6 @@ namespace cds { namespace container { The argument \p itemValue of user-defined functor \p func is the reference to the list's item inserted. User-defined functor \p func should guarantee that during changing item's value no any other changes could be made on this list's item by concurrent threads. - The user-defined functor can be passed by reference using \p std::ref - and it is called only if the inserting is success. The type \p Q should contain the complete key of the node. The object of \ref value_type should be constructible from \p key of type \p Q. @@ -365,44 +416,50 @@ namespace cds { namespace container { return insert_at( head(), key, func ); } - /// Ensures that the \p key exists in the list + /// Updates data by \p key /** - The operation performs inserting or changing data with lock-free manner. + The operation performs inserting or replacing the element with lock-free manner. If the \p key not found in the list, then the new item created from \p key - is inserted into the list. Otherwise, the functor \p func is called with the item found. - The functor \p Func should be a function with signature: - \code - void func( bool bNew, value_type& item, const Q& val ); - \endcode - or a functor: + will be inserted iff \p bAllowInsert is \p true. + Otherwise, if \p key is found, the functor \p func is called with item found. + + The functor \p Func signature is: \code struct my_functor { - void operator()( bool bNew, value_type& item, const Q& val ); + void operator()( bool bNew, value_type& item, Q const& val ); }; \endcode with arguments: - \p bNew - \p true if the item has been inserted, \p false otherwise - \p item - item of the list - - \p val - argument \p key passed into the \p ensure function + - \p val - argument \p key passed into the \p %update() function The functor may change non-key fields of the \p item; however, \p func must guarantee that during changing no any other modifications could be made on this item by concurrent threads. - The function makes RCU lock internally. + The function applies RCU lock internally. Returns std::pair where \p first is true if operation is successfull, \p second is true if new item has been added or \p false if the item with \p key - already is in the list. + already exists. @warning See \ref cds_intrusive_item_creating "insert item troubleshooting" */ template + std::pair update( Q const& key, Func func, bool bAllowInsert = true ) + { + return update_at( head(), key, func, bAllowInsert ); + } + //@cond + template + CDS_DEPRECATED("ensure() is deprecated, use update()") std::pair ensure( Q const& key, Func f ) { - return ensure_at( head(), key, f ); + return update( key, f, true ); } + //@endcond /// Inserts data of type \ref value_type constructed from \p args /** @@ -420,7 +477,7 @@ namespace cds { namespace container { /** \anchor cds_nonintrusive_MichealList_rcu_erase_val Since the key of MichaelList's item type \p value_type is not explicitly specified, template parameter \p Q defines the key type searching in the list. - The list item comparator should be able to compare values of the type \p value_type + The list item comparator should be able to compare values of the type \p value_type and \p Q in any order. RCU \p synchronize method can be called. RCU should not be locked. @@ -443,6 +500,7 @@ namespace cds { namespace container { template bool erase_with( Q const& key, Less pred ) { + CDS_UNUSED( pred ); return erase_at( head(), key, typename maker::template less_wrapper::type(), [](value_type const&){} ); } @@ -453,7 +511,7 @@ namespace cds { namespace container { The functor \p Func interface: \code - struct extractor { + struct functor { void operator()(const value_type& val) { ... } }; \endcode @@ -483,6 +541,7 @@ namespace cds { namespace container { template bool erase_with( Q const& key, Less pred, Func f ) { + CDS_UNUSED( pred ); return erase_at( head(), key, typename maker::template less_wrapper::type(), f ); } @@ -490,13 +549,12 @@ namespace cds { namespace container { /** @anchor cds_nonintrusive_MichaelList_rcu_extract The function searches an item with key equal to \p key in the list, - unlinks it from the list, and returns pointer to an item found in \p dest argument. - If the item with the key equal to \p key is not found the function returns \p false. + unlinks it from the list, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item found. + If the item with the key equal to \p key is not found the function returns an empty \p exempt_ptr. - @note The function does NOT call RCU read-side lock or synchronization, - and does NOT dispose the item found. It just excludes the item from the list - and returns a pointer to item found. - You should lock RCU before calling this function. + @note The function does NOT dispose the item found. It just excludes the item from the list + and returns a pointer to the item. + You shouldn't lock RCU for current thread before calling this function. \code #include @@ -509,69 +567,85 @@ namespace cds { namespace container { // ... rcu_michael_list::exempt_ptr p; - { - // first, we should lock RCU - rcu::scoped_lock sl; - - // Now, you can apply extract function - // Note that you must not delete the item found inside the RCU lock - if ( theList.extract( p, 10 )) { - // do something with p - ... - } + + // The RCU should NOT be locked when extract() is called! + assert( !rcu::is_locked() ); + + // extract() call + p = theList.extract( 10 ) + if ( p ) { + // do something with p + ... } - // Outside RCU lock section we may safely release extracted pointer. + + // we may safely release extracted pointer here. // release() passes the pointer to RCU reclamation cycle. p.release(); \endcode */ template - bool extract( exempt_ptr& dest, Q const& key ) + exempt_ptr extract( Q const& key ) { - dest = extract_at( head(), key, intrusive_key_comparator() ); - return !dest.empty(); + return exempt_ptr( extract_at( head(), key, intrusive_key_comparator() )); } /// Extracts an item from the list using \p pred predicate for searching /** - This function is the analog for \ref cds_nonintrusive_MichaelList_rcu_extract "extract(exempt_ptr&, Q const&)". + This function is the analog for \p extract(Q const&). The \p pred is a predicate used for key comparing. \p Less has the interface like \p std::less. \p pred must imply the same element order as \ref key_comparator. */ template - bool extract_with( exempt_ptr& dest, Q const& key, Less pred ) + exempt_ptr extract_with( Q const& key, Less pred ) { - dest = extract_at( head(), key, typename maker::template less_wrapper::type() ); - return !dest.empty(); + CDS_UNUSED( pred ); + return exempt_ptr( extract_at( head(), key, typename maker::template less_wrapper::type() )); } - /// Finds the key \p key - /** \anchor cds_nonintrusive_MichaelList_rcu_find_val + /// Checks whether the list 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. - The function makes RCU lock internally. + The function applies RCU lock internally. */ template - bool find( Q const& key ) const + bool contains( Q const& key ) { return find_at( head(), key, intrusive_key_comparator() ); } + //@cond + template + CDS_DEPRECATED("deprecated, use contains()") + bool find( Q const& key ) + { + return contains( key ); + } + //@endcond - /// Finds the key \p val using \p pred predicate for searching + /// Checks whether the list contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_nonintrusive_MichaelList_rcu_find_val "find(Q const&)" - but \p pred is used for key comparing. + 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 pred must imply the same element order as the comparator used for building the list. */ template - bool find_with( Q const& key, Less pred ) const + bool contains( Q const& key, Less pred ) { + CDS_UNUSED( pred ); return find_at( head(), key, typename maker::template less_wrapper::type() ); } + //@cond + // Deprecatd, use contains() + template + bool find_with( Q const& key, Less pred ) + { + CDS_UNUSED( pred ); + return contains( key, pred ); + } + //@endcond /// Finds the key \p key and performs an action with it /** \anchor cds_nonintrusive_MichaelList_rcu_find_func @@ -594,10 +668,17 @@ namespace cds { namespace container { The function returns \p true if \p val is found, \p false otherwise. */ template - bool find( Q& key, Func f ) const + bool find( Q& key, Func f ) + { + return find_at( head(), key, intrusive_key_comparator(), f ); + } + //@cond + template + bool find( Q const& key, Func f ) { return find_at( head(), key, intrusive_key_comparator(), f ); } + //@endcond /// Finds the key \p key using \p pred predicate for searching /** @@ -607,15 +688,24 @@ namespace cds { namespace container { \p pred must imply the same element order as the comparator used for building the list. */ template - bool find_with( Q& key, Less pred, Func f ) const + bool find_with( Q& key, Less pred, Func f ) { + CDS_UNUSED( pred ); return find_at( head(), key, typename maker::template less_wrapper::type(), f ); } + //@cond + template + bool find_with( Q const& key, Less pred, Func f ) + { + CDS_UNUSED( pred ); + return find_at( head(), key, typename maker::template less_wrapper::type(), f ); + } + //@endcond /// Finds the key \p key and return the item found /** \anchor cds_nonintrusive_MichaelList_rcu_get The function searches the item with key equal to \p key and returns the pointer to item found. - If \p key is not found it returns \p nullptr. + If \p key is not found it returns an empty \p raw_ptr. Note the compare functor should accept a parameter of type \p Q that can be not the same as \p value_type. @@ -625,22 +715,25 @@ namespace cds { namespace container { typedef cds::container::MichaelList< cds::urcu::gc< cds::urcu::general_buffered<> >, foo, my_traits > ord_list; ord_list theList; // ... + typename ord_list::raw_ptr rp; { // Lock RCU ord_list::rcu_lock lock; - foo * pVal = theList.get( 5 ); - if ( pVal ) { - // Deal with pVal + rp = theList.get( 5 ); + if ( rp ) { + // Deal with rp //... } // Unlock RCU by rcu_lock destructor - // pVal can be freed at any time after RCU has been unlocked + // A value owned by rp can be freed at any time after RCU has been unlocked } + // You can manually release rp after RCU-locked section + rp.release(); \endcode */ template - value_type * get( Q const& key ) const + raw_ptr get( Q const& key ) { return get_at( head(), key, intrusive_key_comparator()); } @@ -655,8 +748,9 @@ namespace cds { namespace container { \p pred must imply the same element order as the comparator used for building the list. */ template - value_type * get_with( Q const& key, Less pred ) const + raw_ptr get_with( Q const& key, Less pred ) { + CDS_UNUSED( pred ); return get_at( head(), key, typename maker::template less_wrapper::type()); } @@ -730,12 +824,13 @@ namespace cds { namespace container { } template - std::pair ensure_at( head_type& refHead, Q const& key, Func f ) + std::pair update_at( head_type& refHead, Q const& key, Func f, bool bAllowInsert ) { scoped_node_ptr pNode( alloc_node( key )); - std::pair ret = base_class::ensure_at( refHead, *pNode, - [&f, &key](bool bNew, node_type& node, node_type&){ f( bNew, node_to_value(node), key ); }); + std::pair ret = base_class::update_at( refHead, *pNode, + [&f, &key](bool bNew, node_type& node, node_type&){ f( bNew, node_to_value(node), key );}, + bAllowInsert ); if ( ret.first && ret.second ) pNode.release(); @@ -749,22 +844,21 @@ namespace cds { namespace container { } template - bool find_at( head_type& refHead, Q const& key, Compare cmp ) const + bool find_at( head_type& refHead, Q const& key, Compare cmp ) { return base_class::find_at( refHead, key, cmp, [](node_type&, Q const &) {} ); } template - bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) const + bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) { return base_class::find_at( refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); }); } template - value_type * get_at( head_type& refHead, Q const& val, Compare cmp ) const + raw_ptr get_at( head_type& refHead, Q const& val, Compare cmp ) { - node_type * pNode = base_class::get_at( refHead, val, cmp ); - return pNode ? &pNode->m_Value : nullptr; + return raw_ptr( base_class::get_at( refHead, val, cmp )); } //@endcond @@ -772,4 +866,4 @@ namespace cds { namespace container { }} // namespace cds::container -#endif // #ifndef __CDS_CONTAINER_MICHAEL_LIST_RCU_H +#endif // #ifndef CDSLIB_CONTAINER_MICHAEL_LIST_RCU_H