X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=cds%2Fcontainer%2Fmichael_list_rcu.h;h=5b3f8e674fe5063ef23512df73e0e1cc22af124a;hb=ec53bf39af3914a93bd1f53fa8657d5f87583d01;hp=24b6b62fc14d247d916b8d24286a98036b0a8e88;hpb=0594e601c8b1fcf9f8ca595d49ef025be04aa8d1;p=libcds.git diff --git a/cds/container/michael_list_rcu.h b/cds/container/michael_list_rcu.h index 24b6b62f..5b3f8e67 100644 --- a/cds/container/michael_list_rcu.h +++ b/cds/container/michael_list_rcu.h @@ -1,7 +1,35 @@ -//$$CDS-header$$ +/* + This file is a part of libcds - Concurrent Data Structures library -#ifndef __CDS_CONTAINER_MICHAEL_LIST_RCU_H -#define __CDS_CONTAINER_MICHAEL_LIST_RCU_H + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017 + + 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 @@ -120,10 +148,27 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counting policy used typedef typename maker::key_comparator key_comparator; ///< key comparison functor typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics 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 + + //@cond + // Rebind traits (split-list support) + template + struct rebind_traits { + typedef MichaelList< + gc + , value_type + , typename cds::opt::make_options< traits, Options...>::type + > type; + }; + + // Stat selector + template + using select_stat_wrapper = typename base_class::template select_stat_wrapper< Stat >; + //@endcond protected: //@cond @@ -133,41 +178,6 @@ namespace cds { namespace container { typedef typename maker::intrusive_traits::compare intrusive_key_comparator; typedef typename base_class::atomic_node_ptr head_type; - //@endcond - - public: - typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer > exempt_ptr; ///< pointer to extracted node - - private: - //@cond - static value_type& node_to_value( node_type& n ) - { - return n.m_Value; - } - static value_type const& node_to_value( node_type const& n ) - { - return n.m_Value; - } - //@endcond - - protected: - //@cond - template - static node_type * alloc_node( Q const& v ) - { - return cxx_allocator().New( v ); - } - - template - static node_type * alloc_node( Args&&... args ) - { - return cxx_allocator().MoveNew( std::forward(args)... ); - } - - static void free_node( node_type * pNode ) - { - cxx_allocator().Delete( pNode ); - } struct node_disposer { void operator()( node_type * pNode ) @@ -176,20 +186,38 @@ namespace cds { namespace container { } }; typedef std::unique_ptr< node_type, node_disposer > scoped_node_ptr; + //@endcond - head_type& head() + private: + //@cond + struct raw_ptr_converter { - return base_class::m_pHead; - } + value_type * operator()( node_type * p ) const + { + return p ? &p->m_Value : nullptr; + } - head_type& head() const - { - return const_cast( base_class::m_pHead ); - } + 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: + ///< pointer to extracted node + using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer >; + + /// 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; + protected: - //@cond + //@cond template class iterator_type: protected base_class::template iterator_type { @@ -244,7 +272,13 @@ namespace cds { namespace container { //@endcond public: + ///@name Forward iterators (only for debugging purpose) + //@{ /// Forward iterator + /** + You may safely use iterators in multi-threaded environment only under RCU lock. + Otherwise, a crash is possible if another thread deletes the item the iterator points to. + */ typedef iterator_type iterator; /// Const forward iterator @@ -256,7 +290,7 @@ namespace cds { namespace container { */ iterator begin() { - return iterator( head() ); + return iterator( head()); } /// Returns an iterator that addresses the location succeeding the last element in a list @@ -273,28 +307,29 @@ namespace cds { namespace container { } /// Returns a forward const iterator addressing the first element in a list - //@{ const_iterator begin() const { - return const_iterator( head() ); + return const_iterator( head()); } + + /// Returns a forward const iterator addressing the first element in a list const_iterator cbegin() const { - return const_iterator( head() ); + return const_iterator( head()); } - //@} /// Returns an const iterator that addresses the location succeeding the last element in a list - //@{ const_iterator end() const { return const_iterator(); } + + /// Returns an const iterator that addresses the location succeeding the last element in a list const_iterator cend() const { return const_iterator(); } - //@} + //@} public: /// Default constructor @@ -304,6 +339,13 @@ namespace cds { namespace container { MichaelList() {} + //@cond + template >::value >> + explicit MichaelList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// List destructor /** Clears the list @@ -327,9 +369,9 @@ namespace cds { namespace container { Returns \p true if inserting successful, \p false otherwise. */ template - bool insert( Q const& val ) + bool insert( Q&& val ) { - return insert_at( head(), val ); + return insert_at( head(), std::forward( val )); } /// Inserts new node @@ -341,8 +383,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. @@ -360,49 +400,55 @@ namespace cds { namespace container { @warning See \ref cds_intrusive_item_creating "insert item troubleshooting" */ template - bool insert( Q const& key, Func func ) + bool insert( Q&& key, Func func ) { - return insert_at( head(), key, func ); + return insert_at( head(), std::forward( 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, + Returns std::pair where \p first is true if operation is successful, \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 +466,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 +489,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 +500,7 @@ namespace cds { namespace container { The functor \p Func interface: \code - struct extractor { + struct functor { void operator()(const value_type& val) { ... } }; \endcode @@ -483,6 +530,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 +538,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 +556,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() ); + 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 ) { - return find_at( head(), key, typename maker::template less_wrapper::type() ); + 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 +657,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 +677,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 +704,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 +737,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()); } @@ -679,6 +762,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { @@ -687,6 +776,11 @@ namespace cds { namespace container { protected: //@cond + bool insert_node( node_type * pNode ) + { + return insert_node_at( head(), pNode ); + } + bool insert_node_at( head_type& refHead, node_type * pNode ) { assert( pNode ); @@ -700,17 +794,17 @@ namespace cds { namespace container { } template - bool insert_at( head_type& refHead, Q const& val ) + bool insert_at( head_type& refHead, Q&& val ) { - return insert_node_at( refHead, alloc_node( val )); + return insert_node_at( refHead, alloc_node( std::forward( val ))); } template - bool insert_at( head_type& refHead, Q const& key, Func f ) + bool insert_at( head_type& refHead, Q&& key, Func f ) { - scoped_node_ptr pNode( alloc_node( key )); + scoped_node_ptr pNode( alloc_node( std::forward( key ))); - if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { f( node_to_value(node) ); } )) { + if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { f( node_to_value(node)); } )) { pNode.release(); return true; } @@ -726,16 +820,17 @@ namespace cds { namespace container { template bool erase_at( head_type& refHead, Q const& key, Compare cmp, Func f ) { - return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node) ); } ); + return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node)); } ); } 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,27 +844,61 @@ 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 ) + { + return raw_ptr( base_class::get_at( refHead, val, cmp )); + } + + static value_type& node_to_value( node_type& n ) + { + return n.m_Value; + } + static value_type const& node_to_value( node_type const& n ) + { + return n.m_Value; + } + + template + static node_type * alloc_node( Q&& v ) { - node_type * pNode = base_class::get_at( refHead, val, cmp ); - return pNode ? &pNode->m_Value : nullptr; + return cxx_allocator().New( std::forward( v )); } + template + static node_type * alloc_node( Args&&... args ) + { + return cxx_allocator().MoveNew( std::forward( args )... ); + } + + static void free_node( node_type * pNode ) + { + cxx_allocator().Delete( pNode ); + } + + head_type& head() + { + return base_class::m_pHead; + } + + head_type& head() const + { + return const_cast(base_class::m_pHead); + } //@endcond }; }} // namespace cds::container -#endif // #ifndef __CDS_CONTAINER_MICHAEL_LIST_RCU_H +#endif // #ifndef CDSLIB_CONTAINER_MICHAEL_LIST_RCU_H