From 26fb5bb88c4449f4177a017305a6ddf9b7574f1c Mon Sep 17 00:00:00 2001 From: khizmax Date: Wed, 9 Sep 2015 21:53:05 +0300 Subject: [PATCH] Refactored Set_DelOdd MT-test --- cds/container/impl/ellen_bintree_set.h | 2 +- cds/container/impl/lazy_list.h | 1 + cds/container/impl/michael_list.h | 2 +- cds/container/michael_set.h | 72 ++- cds/container/michael_set_nogc.h | 66 ++- cds/container/michael_set_rcu.h | 79 ++- cds/intrusive/michael_set.h | 57 +- cds/intrusive/michael_set_nogc.h | 63 ++- cds/intrusive/michael_set_rcu.h | 70 ++- tests/unit/map2/map_delodd.cpp | 16 +- tests/unit/map2/map_delodd.h | 2 +- tests/unit/set2/set_defs.h | 640 +++++++---------------- tests/unit/set2/set_delodd.cpp | 30 +- tests/unit/set2/set_delodd.h | 153 +++--- tests/unit/set2/set_delodd_cuckoo.cpp | 11 +- tests/unit/set2/set_delodd_ellentree.cpp | 11 +- tests/unit/set2/set_delodd_michael.cpp | 11 +- tests/unit/set2/set_delodd_skip.cpp | 11 +- tests/unit/set2/set_delodd_split.cpp | 11 +- tests/unit/set2/set_type_cuckoo.h | 17 +- tests/unit/set2/set_type_ellen_bintree.h | 58 +- tests/unit/set2/set_type_michael.h | 159 +++--- tests/unit/set2/set_type_skip_list.h | 146 +++--- tests/unit/set2/set_type_split_list.h | 301 ++++++----- 24 files changed, 980 insertions(+), 1009 deletions(-) diff --git a/cds/container/impl/ellen_bintree_set.h b/cds/container/impl/ellen_bintree_set.h index 381938fb..8cd28e7a 100644 --- a/cds/container/impl/ellen_bintree_set.h +++ b/cds/container/impl/ellen_bintree_set.h @@ -251,8 +251,8 @@ namespace cds { namespace container { return bRes; } //@cond - // Deprecated, use update() template + CDS_DEPRECATED("ensure() is deprecated, use update()") std::pair ensure( const Q& val, Func func ) { return update( val, func, true ); diff --git a/cds/container/impl/lazy_list.h b/cds/container/impl/lazy_list.h index c3a6f67d..50212291 100644 --- a/cds/container/impl/lazy_list.h +++ b/cds/container/impl/lazy_list.h @@ -421,6 +421,7 @@ namespace cds { namespace container { } //@cond template + CDS_DEPRECATED("ensure() is deprecated, use update()") std::pair ensure( Q const& key, Func f ) { return update( key, f, true ); diff --git a/cds/container/impl/michael_list.h b/cds/container/impl/michael_list.h index 362f1f99..a321d258 100644 --- a/cds/container/impl/michael_list.h +++ b/cds/container/impl/michael_list.h @@ -396,8 +396,8 @@ namespace cds { namespace container { return update_at( head(), key, func, bAllowInsert ); } //@cond - // Deprecated, use update() template + CDS_DEPRECATED("ensure() is deprecated, use update()") std::pair ensure( Q const& key, Func func ) { return update( key, func ); diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h index 5bf3d4a9..3f2a0435 100644 --- a/cds/container/michael_set.h +++ b/cds/container/michael_set.h @@ -368,42 +368,49 @@ namespace cds { namespace container { return bRet; } - /// Ensures that the item exists in the set + /// Updates the element /** The operation performs inserting or changing data with lock-free manner. - If the \p val key not found in the set, then the new item created from \p val - is inserted into the set. Otherwise, the functor \p func is called with the item found. - The functor \p Func signature is: + If the item \p val 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 - struct my_functor { - void operator()( bool bNew, value_type& item, const Q& val ); + struct functor { + 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 set - - \p val - argument \p key passed into the \p ensure function + - \p val - argument \p val passed into the \p %update() function The functor may change non-key fields of the \p item. - 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 + 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. - @warning For \ref cds_nonintrusive_MichaelList_gc "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting". - @ref cds_nonintrusive_LazyList_gc "LazyList" provides exclusive access to inserted item and does not require any node-level + @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( const Q& val, Func func ) + std::pair update( const Q& val, Func func, bool bAllowUpdate = true ) { - std::pair bRet = bucket( val ).ensure( val, func ); - if ( bRet.first && bRet.second ) + std::pair bRet = bucket( val ).update( val, func, bAllowUpdate ); + if ( bRet.second ) ++m_ItemCounter; return bRet; } + //@cond + template + CDS_DEPRECATED("ensure() is deprecated, use update()") + std::pair ensure( const Q& val, Func func ) + { + return update( val, func, true ); + } + //@endcond /// Inserts data of type \p value_type constructed from \p args /** @@ -610,32 +617,47 @@ namespace cds { namespace container { } //@endcond - /// Finds the key \p key - /** \anchor cds_nonintrusive_MichaelSet_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. + and returns \p true if the key 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 may be not the same as \ref value_type. + should accept a parameter of type \p Q that can be not the same as \p value_type. */ template + bool contains( Q const& key ) + { + return bucket( key ).contains( key ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find( Q const& key ) { - return bucket( key ).find( key ); + return contains( key ); } + //@endcond - /// Finds the key \p key using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_nonintrusive_MichaelSet_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 Less must imply the same element order as the comparator used for building the set. */ template + bool contains( Q const& key, Less pred ) + { + return bucket( key ).contains( key, pred ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find_with( Q const& key, Less pred ) { - return bucket( key ).find_with( key, pred ); + return contains( key, pred ); } + //@endcond /// Finds the key \p key and return the item found /** \anchor cds_nonintrusive_MichaelHashSet_hp_get diff --git a/cds/container/michael_set_nogc.h b/cds/container/michael_set_nogc.h index ce0dc31c..dbcb369d 100644 --- a/cds/container/michael_set_nogc.h +++ b/cds/container/michael_set_nogc.h @@ -224,68 +224,94 @@ namespace cds { namespace container { return end(); } - /// Ensures that the item \p val exists in the set + /// Updates the element /** - The operation inserts new item if the key \p val is not found in the set. - Otherwise, the function returns an iterator that points to item found. + The operation performs inserting or changing data with lock-free manner. + + If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true. Returns std::pair where \p first is an iterator pointing to - item found or inserted, \p second is true if new item has been added or \p false if the item - already is in the set. + item found or inserted, or \p end() if \p bAllowInsert is \p false, + \p second is true if new item has been added or \p false if the item is already in the set. - @warning For \ref cds_nonintrusive_MichaelList_nogc "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting". - \ref cds_nonintrusive_LazyList_nogc "LazyList" provides exclusive access to inserted item and does not require any node-level + @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( const Q& val ) + std::pair update( Q const& val, bool bAllowInsert = true ) { bucket_type& refBucket = bucket( val ); - std::pair ret = refBucket.ensure( val ); + std::pair ret = refBucket.update( val, bAllowInsert ); if ( ret.first != refBucket.end() ) { if ( ret.second ) ++m_ItemCounter; return std::make_pair( iterator( ret.first, &refBucket, m_Buckets + bucket_count() ), ret.second ); } - return std::make_pair( end(), ret.second ); } + //@cond + template + CDS_DEPRECATED("ensure() is deprecated, use update()") + std::pair ensure( Q const& val ) + { + return update( val, true ); + } + //@endcond - /// Find the key \p key - /** \anchor cds_nonintrusive_MichealSet_nogc_find + /// Checks whether the set contains \p key + /** The function searches the item with key equal to \p key and returns an iterator pointed to item found if the key is found, - and \ref end() otherwise + or \ref end() 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. */ template - iterator find( Q const& key ) + iterator contains( Q const& key ) { bucket_type& refBucket = bucket( key ); - bucket_iterator it = refBucket.find( key ); + bucket_iterator it = refBucket.contains( key ); if ( it != refBucket.end() ) return iterator( it, &refBucket, m_Buckets + bucket_count() ); return end(); } + //@cond + template + CDS_DEPRECATED("use contains()") + iterator find( Q const& key ) + { + return contains( key ); + } + //@endcond - /// Finds the key \p val using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_nonintrusive_MichealSet_nogc_find "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 Less must imply the same element order as the comparator used for building the set. */ template - iterator find_with( Q const& key, Less pred ) + iterator contains( Q const& key, Less pred ) { bucket_type& refBucket = bucket( key ); - bucket_iterator it = refBucket.find_with( key, pred ); + bucket_iterator it = refBucket.contains( key, pred ); if ( it != refBucket.end() ) return iterator( it, &refBucket, m_Buckets + bucket_count() ); return end(); } + //@cond + template + CDS_DEPRECATED("use contains()") + iterator find_with( Q const& key, Less pred ) + { + return contains( key, pred ); + } + //@endcond /// Clears the set (not atomic) void clear() diff --git a/cds/container/michael_set_rcu.h b/cds/container/michael_set_rcu.h index 868ae890..af3a70b0 100644 --- a/cds/container/michael_set_rcu.h +++ b/cds/container/michael_set_rcu.h @@ -349,14 +349,50 @@ namespace cds { namespace container { \ref cds_nonintrusive_LazyList_rcu "LazyList" provides exclusive access to inserted item and does not require any node-level synchronization. */ + /// Updates the element + /** + The operation performs inserting or changing data with lock-free manner. + + If the item \p val 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 + struct functor { + 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 set + - \p val - argument \p val passed into the \p %update() function + + The functor may change non-key fields of the \p item. + + The function applies RCU lock internally. + + 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. + + @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( const Q& val, Func func ) + std::pair update( const Q& val, Func func, bool bAllowInsert = true ) { - std::pair bRet = bucket( val ).ensure( val, func ); - if ( bRet.first && bRet.second ) + std::pair bRet = bucket( val ).update( val, func, bAllowInsert ); + if ( bRet.second ) ++m_ItemCounter; return bRet; + }//@cond + template + CDS_DEPRECATED("ensure() is deprecated, use update()") + std::pair ensure( const Q& val, Func func ) + { + return update( val, func, true ); } + //@endcond /// Inserts data of type \p value_type created from \p args /** @@ -581,32 +617,45 @@ namespace cds { namespace container { } //@endcond - /// Finds the key \p key - /** \anchor cds_nonintrusive_MichealSet_rcu_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. + and returns \p true if the key 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 may be not the same as \p value_type. + should accept a parameter of type \p Q that can be not the same as \p value_type. */ template - bool find( Q const & key ) + bool contains( Q const& key ) { - return bucket( key ).find( key ); + return bucket( key ).contains( key ); } + //@cond + template + CDS_DEPRECATED("use contains()") + bool find( Q const& key ) + { + return contains( key ); + } + //@endcond - /// Finds the key \p key using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_nonintrusive_MichealSet_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 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 ) + { + return bucket( key ).contains( key, pred ); + } + //@cond + template + CDS_DEPRECATED("use contains()") + bool find_with( Q const& key, Less pred ) { - return bucket( key ).find_with( key, pred ); + return contains( key, pred ); } /// Finds the key \p key and return the item found diff --git a/cds/intrusive/michael_set.h b/cds/intrusive/michael_set.h index 87feff4d..6cf57de2 100644 --- a/cds/intrusive/michael_set.h +++ b/cds/intrusive/michael_set.h @@ -420,20 +420,22 @@ namespace cds { namespace intrusive { return bRet; } - /// Ensures that the \p val exists in the set + /// Updates the element /** The operation performs inserting or changing data with lock-free manner. - If the item \p val not found in the set, then \p val is inserted into the set. + If the item \p val 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 - void func( bool bNew, value_type& item, value_type& val ); + struct functor { + void operator()( bool bNew, value_type& item, value_type& val ); + }; \endcode 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. @@ -448,13 +450,21 @@ namespace cds { namespace intrusive { synchronization. */ template - std::pair ensure( value_type& val, Func func ) + std::pair update( value_type& val, Func func, bool bAllowInsert = true ) { - std::pair bRet = bucket( val ).ensure( val, func ); - if ( bRet.first && bRet.second ) + std::pair bRet = bucket( val ).update( val, func, bAllowInsert ); + if ( bRet.second ) ++m_ItemCounter; 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 /** @@ -662,32 +672,47 @@ namespace cds { namespace intrusive { } //@endcond - /// Finds the key \p key - /** \anchor cds_intrusive_MichaelHashSet_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. + and returns \p true if the key 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. */ template + bool contains( Q const& key ) + { + return bucket( key ).contains( key ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find( Q const& key ) { - return bucket( key ).find( key ); + return contains( key ); } + //@endcond - /// Finds the key \p key using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_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 set. + \p Less must imply the same element order as the comparator used for building the set. */ template + bool contains( Q const& key, Less pred ) + { + return bucket( key ).contains( key, pred ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find_with( Q const& key, Less pred ) { - return bucket( key ).find_with( key, pred ); + return contains( key, pred ); } + //@endcond /// Finds the key \p key and return the item found /** \anchor cds_intrusive_MichaelHashSet_hp_get diff --git a/cds/intrusive/michael_set_nogc.h b/cds/intrusive/michael_set_nogc.h index dd08d821..7ac42f8d 100644 --- a/cds/intrusive/michael_set_nogc.h +++ b/cds/intrusive/michael_set_nogc.h @@ -182,68 +182,93 @@ namespace cds { namespace intrusive { return bRet; } - /// Ensures that the \p item exists in the set + /// Updates the element /** The operation performs inserting or changing data with lock-free manner. - If the item \p val not found in the set, then \p val is inserted into the set. + If the item \p val 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 - void func( bool bNew, value_type& item, value_type& val ); + struct functor { + void operator()( bool bNew, value_type& item, value_type& val ); + }; \endcode 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, + 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. @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting". - \ref cds_intrusive_LazyList_nogc "LazyList" provides exclusive access to inserted item and does not require any node-level + \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 ) { - std::pair bRet = bucket( val ).ensure( val, func ); - if ( bRet.first && bRet.second ) + std::pair bRet = bucket( val ).update( val, func, bAllowInsert ); + if ( bRet.second ) ++m_ItemCounter; 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 - /// Finds the key \p key - /** \anchor cds_intrusive_MichaelHashSet_nogc_find_val + /// Checks whether the set contains \p key + /** The function searches the item with key equal to \p key - and returns pointer to item found, otherwise \p nullptr. + and returns the pointer to an element found or \p nullptr. 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. */ template + value_type * contains( Q const& key ) + { + return bucket( key ).contains( key ); + } + //@cond + template + CDS_DEPRECATED("use contains()") value_type * find( Q const& key ) { - return bucket( key ).find( key ); + return contains( key ); } + //@endcond - /// Finds the key \p key using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_intrusive_MichaelHashSet_nogc_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 set. + \p Less must imply the same element order as the comparator used for building the set. */ template + value_type * contains( Q const& key, Less pred ) + { + return bucket( key ).contains( key, pred ); + } + //@cond + template + CDS_DEPRECATED("use contains()") value_type * find_with( Q const& key, Less pred ) { - return bucket( key ).find_with( key, pred ); + return contains( key ); } + //@endcond /// Finds the key \p key /** \anchor cds_intrusive_MichaelHashSet_nogc_find_func diff --git a/cds/intrusive/michael_set_rcu.h b/cds/intrusive/michael_set_rcu.h index a93e0fe3..019ff24e 100644 --- a/cds/intrusive/michael_set_rcu.h +++ b/cds/intrusive/michael_set_rcu.h @@ -265,41 +265,51 @@ namespace cds { namespace intrusive { return bRet; } - /// Ensures that the \p item exists in the set + /// Updates the element /** The operation performs inserting or changing data with lock-free manner. - If the item \p val not found in the set, then \p val is inserted into the set. + If the item \p val 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 - void func( bool bNew, value_type& item, value_type& val ); + struct functor { + void operator()( bool bNew, value_type& item, value_type& val ); + }; \endcode 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, + 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. - @warning For \ref cds_intrusive_MichaelList_rcu "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting". - \ref cds_intrusive_LazyList_rcu "LazyList" provides exclusive access to inserted item and does not require any node-level + @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 ) { - std::pair bRet = bucket( val ).ensure( val, func ); - if ( bRet.first && bRet.second ) + std::pair bRet = bucket( val ).update( val, func, bAllowInsert ); + if ( bRet.second ) ++m_ItemCounter; 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 /** @@ -461,29 +471,47 @@ namespace cds { namespace intrusive { return p; } - /// Finds the key \p key - /** \anchor cds_intrusive_MichaelHashSet_rcu_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 \p key found or \p false otherwise. + and returns \p true if the key 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. */ template + bool contains( Q const& key ) + { + return bucket( key ).contains( key ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find( Q const& key ) { - return bucket( key ).find( key ); + return contains( key ); } + //@endcond - /// Finds the key \p key using \p pred predicate for searching + /// Checks whether the set contains \p key using \p pred predicate for searching /** - The function is an analog of \ref cds_intrusive_MichaelHashSet_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 set. + \p Less must imply the same element order as the comparator used for building the set. */ template + bool contains( Q const& key, Less pred ) + { + return bucket( key ).contains( key, pred ); + } + //@cond + template + CDS_DEPRECATED("use contains()") bool find_with( Q const& key, Less pred ) { - return bucket( key ).find_with( key, pred ); + return contains( key, pred ); } + //@endcond /// Find the key \p key /** \anchor cds_intrusive_MichaelHashSet_rcu_find_func diff --git a/tests/unit/map2/map_delodd.cpp b/tests/unit/map2/map_delodd.cpp index 2bee64ed..3284565f 100644 --- a/tests/unit/map2/map_delodd.cpp +++ b/tests/unit/map2/map_delodd.cpp @@ -6,16 +6,16 @@ namespace map2 { CPPUNIT_TEST_SUITE_REGISTRATION( Map_DelOdd ); void Map_DelOdd::setUpParams( const CppUnitMini::TestCfg& cfg ) { - c_nMapSize = cfg.getULong("MapSize", static_cast(c_nMapSize) ); - c_nInsThreadCount = cfg.getULong("InsThreadCount", static_cast(c_nInsThreadCount) ); - c_nDelThreadCount = cfg.getULong("DelThreadCount", static_cast(c_nDelThreadCount) ); - c_nExtractThreadCount = cfg.getULong("ExtractThreadCount", static_cast(c_nExtractThreadCount) ); - c_nMaxLoadFactor = cfg.getULong("MaxLoadFactor", static_cast(c_nMaxLoadFactor) ); + c_nMapSize = cfg.getSizeT("MapSize", c_nMapSize ); + c_nInsThreadCount = cfg.getSizeT("InsThreadCount", c_nInsThreadCount ); + c_nDelThreadCount = cfg.getSizeT("DelThreadCount", c_nDelThreadCount ); + c_nExtractThreadCount = cfg.getSizeT("ExtractThreadCount", c_nExtractThreadCount ); + c_nMaxLoadFactor = cfg.getSizeT("MaxLoadFactor", c_nMaxLoadFactor ); c_bPrintGCState = cfg.getBool("PrintGCStateFlag", true ); - c_nCuckooInitialSize = cfg.getULong("CuckooInitialSize", static_cast(c_nCuckooInitialSize) ); - c_nCuckooProbesetSize = cfg.getULong("CuckooProbesetSize", static_cast(c_nCuckooProbesetSize) ); - c_nCuckooProbesetThreshold = cfg.getULong("CuckooProbesetThreshold", static_cast(c_nCuckooProbesetThreshold) ); + c_nCuckooInitialSize = cfg.getSizeT("CuckooInitialSize", c_nCuckooInitialSize ); + c_nCuckooProbesetSize = cfg.getSizeT("CuckooProbesetSize", c_nCuckooProbesetSize ); + c_nCuckooProbesetThreshold = cfg.getSizeT("CuckooProbesetThreshold", c_nCuckooProbesetThreshold ); if ( c_nInsThreadCount == 0 ) diff --git a/tests/unit/map2/map_delodd.h b/tests/unit/map2/map_delodd.h index 3121deed..3bafa791 100644 --- a/tests/unit/map2/map_delodd.h +++ b/tests/unit/map2/map_delodd.h @@ -122,7 +122,7 @@ namespace map2 { size_t c_nMaxLoadFactor = 8; // maximum load factor size_t c_nCuckooInitialSize = 1024;// initial size for CuckooMap size_t c_nCuckooProbesetSize = 16; // CuckooMap probeset size (only for list-based probeset) - size_t c_nCuckooProbesetThreshold = 0; // CUckooMap probeset threshold (o - use default) + size_t c_nCuckooProbesetThreshold = 0; // CUckooMap probeset threshold (0 - use default) bool c_bPrintGCState = true; diff --git a/tests/unit/set2/set_defs.h b/tests/unit/set2/set_defs.h index 969ebc82..e893594f 100644 --- a/tests/unit/set2/set_defs.h +++ b/tests/unit/set2/set_defs.h @@ -17,24 +17,14 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_MichaelSet_RCU_signal \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHB_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHB_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHT_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHT_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHT_less_michaelAlloc) - -# define CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C ) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHB_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHT_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHT_less_michaelAlloc) + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHB_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHB_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHT_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHT_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHT_less_michaelAlloc) # define CDSUNIT_TEST_MichaelSet_RCU_signal \ CPPUNIT_TEST(MichaelSet_RCU_SHB_cmp_stdAlloc) \ @@ -47,57 +37,33 @@ CPPUNIT_TEST(MichaelSet_Lazy_RCU_SHT_less_michaelAlloc) #else # define CDSUNIT_DECLARE_MichaelSet_RCU_signal -# define CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C ) # define CDSUNIT_TEST_MichaelSet_RCU_signal #endif #define CDSUNIT_DECLARE_MichaelSet \ - CDSUNIT_DECLARE_TEST(MichaelSet_HP_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_HP_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_DHP_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_DHP_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPI_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPI_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPB_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPB_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPT_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPT_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_HP_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_HP_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_DHP_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_DHP_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \ - CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_HP_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_HP_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_DHP_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_DHP_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPI_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPI_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPB_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPB_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPT_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPT_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_HP_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_HP_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_DHP_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_DHP_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \ + TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \ CDSUNIT_DECLARE_MichaelSet_RCU_signal -#define CDSUNIT_DEFINE_MichaelSet( IMPL, C ) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_HP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_HP_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_DHP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_DHP_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPI_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPI_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPB_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPT_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_HP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_HP_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_DHP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_DHP_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \ - CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C) - #define CDSUNIT_TEST_MichaelSet \ CPPUNIT_TEST(MichaelSet_HP_cmp_stdAlloc) \ CPPUNIT_TEST(MichaelSet_HP_less_michaelAlloc) \ @@ -124,56 +90,30 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_SplitList_RCU_signal \ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less_stat) - -# define CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C ) \ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_less_stat) + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_less_stat) # define CDSUNIT_TEST_SplitList_RCU_signal \ CPPUNIT_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\ @@ -203,136 +143,72 @@ #else # define CDSUNIT_DECLARE_SplitList_RCU_signal -# define CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C ) # define CDSUNIT_TEST_SplitList_RCU_signal #endif #define CDSUNIT_DECLARE_SplitList \ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_cmp)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less)\ - CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_less_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_cmp)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_less)\ + TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_less_stat)\ CDSUNIT_DECLARE_SplitList_RCU_signal -#define CDSUNIT_DEFINE_SplitList( IMPL, C ) \ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_less_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_cmp)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_less)\ - TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_less_stat)\ - CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C ) - #define CDSUNIT_TEST_SplitList \ CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp)\ CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp_stat)\ @@ -398,57 +274,30 @@ #define CDSUNIT_DECLARE_CuckooSet \ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord_stat)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord) \ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord_stat) \ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord_storehash)\ - CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord_storehash) - -#define CDSUNIT_DEFINE_CuckooSet(IMPL, C) \ - TEST_SET(IMPL, C, CuckooStripedSet_list_unord)\ - TEST_SET(IMPL, C, CuckooStripedSet_list_unord_stat)\ - TEST_SET(IMPL, C, CuckooStripedSet_list_ord)\ - TEST_SET(IMPL, C, CuckooStripedSet_list_ord_stat)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_unord)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_ord)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_unord_stat)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_ord_stat)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_unord)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_ord)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_unord_stat)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_ord_stat)\ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord)\ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord_stat)\ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord) \ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord_stat) \ - TEST_SET(IMPL, C, CuckooStripedSet_list_unord_storehash)\ - TEST_SET(IMPL, C, CuckooStripedSet_list_ord_storehash)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_unord_storehash)\ - TEST_SET(IMPL, C, CuckooStripedSet_vector_ord_storehash)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_unord_storehash)\ - TEST_SET(IMPL, C, CuckooRefinableSet_list_ord_storehash)\ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord_storehash)\ - TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord_storehash) - + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord_stat)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord) \ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord_stat) \ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord_storehash)\ + TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord_storehash) #define CDSUNIT_TEST_CuckooSet \ CPPUNIT_TEST(CuckooStripedSet_list_unord)\ @@ -480,24 +329,14 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_SkipListSet_RCU_signal \ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_cmp_xorshift_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_cmp_xorshift_stat) - -# define CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C ) \ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_cmp_xorshift_stat) + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_cmp_xorshift_stat) # define CDSUNIT_TEST_SkipListSet_RCU_signal \ CPPUNIT_TEST(SkipListSet_rcu_shb_less_pascal)\ @@ -511,56 +350,32 @@ #else # define CDSUNIT_DECLARE_SkipListSet_RCU_signal -# define CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C ) # define CDSUNIT_TEST_SkipListSet_RCU_signal #endif #define CDSUNIT_DECLARE_SkipListSet \ - CDSUNIT_DECLARE_TEST(SkipListSet_hp_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_hp_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_hp_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_hp_cmp_xorshift_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_dhp_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_dhp_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_dhp_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_dhp_cmp_xorshift_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_cmp_xorshift_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_cmp_xorshift_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_less_pascal)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_cmp_pascal_stat)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_less_xorshift)\ - CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_hp_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_hp_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_hp_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_hp_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_dhp_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_dhp_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_dhp_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_dhp_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_cmp_xorshift_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_less_pascal)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_cmp_pascal_stat)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_less_xorshift)\ + TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_cmp_xorshift_stat)\ CDSUNIT_DECLARE_SkipListSet_RCU_signal -#define CDSUNIT_DEFINE_SkipListSet(IMPL, C) \ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_less_pascal)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_cmp_xorshift_stat)\ - CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C ) - #define CDSUNIT_TEST_SkipListSet \ CPPUNIT_TEST(SkipListSet_hp_less_pascal)\ CPPUNIT_TEST(SkipListSet_hp_cmp_pascal_stat)\ @@ -587,16 +402,10 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal \ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_shb)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_shb_stat)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_sht)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_sht_stat) - -# define CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal( IMPL, C ) \ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_shb)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_shb_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_sht)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_sht_stat) + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_shb)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_shb_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_sht)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_sht_stat) # define CDSUNIT_TEST_EllenBinTreeSet_RCU_signal \ CPPUNIT_TEST(EllenBinTreeSet_rcu_shb)\ @@ -605,42 +414,25 @@ CPPUNIT_TEST(EllenBinTreeSet_rcu_sht_stat) #else # define CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal -# define CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal( IMPL, C ) # define CDSUNIT_TEST_EllenBinTreeSet_RCU_signal #endif #define CDSUNIT_DECLARE_EllenBinTreeSet \ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_hp)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_hp)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_hp_stat)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_dhp)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_dhp)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_dhp_stat)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpi)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpi_stat)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpb)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_rcu_gpb)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpb_stat)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpt)\ - CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpt_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_hp)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_hp)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_hp_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_dhp)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_dhp)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_dhp_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpi)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpi_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpb)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_rcu_gpb)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpb_stat)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpt)\ + TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpt_stat)\ CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal -#define CDSUNIT_DEFINE_EllenBinTreeSet( IMPL, C ) \ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_hp)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_hp)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_hp_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_dhp)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_dhp)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_dhp_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpi)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpi_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpb)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_rcu_gpb)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpb_stat)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpt)\ - TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpt_stat)\ - CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal(IMPL, C) - #define CDSUNIT_TEST_EllenBinTreeSet \ CPPUNIT_TEST(EllenBinTreeSet_hp)\ CPPUNIT_TEST(EllenBinTreeSet_yield_hp)\ @@ -671,18 +463,6 @@ CDSUNIT_DECLARE_TEST(StripedSet_rational_hashset) \ CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_unordered_set) -#define CDSUNIT_DEFINE_StripedSet_common( IMPL, C ) \ - TEST_SET(IMPL, C, StripedSet_list) \ - TEST_SET(IMPL, C, StripedSet_vector) \ - TEST_SET(IMPL, C, StripedSet_set) \ - TEST_SET(IMPL, C, StripedSet_hashset) \ - TEST_SET(IMPL, C, StripedSet_boost_unordered_set) \ - TEST_SET(IMPL, C, StripedSet_rational_list) \ - TEST_SET(IMPL, C, StripedSet_rational_vector) \ - TEST_SET(IMPL, C, StripedSet_rational_set) \ - TEST_SET(IMPL, C, StripedSet_rational_hashset) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_unordered_set) - #define CDSUNIT_TEST_StripedSet_common \ CPPUNIT_TEST(StripedSet_list) \ CPPUNIT_TEST(StripedSet_vector) \ @@ -708,18 +488,6 @@ CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_stable_vector) \ CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_set) -# define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) \ - TEST_SET(IMPL, C, StripedSet_boost_list) \ - TEST_SET(IMPL, C, StripedSet_boost_slist) \ - TEST_SET(IMPL, C, StripedSet_boost_vector) \ - TEST_SET(IMPL, C, StripedSet_boost_stable_vector) \ - TEST_SET(IMPL, C, StripedSet_boost_set) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_list) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_slist) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_vector) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_stable_vector) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_set) - # define CDSUNIT_TEST_StripedSet_boost_container \ CPPUNIT_TEST(StripedSet_boost_list) \ CPPUNIT_TEST(StripedSet_boost_slist) \ @@ -733,7 +501,6 @@ CPPUNIT_TEST(StripedSet_rational_boost_set) #else # define CDSUNIT_DECLARE_StripedSet_boost_container -# define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) # define CDSUNIT_TEST_StripedSet_boost_container #endif @@ -741,15 +508,12 @@ # define CDSUNIT_DECLARE_StripedSet_boost_flat_container \ CDSUNIT_DECLARE_TEST(StripedSet_boost_flat_set) \ CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_flat_set) -# define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) \ - TEST_SET(IMPL, C, StripedSet_boost_flat_set) \ - TEST_SET(IMPL, C, StripedSet_rational_boost_flat_set) + # define CDSUNIT_TEST_StripedSet_boost_flat_container \ CPPUNIT_TEST(StripedSet_boost_flat_set) \ CPPUNIT_TEST(StripedSet_rational_boost_flat_set) #else # define CDSUNIT_DECLARE_StripedSet_boost_flat_container -# define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) # define CDSUNIT_TEST_StripedSet_boost_flat_container #endif @@ -757,10 +521,7 @@ CDSUNIT_DECLARE_StripedSet_common \ CDSUNIT_DECLARE_StripedSet_boost_container \ CDSUNIT_DECLARE_StripedSet_boost_flat_container -#define CDSUNIT_DEFINE_StripedSet( IMPL, C ) \ - CDSUNIT_DEFINE_StripedSet_common( IMPL, C ) \ - CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) \ - CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) + #define CDSUNIT_TEST_StripedSet \ CDSUNIT_TEST_StripedSet_common \ CDSUNIT_TEST_StripedSet_boost_container \ @@ -778,17 +539,7 @@ CDSUNIT_DECLARE_TEST(RefinableSet_rational_set) \ CDSUNIT_DECLARE_TEST(RefinableSet_rational_hashset) \ CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_unordered_set) -#define CDSUNIT_DEFINE_RefinableSet_common(IMPL, C) \ - TEST_SET(IMPL, C, RefinableSet_list) \ - TEST_SET(IMPL, C, RefinableSet_vector) \ - TEST_SET(IMPL, C, RefinableSet_set) \ - TEST_SET(IMPL, C, RefinableSet_hashset) \ - TEST_SET(IMPL, C, RefinableSet_boost_unordered_set) \ - TEST_SET(IMPL, C, RefinableSet_rational_list) \ - TEST_SET(IMPL, C, RefinableSet_rational_vector) \ - TEST_SET(IMPL, C, RefinableSet_rational_set) \ - TEST_SET(IMPL, C, RefinableSet_rational_hashset) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_unordered_set) + #define CDSUNIT_TEST_RefinableSet_common \ CPPUNIT_TEST(RefinableSet_list) \ CPPUNIT_TEST(RefinableSet_vector) \ @@ -813,17 +564,7 @@ CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_vector) \ CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_stable_vector) \ CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_set) -# define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ - TEST_SET(IMPL, C, RefinableSet_boost_list) \ - TEST_SET(IMPL, C, RefinableSet_boost_slist) \ - TEST_SET(IMPL, C, RefinableSet_boost_vector) \ - TEST_SET(IMPL, C, RefinableSet_boost_stable_vector) \ - TEST_SET(IMPL, C, RefinableSet_boost_set) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_list) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_slist) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_vector) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_stable_vector) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_set) + # define CDSUNIT_TEST_RefinableSet_boost_container \ CPPUNIT_TEST(RefinableSet_boost_list) \ CPPUNIT_TEST(RefinableSet_boost_slist) \ @@ -837,7 +578,6 @@ CPPUNIT_TEST(RefinableSet_rational_boost_set) #else # define CDSUNIT_DECLARE_RefinableSet_boost_container -# define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ # define CDSUNIT_TEST_RefinableSet_boost_container #endif @@ -845,15 +585,12 @@ # define CDSUNIT_DECLARE_RefinableSet_boost_flat_container \ CDSUNIT_DECLARE_TEST(RefinableSet_boost_flat_set) \ CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_flat_set) -# define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) \ - TEST_SET(IMPL, C, RefinableSet_boost_flat_set) \ - TEST_SET(IMPL, C, RefinableSet_rational_boost_flat_set) + # define CDSUNIT_TEST_RefinableSet_boost_flat_container \ CPPUNIT_TEST(RefinableSet_boost_flat_set) \ CPPUNIT_TEST(RefinableSet_rational_boost_flat_set) #else # define CDSUNIT_DECLARE_RefinableSet_boost_flat_container -# define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) # define CDSUNIT_TEST_RefinableSet_boost_flat_container #endif @@ -861,10 +598,7 @@ CDSUNIT_DECLARE_RefinableSet_common \ CDSUNIT_DECLARE_RefinableSet_boost_container \ CDSUNIT_DECLARE_RefinableSet_boost_flat_container -#define CDSUNIT_DEFINE_RefinableSet( IMPL, C ) \ - CDSUNIT_DEFINE_RefinableSet_common( IMPL, C ) \ - CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ - CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) + #define CDSUNIT_TEST_RefinableSet \ CDSUNIT_TEST_RefinableSet_common \ CDSUNIT_TEST_RefinableSet_boost_container \ diff --git a/tests/unit/set2/set_delodd.cpp b/tests/unit/set2/set_delodd.cpp index 3ad6a882..6eab9448 100644 --- a/tests/unit/set2/set_delodd.cpp +++ b/tests/unit/set2/set_delodd.cpp @@ -5,13 +5,6 @@ namespace set2 { CPPUNIT_TEST_SUITE_REGISTRATION( Set_DelOdd ); - size_t Set_DelOdd::c_nSetSize = 1000000; - size_t Set_DelOdd::c_nInsThreadCount; - size_t Set_DelOdd::c_nDelThreadCount; - size_t Set_DelOdd::c_nExtractThreadCount; - size_t Set_DelOdd::c_nMaxLoadFactor; - bool Set_DelOdd::c_bPrintGCState; - void Set_DelOdd::setUpParams( const CppUnitMini::TestCfg& cfg ) { c_nSetSize = cfg.getSizeT("MapSize", c_nSetSize ); @@ -21,11 +14,15 @@ namespace set2 { c_nMaxLoadFactor = cfg.getSizeT("MaxLoadFactor", c_nMaxLoadFactor); c_bPrintGCState = cfg.getBool("PrintGCStateFlag", true ); + c_nCuckooInitialSize = cfg.getSizeT("CuckooInitialSize", c_nCuckooInitialSize ); + c_nCuckooProbesetSize = cfg.getSizeT("CuckooProbesetSize", c_nCuckooProbesetSize ); + c_nCuckooProbesetThreshold = cfg.getSizeT("CuckooProbesetThreshold", c_nCuckooProbesetThreshold ); + if ( c_nInsThreadCount == 0 ) - c_nInsThreadCount = cds::OS::topology::processor_count(); + c_nInsThreadCount = std::thread::hardware_concurrency(); if ( c_nDelThreadCount == 0 && c_nExtractThreadCount == 0 ) { - c_nExtractThreadCount = cds::OS::topology::processor_count() / 2; - c_nDelThreadCount = cds::OS::topology::processor_count() - c_nExtractThreadCount; + c_nExtractThreadCount = std::thread::hardware_concurrency() / 2; + c_nDelThreadCount = std::thread::hardware_concurrency() - c_nExtractThreadCount; } m_arrData.resize( c_nSetSize ); @@ -33,17 +30,4 @@ namespace set2 { m_arrData[i] = i; shuffle( m_arrData.begin(), m_arrData.end() ); } - - void Set_DelOdd::myRun(const char *in_name, bool invert /*= false*/) - { - setUpParams( m_Cfg.get( "Map_DelOdd" )); - - run_MichaelSet(in_name, invert); - run_SplitList(in_name, invert); - run_SkipListSet(in_name, invert); - run_EllenBinTreeSet(in_name, invert); - run_CuckooSet(in_name, invert); - - endTestCase(); - } } // namespace set2 diff --git a/tests/unit/set2/set_delodd.h b/tests/unit/set2/set_delodd.h index e224d1f6..7ae8c857 100644 --- a/tests/unit/set2/set_delodd.h +++ b/tests/unit/set2/set_delodd.h @@ -5,10 +5,7 @@ namespace set2 { -# define TEST_SET(IMPL, C, X) void C::X() { test::X >(); } -# define TEST_SET_EXTRACT(IMPL, C, X) void C::X() { test_extract::X >(); } -# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf::X >(); } -# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) void C::X() { test_nolf_extract::X >(); } +#define TEST_CASE(TAG, X) void X(); namespace { struct key_thread @@ -119,13 +116,19 @@ namespace set2 { class Set_DelOdd: public CppUnitMini::TestCase { - static size_t c_nSetSize; // max set size - static size_t c_nInsThreadCount; // insert thread count - static size_t c_nDelThreadCount; // delete thread count - static size_t c_nExtractThreadCount; // extract thread count - static size_t c_nMaxLoadFactor; // maximum load factor - static bool c_bPrintGCState; - + public: + size_t c_nSetSize =1000000; // max set size + size_t c_nInsThreadCount = 4; // insert thread count + size_t c_nDelThreadCount = 4; // delete thread count + size_t c_nExtractThreadCount = 4; // extract thread count + size_t c_nMaxLoadFactor = 8; // maximum load factor + bool c_bPrintGCState = true; + + size_t c_nCuckooInitialSize = 1024;// initial size for CuckooSet + size_t c_nCuckooProbesetSize = 16; // CuckooSet probeset size (only for list-based probeset) + size_t c_nCuckooProbesetThreshold = 0; // CUckooSet probeset threshold (0 - use default) + + size_t c_nLoadFactor = 2; std::vector m_arrData; protected: @@ -146,7 +149,7 @@ namespace set2 { return new InsertThread( *this ); } - struct ensure_func + struct update_functor { template void operator()( bool /*bNew*/, key_value_pair const&, Q const& ) @@ -189,10 +192,10 @@ namespace set2 { ++m_nInsertFailed; } - ensure_func f; + update_functor f; for ( size_t i = arrData.size() - 1; i > 0; --i ) { if ( arrData[i] & 1 ) { - rSet.ensure( key_type( arrData[i], m_nThreadNo ), f ); + rSet.update( key_type( arrData[i], m_nThreadNo ), f, true ); } } @@ -311,9 +314,11 @@ namespace set2 { m_nDeleteSuccess = m_nDeleteFailed = 0; + size_t const nInsThreadCount = getTest().c_nInsThreadCount; std::vector& arrData = getTest().m_arrData; + if ( m_nThreadNo & 1 ) { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = 0; i < arrData.size(); ++i ) { if ( arrData[i] & 1 ) { if ( rSet.erase_with( arrData[i], key_less() )) @@ -327,7 +332,7 @@ namespace set2 { } } else { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = arrData.size() - 1; i > 0; --i ) { if ( arrData[i] & 1 ) { if ( rSet.erase_with( arrData[i], key_less() )) @@ -385,8 +390,10 @@ namespace set2 { typename Set::guarded_ptr gp; std::vector& arrData = getTest().m_arrData; + size_t const nInsThreadCount = getTest().c_nInsThreadCount; + if ( m_nThreadNo & 1 ) { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = 0; i < arrData.size(); ++i ) { if ( arrData[i] & 1 ) { gp = rSet.extract_with( arrData[i], key_less()); @@ -402,7 +409,7 @@ namespace set2 { } } else { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = arrData.size() - 1; i > 0; --i ) { if ( arrData[i] & 1 ) { gp = rSet.extract_with( arrData[i], key_less()); @@ -461,8 +468,10 @@ namespace set2 { typename Set::exempt_ptr xp; std::vector& arrData = getTest().m_arrData; + size_t const nInsThreadCount = getTest().c_nInsThreadCount; + if ( m_nThreadNo & 1 ) { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = 0; i < arrData.size(); ++i ) { if ( arrData[i] & 1 ) { if ( Set::c_bExtractLockExternal ) { @@ -488,7 +497,7 @@ namespace set2 { } } else { - for ( size_t k = 0; k < c_nInsThreadCount; ++k ) { + for ( size_t k = 0; k < nInsThreadCount; ++k ) { for ( size_t i = arrData.size() - 1; i > 0; --i ) { if ( arrData[i] & 1 ) { if ( Set::c_bExtractLockExternal ) { @@ -637,7 +646,7 @@ namespace set2 { size_t nErrorCount = 0; for ( size_t n = 0; n < c_nSetSize; n +=2 ) { for ( size_t i = 0; i < c_nInsThreadCount; ++i ) { - if ( !testSet.find( key_type(n, i) ) ) { + if ( !testSet.contains( key_type(n, i) ) ) { if ( ++nErrorCount < 10 ) { CPPUNIT_MSG( "key " << n << "-" << i << " is not found!"); } @@ -661,91 +670,87 @@ namespace set2 { } template - void test() + void run_test() { + static_assert( !Set::c_bExtractSupported, "Set class must not support extract() method" ); + CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount << " delete thread count=" << c_nDelThreadCount << " set size=" << c_nSetSize ); - for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) { - CPPUNIT_MSG( "Load factor=" << nLoadFactor ); - do_test( nLoadFactor ); - if ( c_bPrintGCState ) - print_gc_state(); - } - } + if ( Set::c_bLoadFactorDepended ) { + for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) { + CPPUNIT_MSG( "Load factor=" << c_nLoadFactor ); - template - void test_extract() - { - CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount - << " delete thread count=" << c_nDelThreadCount - << " extract thread count=" << c_nExtractThreadCount - << " set size=" << c_nSetSize - ); + Set testSet( *this ); + do_test_with( testSet ); + analyze( testSet ); + + if ( c_bPrintGCState ) + print_gc_state(); + } + } + else { + Set testSet( *this ); + do_test_with( testSet ); + analyze( testSet ); - for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) { - CPPUNIT_MSG( "Load factor=" << nLoadFactor ); - do_test_extract( nLoadFactor ); if ( c_bPrintGCState ) print_gc_state(); } } template - void test_nolf() + void run_test_extract() { - CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount - << " delete thread count=" << c_nDelThreadCount - << " set size=" << c_nSetSize - ); - - { - Set s; - do_test_with( s ); - analyze( s ); - } - - if ( c_bPrintGCState ) - print_gc_state(); - } + static_assert( Set::c_bExtractSupported, "Set class must support extract() method" ); - template - void test_nolf_extract() - { CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount << " delete thread count=" << c_nDelThreadCount << " extract thread count=" << c_nExtractThreadCount << " set size=" << c_nSetSize ); - { - Set s; - do_test_extract_with( s ); - analyze( s ); + if ( Set::c_bLoadFactorDepended ) { + for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) { + CPPUNIT_MSG( "Load factor=" << c_nLoadFactor ); + + Set testSet( *this ); + do_test_extract_with( testSet ); + analyze( testSet ); + + if ( c_bPrintGCState ) + print_gc_state(); + } } + else { + Set testSet( *this ); + do_test_extract_with( testSet ); + analyze( testSet ); - if ( c_bPrintGCState ) - print_gc_state(); + if ( c_bPrintGCState ) + print_gc_state(); + } } void setUpParams( const CppUnitMini::TestCfg& cfg ); - void run_MichaelSet(const char *in_name, bool invert = false); - void run_SplitList(const char *in_name, bool invert = false); - void run_CuckooSet(const char *in_name, bool invert = false); - void run_SkipListSet(const char *in_name, bool invert = false); - void run_EllenBinTreeSet(const char *in_name, bool invert = false); - - virtual void myRun(const char *in_name, bool invert = false); - - # include "set2/set_defs.h" CDSUNIT_DECLARE_MichaelSet CDSUNIT_DECLARE_SplitList - CDSUNIT_DECLARE_CuckooSet CDSUNIT_DECLARE_SkipListSet CDSUNIT_DECLARE_EllenBinTreeSet + CDSUNIT_DECLARE_CuckooSet + + CPPUNIT_TEST_SUITE(Set_DelOdd) + CDSUNIT_TEST_MichaelSet + CDSUNIT_TEST_SplitList + CDSUNIT_TEST_SkipListSet + CDSUNIT_TEST_EllenBinTreeSet + CDSUNIT_TEST_CuckooSet + + //CDSUNIT_TEST_MultiLevelHashSet // the test is not suitable + CPPUNIT_TEST_SUITE_END(); }; } // namespace set2 diff --git a/tests/unit/set2/set_delodd_cuckoo.cpp b/tests/unit/set2/set_delodd_cuckoo.cpp index 2e543c20..bb2ff0ea 100644 --- a/tests/unit/set2/set_delodd_cuckoo.cpp +++ b/tests/unit/set2/set_delodd_cuckoo.cpp @@ -3,11 +3,10 @@ #include "set2/set_delodd.h" #include "set2/set_type_cuckoo.h" -namespace set2 { - CDSUNIT_DEFINE_CuckooSet( cc::cuckoo::implementation_tag, Set_DelOdd ) - - CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_CuckooSet ) - CDSUNIT_TEST_CuckooSet - CPPUNIT_TEST_SUITE_END_PART() +#undef TEST_CASE +#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test::X>(); } +#include "set2/set_defs.h" +namespace set2 { + CDSUNIT_DECLARE_CuckooSet } // namespace set2 diff --git a/tests/unit/set2/set_delodd_ellentree.cpp b/tests/unit/set2/set_delodd_ellentree.cpp index e4f85627..e9488614 100644 --- a/tests/unit/set2/set_delodd_ellentree.cpp +++ b/tests/unit/set2/set_delodd_ellentree.cpp @@ -3,11 +3,10 @@ #include "set2/set_delodd.h" #include "set2/set_type_ellen_bintree.h" -namespace set2 { - CDSUNIT_DEFINE_EllenBinTreeSet( cc::ellen_bintree::implementation_tag, Set_DelOdd ) - - CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_EllenBinTreeSet ) - CDSUNIT_TEST_EllenBinTreeSet - CPPUNIT_TEST_SUITE_END_PART() +#undef TEST_CASE +#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract::X>(); } +#include "set2/set_defs.h" +namespace set2 { + CDSUNIT_DECLARE_EllenBinTreeSet } // namespace set2 diff --git a/tests/unit/set2/set_delodd_michael.cpp b/tests/unit/set2/set_delodd_michael.cpp index ac7c470c..e94e6ade 100644 --- a/tests/unit/set2/set_delodd_michael.cpp +++ b/tests/unit/set2/set_delodd_michael.cpp @@ -3,11 +3,10 @@ #include "set2/set_delodd.h" #include "set2/set_type_michael.h" -namespace set2 { - CDSUNIT_DEFINE_MichaelSet(cc::michael_set::implementation_tag, Set_DelOdd) - - CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_MichaelSet ) - CDSUNIT_TEST_MichaelSet - CPPUNIT_TEST_SUITE_END_PART() +#undef TEST_CASE +#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract::X>(); } +#include "set2/set_defs.h" +namespace set2 { + CDSUNIT_DECLARE_MichaelSet } // namespace set2 diff --git a/tests/unit/set2/set_delodd_skip.cpp b/tests/unit/set2/set_delodd_skip.cpp index 58a00472..4bc45507 100644 --- a/tests/unit/set2/set_delodd_skip.cpp +++ b/tests/unit/set2/set_delodd_skip.cpp @@ -3,11 +3,10 @@ #include "set2/set_delodd.h" #include "set2/set_type_skip_list.h" -namespace set2 { - CDSUNIT_DEFINE_SkipListSet(cc::skip_list::implementation_tag, Set_DelOdd) - - CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_SkipListSet ) - CDSUNIT_TEST_SkipListSet - CPPUNIT_TEST_SUITE_END_PART() +#undef TEST_CASE +#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract::X>(); } +#include "set2/set_defs.h" +namespace set2 { + CDSUNIT_DECLARE_SkipListSet } // namespace set2 diff --git a/tests/unit/set2/set_delodd_split.cpp b/tests/unit/set2/set_delodd_split.cpp index 993fdcdf..5b57be78 100644 --- a/tests/unit/set2/set_delodd_split.cpp +++ b/tests/unit/set2/set_delodd_split.cpp @@ -3,11 +3,10 @@ #include "set2/set_delodd.h" #include "set2/set_type_split_list.h" -namespace set2 { - CDSUNIT_DEFINE_SplitList(cc::split_list::implementation_tag, Set_DelOdd) - - CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_SplitList ) - CDSUNIT_TEST_SplitList - CPPUNIT_TEST_SUITE_END_PART() +#undef TEST_CASE +#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract::X>(); } +#include "set2/set_defs.h" +namespace set2 { + CDSUNIT_DECLARE_SplitList } // namespace set2 diff --git a/tests/unit/set2/set_type_cuckoo.h b/tests/unit/set2/set_type_cuckoo.h index 3245de90..748a403f 100644 --- a/tests/unit/set2/set_type_cuckoo.h +++ b/tests/unit/set2/set_type_cuckoo.h @@ -17,8 +17,13 @@ namespace set2 { typedef cc::CuckooSet< V, Traits > cuckoo_base_class; public: - CuckooSet( size_t nCapacity, size_t nLoadFactor ) - : cuckoo_base_class( nCapacity / (nLoadFactor * 16), (unsigned int)4 ) + template + CuckooSet( Config const& cfg ) + : cuckoo_base_class( + cfg.c_nCuckooInitialSize, + static_cast( cfg.c_nCuckooProbesetSize ), + static_cast( cfg.c_nCuckooProbesetThreshold ) + ) {} template @@ -26,11 +31,17 @@ namespace set2 { { return cuckoo_base_class::erase_with( key, typename std::conditional< cuckoo_base_class::c_isSorted, Pred, typename Pred::equal_to>::type() ); } + + // for testing + static CDS_CONSTEXPR bool const c_bExtractSupported = false; + static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false; + }; + struct tag_CuckooSet; template - struct set_type< cds::intrusive::cuckoo::implementation_tag, Key, Val >: public set_type_base< Key, Val > + struct set_type< tag_CuckooSet, Key, Val >: public set_type_base< Key, Val > { typedef set_type_base< Key, Val > base_class; typedef typename base_class::key_val key_val; diff --git a/tests/unit/set2/set_type_ellen_bintree.h b/tests/unit/set2/set_type_ellen_bintree.h index 23cee387..5eb2cc5a 100644 --- a/tests/unit/set2/set_type_ellen_bintree.h +++ b/tests/unit/set2/set_type_ellen_bintree.h @@ -13,8 +13,24 @@ namespace set2 { + template + class EllenBinTreeSet : public cc::EllenBinTreeSet< GC, Key, T, Traits > + { + typedef cc::EllenBinTreeSet< GC, Key, T, Traits > base_class; + public: + template + EllenBinTreeSet( Config const& /*cfg*/ ) + {} + + // for testing + static CDS_CONSTEXPR bool const c_bExtractSupported = true; + static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false; + }; + + struct tag_EllenBinTreeSet; + template - struct set_type< cc::ellen_bintree::implementation_tag, Key, Val >: public set_type_base< Key, Val > + struct set_type< tag_EllenBinTreeSet, Key, Val >: public set_type_base< Key, Val > { typedef set_type_base< Key, Val > base_class; typedef typename base_class::key_type key_type; @@ -102,44 +118,44 @@ namespace set2 { { typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_hp > EllenBinTreeSet_hp; + typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_hp > EllenBinTreeSet_hp; struct traits_EllenBinTreeSet_dhp : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_dhp > EllenBinTreeSet_dhp; + typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_dhp > EllenBinTreeSet_dhp; struct traits_EllenBinTreeSet_gpi : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpi::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_gpi > EllenBinTreeSet_rcu_gpi; + typedef EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_gpi > EllenBinTreeSet_rcu_gpi; struct traits_EllenBinTreeSet_gpb : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_gpb > EllenBinTreeSet_rcu_gpb; + typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_gpb > EllenBinTreeSet_rcu_gpb; struct traits_EllenBinTreeSet_gpt : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpt::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_gpt > EllenBinTreeSet_rcu_gpt; + typedef EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_gpt > EllenBinTreeSet_rcu_gpt; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED struct traits_EllenBinTreeSet_shb : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::shb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_shb > EllenBinTreeSet_rcu_shb; + typedef EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_shb > EllenBinTreeSet_rcu_shb; struct traits_EllenBinTreeSet_sht : public traits_EllenBinTreeSet { typedef cds::memory::pool_allocator< typename ellen_bintree_props::sht::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_sht > EllenBinTreeSet_rcu_sht; + typedef EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_sht > EllenBinTreeSet_rcu_sht; #endif // @@ -152,20 +168,20 @@ namespace set2 { { typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_yield_hp > EllenBinTreeSet_yield_hp; + typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_yield_hp > EllenBinTreeSet_yield_hp; struct traits_EllenBinTreeSet_yield_dhp : public traits_EllenBinTreeSet_yield { typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_yield_dhp > EllenBinTreeSet_yield_dhp; + typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_yield_dhp > EllenBinTreeSet_yield_dhp; struct traits_EllenBinTreeSet_yield_gpb : public traits_EllenBinTreeSet_yield { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_yield_gpb > EllenBinTreeSet_yield_rcu_gpb; + typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_yield_gpb > EllenBinTreeSet_yield_rcu_gpb; struct traits_EllenBinTreeSet_stat: public cc::ellen_bintree::make_set_traits< @@ -180,50 +196,50 @@ namespace set2 { { typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_stat_hp > EllenBinTreeSet_hp_stat; + typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_stat_hp > EllenBinTreeSet_hp_stat; struct traits_EllenBinTreeSet_stat_dhp : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_stat_dhp > EllenBinTreeSet_dhp_stat; + typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_stat_dhp > EllenBinTreeSet_dhp_stat; struct traits_EllenBinTreeSet_stat_gpi : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpi::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_stat_gpi > EllenBinTreeSet_rcu_gpi_stat; + typedef EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_stat_gpi > EllenBinTreeSet_rcu_gpi_stat; struct traits_EllenBinTreeSet_stat_gpb : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_stat_gpb > EllenBinTreeSet_rcu_gpb_stat; + typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_stat_gpb > EllenBinTreeSet_rcu_gpb_stat; struct traits_EllenBinTreeSet_stat_gpt : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpt::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_stat_gpt > EllenBinTreeSet_rcu_gpt_stat; + typedef EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_stat_gpt > EllenBinTreeSet_rcu_gpt_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED struct traits_EllenBinTreeSet_stat_shb : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::shb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_stat_shb > EllenBinTreeSet_rcu_shb_stat; + typedef EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_stat_shb > EllenBinTreeSet_rcu_shb_stat; struct traits_EllenBinTreeSet_stat_sht : public traits_EllenBinTreeSet_stat { typedef cds::memory::pool_allocator< typename ellen_bintree_props::sht::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator; }; - typedef cc::EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_stat_sht > EllenBinTreeSet_rcu_sht_stat; + typedef EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_stat_sht > EllenBinTreeSet_rcu_sht_stat; #endif }; template - static inline void print_stat( cc::EllenBinTreeSet const& s ) + static inline void print_stat( EllenBinTreeSet const& s ) { CPPUNIT_MSG( s.statistics() ); } @@ -252,14 +268,14 @@ namespace set2 { } // namespace ellen_bintree_check template - static inline void additional_check( cc::EllenBinTreeSet& s ) + static inline void additional_check( EllenBinTreeSet& s ) { GC::force_dispose(); ellen_bintree_check::check_stat( s.statistics() ); } template - static inline void additional_cleanup( cc::EllenBinTreeSet& /*s*/ ) + static inline void additional_cleanup( EllenBinTreeSet& /*s*/ ) { ellen_bintree_pool::internal_node_counter::reset(); } diff --git a/tests/unit/set2/set_type_michael.h b/tests/unit/set2/set_type_michael.h index 2df4f2c6..e5d7a2b5 100644 --- a/tests/unit/set2/set_type_michael.h +++ b/tests/unit/set2/set_type_michael.h @@ -13,8 +13,25 @@ namespace set2 { + template + class MichaelHashSet : public cc::MichaelHashSet< GC, List, Traits > + { + typedef cc::MichaelHashSet< GC, List, Traits > base_class; + public: + template + MichaelHashSet( Config const& cfg ) + : base_class( cfg.c_nSetSize, cfg.c_nLoadFactor ) + {} + + // for testing + static CDS_CONSTEXPR bool const c_bExtractSupported = true; + static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true; + }; + + struct tag_MichaelHashSet; + template - struct set_type< cc::michael_set::implementation_tag, Key, Val >: public set_type_base< Key, Val > + struct set_type< tag_MichaelHashSet, Key, Val >: public set_type_base< Key, Val > { typedef set_type_base< Key, Val > base_class; typedef typename base_class::key_val key_val; @@ -32,34 +49,34 @@ namespace set2 { co::hash< hash > >::type {}; - typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc; + typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc; + typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc; + typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc; + typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc; + typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc; + typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc; + typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc_seqcst; + typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst; + typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst; #endif struct traits_MichaelSet_michaelAlloc : @@ -68,24 +85,24 @@ namespace set2 { co::allocator< memory::MichaelAllocator > >::type {}; - typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_cmp_michaelAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_cmp_michaelAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_cmp_michaelAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_cmp_michaelAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_less_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_less_michaelAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_less_michaelAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_less_michaelAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_less_michaelAlloc; + typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_less_michaelAlloc; + typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_less_michaelAlloc; #endif @@ -94,54 +111,54 @@ namespace set2 { typedef lazy_list_type< Key, Val > ll; - typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc; + typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc; + typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc; + typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc; + typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc; + typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc; + typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc; + typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc; + typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc_seqcst; + typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst; + typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_seqcst; + typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_seqcst; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_cmp_michaelAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_cmp_michaelAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_cmp_michaelAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc; + typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc; #endif - typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_less_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_less_michaelAlloc; + typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_less_michaelAlloc; + typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_less_michaelAlloc; + typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_less_michaelAlloc; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc; + typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc; + typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc; #endif }; diff --git a/tests/unit/set2/set_type_skip_list.h b/tests/unit/set2/set_type_skip_list.h index 30873cf9..0a7bc7f1 100644 --- a/tests/unit/set2/set_type_skip_list.h +++ b/tests/unit/set2/set_type_skip_list.h @@ -13,8 +13,24 @@ namespace set2 { + template + class SkipListSet : public cc::SkipListSet + { + typedef cc::SkipListSet base_class; + public: + template + SkipListSet( Config const& /*cfg*/ ) + {} + + // for testing + static CDS_CONSTEXPR bool const c_bExtractSupported = true; + static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false; + }; + + struct tag_SkipListSet; + template - struct set_type< cc::skip_list::implementation_tag, Key, Val >: public set_type_base< Key, Val > + struct set_type< tag_SkipListSet, Key, Val >: public set_type_base< Key, Val > { typedef set_type_base< Key, Val > base_class; typedef typename base_class::key_val key_val; @@ -28,14 +44,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal > SkipListSet_hp_less_pascal; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal > SkipListSet_dhp_less_pascal; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpi_less_pascal; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpb_less_pascal; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpt_less_pascal; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal > SkipListSet_hp_less_pascal; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal > SkipListSet_dhp_less_pascal; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpi_less_pascal; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpb_less_pascal; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpt_less_pascal; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_shb_less_pascal; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_sht_less_pascal; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_shb_less_pascal; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_sht_less_pascal; #endif class traits_SkipListSet_less_pascal_seqcst: public cc::skip_list::make_traits < @@ -45,14 +61,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_hp_less_pascal_seqcst; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_dhp_less_pascal_seqcst; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpi_less_pascal_seqcst; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpb_less_pascal_seqcst; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpt_less_pascal_seqcst; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_hp_less_pascal_seqcst; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_dhp_less_pascal_seqcst; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpi_less_pascal_seqcst; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpb_less_pascal_seqcst; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpt_less_pascal_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_shb_less_pascal_seqcst; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_sht_less_pascal_seqcst; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_shb_less_pascal_seqcst; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_sht_less_pascal_seqcst; #endif class traits_SkipListSet_less_pascal_stat: public cc::skip_list::make_traits < @@ -62,14 +78,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_hp_less_pascal_stat; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_dhp_less_pascal_stat; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpi_less_pascal_stat; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpb_less_pascal_stat; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpt_less_pascal_stat; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_hp_less_pascal_stat; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_dhp_less_pascal_stat; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpi_less_pascal_stat; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpb_less_pascal_stat; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpt_less_pascal_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_shb_less_pascal_stat; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_sht_less_pascal_stat; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_shb_less_pascal_stat; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_sht_less_pascal_stat; #endif class traits_SkipListSet_cmp_pascal: public cc::skip_list::make_traits < @@ -78,14 +94,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_hp_cmp_pascal; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_dhp_cmp_pascal; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpi_cmp_pascal; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpb_cmp_pascal; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpt_cmp_pascal; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_hp_cmp_pascal; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_dhp_cmp_pascal; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpi_cmp_pascal; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpb_cmp_pascal; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpt_cmp_pascal; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_shb_cmp_pascal; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_sht_cmp_pascal; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_shb_cmp_pascal; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_sht_cmp_pascal; #endif class traits_SkipListSet_cmp_pascal_stat: public cc::skip_list::make_traits < @@ -95,14 +111,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_hp_cmp_pascal_stat; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_dhp_cmp_pascal_stat; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpi_cmp_pascal_stat; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpb_cmp_pascal_stat; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpt_cmp_pascal_stat; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_hp_cmp_pascal_stat; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_dhp_cmp_pascal_stat; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpi_cmp_pascal_stat; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpb_cmp_pascal_stat; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpt_cmp_pascal_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_shb_cmp_pascal_stat; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_sht_cmp_pascal_stat; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_shb_cmp_pascal_stat; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_sht_cmp_pascal_stat; #endif class traits_SkipListSet_less_xorshift: public cc::skip_list::make_traits < @@ -111,14 +127,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_hp_less_xorshift; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_dhp_less_xorshift; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpi_less_xorshift; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpb_less_xorshift; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpt_less_xorshift; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_hp_less_xorshift; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_dhp_less_xorshift; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpi_less_xorshift; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpb_less_xorshift; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpt_less_xorshift; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_shb_less_xorshift; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_sht_less_xorshift; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_shb_less_xorshift; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_sht_less_xorshift; #endif class traits_SkipListSet_less_xorshift_stat: public cc::skip_list::make_traits < @@ -128,14 +144,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_hp_less_xorshift_stat; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_dhp_less_xorshift_stat; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpi_less_xorshift_stat; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpb_less_xorshift_stat; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpt_less_xorshift_stat; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_hp_less_xorshift_stat; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_dhp_less_xorshift_stat; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpi_less_xorshift_stat; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpb_less_xorshift_stat; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpt_less_xorshift_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_shb_less_xorshift_stat; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_sht_less_xorshift_stat; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_shb_less_xorshift_stat; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_sht_less_xorshift_stat; #endif class traits_SkipListSet_cmp_xorshift: public cc::skip_list::make_traits < @@ -144,14 +160,14 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_hp_cmp_xorshift; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_dhp_cmp_xorshift; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpi_cmp_xorshift; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpb_cmp_xorshift; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpt_cmp_xorshift; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_hp_cmp_xorshift; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_dhp_cmp_xorshift; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpi_cmp_xorshift; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpb_cmp_xorshift; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpt_cmp_xorshift; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_shb_cmp_xorshift; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_sht_cmp_xorshift; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_shb_cmp_xorshift; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_sht_cmp_xorshift; #endif class traits_SkipListSet_cmp_xorshift_stat: public cc::skip_list::make_traits < @@ -161,19 +177,19 @@ namespace set2 { ,co::item_counter< cds::atomicity::item_counter > >::type {}; - typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_hp_cmp_xorshift_stat; - typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_dhp_cmp_xorshift_stat; - typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpi_cmp_xorshift_stat; - typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpb_cmp_xorshift_stat; - typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpt_cmp_xorshift_stat; + typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_hp_cmp_xorshift_stat; + typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_dhp_cmp_xorshift_stat; + typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpi_cmp_xorshift_stat; + typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpb_cmp_xorshift_stat; + typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpt_cmp_xorshift_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_shb_cmp_xorshift_stat; - typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_sht_cmp_xorshift_stat; + typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_shb_cmp_xorshift_stat; + typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_sht_cmp_xorshift_stat; #endif }; template - static inline void print_stat( cc::SkipListSet const& s ) + static inline void print_stat( SkipListSet const& s ) { CPPUNIT_MSG( s.statistics() ); } diff --git a/tests/unit/set2/set_type_split_list.h b/tests/unit/set2/set_type_split_list.h index 13b9e397..6d4134c9 100644 --- a/tests/unit/set2/set_type_split_list.h +++ b/tests/unit/set2/set_type_split_list.h @@ -19,8 +19,25 @@ namespace set2 { + template + class SplitListSet : public cc::SplitListSet< GC, T, Traits > + { + typedef cc::SplitListSet< GC, T, Traits > base_class; + public: + template + SplitListSet( Config const& cfg ) + : base_class( cfg.c_nSetSize, cfg.c_nLoadFactor ) + {} + + // for testing + static CDS_CONSTEXPR bool const c_bExtractSupported = true; + static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true; + }; + + struct tag_SplitListSet; + template - struct set_type< cc::split_list::implementation_tag, Key, Val >: public set_type_base< Key, Val > + struct set_type< tag_SplitListSet, Key, Val >: public set_type_base< Key, Val > { typedef set_type_base< Key, Val > base_class; typedef typename base_class::key_val key_val; @@ -42,14 +59,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp; #endif struct traits_SplitList_Michael_dyn_cmp_stat : @@ -64,14 +81,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat; #endif struct traits_SplitList_Michael_dyn_cmp_seqcst : @@ -87,14 +104,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst; #endif struct traits_SplitList_Michael_st_cmp : @@ -109,14 +126,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp; #endif struct traits_SplitList_Michael_st_cmp_seqcst : @@ -133,14 +150,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_HP_st_cmp_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_DHP_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPI_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPB_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPT_st_cmp_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_HP_st_cmp_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_DHP_st_cmp_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPI_st_cmp_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPB_st_cmp_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPT_st_cmp_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHB_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHT_st_cmp_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHB_st_cmp_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHT_st_cmp_seqcst; #endif //HP + less @@ -155,14 +172,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less; #endif struct traits_SplitList_Michael_dyn_less_seqcst : @@ -178,14 +195,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst; #endif struct traits_SplitList_Michael_st_less : @@ -200,14 +217,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less; #endif struct traits_SplitList_Michael_st_less_stat : @@ -223,14 +240,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat; #endif struct traits_SplitList_Michael_st_less_seqcst : @@ -247,14 +264,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst; #endif // *************************************************************************** @@ -271,28 +288,28 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp; #endif struct traits_SplitList_Lazy_dyn_cmp_stat : public traits_SplitList_Lazy_dyn_cmp { typedef cc::split_list::stat<> stat; }; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp_stat; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp_stat; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp_stat; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp_stat; #endif struct traits_SplitList_Lazy_dyn_cmp_seqcst : @@ -308,14 +325,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst; #endif struct traits_SplitList_Lazy_st_cmp : @@ -330,14 +347,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp; #endif struct traits_SplitList_Lazy_st_cmp_seqcst : @@ -354,14 +371,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_HP_st_cmp_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_DHP_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPI_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPB_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPT_st_cmp_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_HP_st_cmp_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_DHP_st_cmp_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPI_st_cmp_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPB_st_cmp_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPT_st_cmp_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHB_st_cmp_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHT_st_cmp_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHB_st_cmp_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHT_st_cmp_seqcst; #endif struct traits_SplitList_Lazy_dyn_less : @@ -375,14 +392,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less; #endif struct traits_SplitList_Lazy_dyn_less_seqcst : @@ -398,14 +415,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst; #endif struct traits_SplitList_Lazy_st_less : @@ -420,14 +437,14 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less; #endif struct traits_SplitList_Lazy_st_less_seqcst : @@ -444,33 +461,33 @@ namespace set2 { > >::type {}; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst; #endif struct traits_SplitList_Lazy_st_less_stat : public traits_SplitList_Lazy_st_less { typedef cc::split_list::stat<> stat; }; - typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat; - typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat; - typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat; - typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat; - typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat; + typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat; + typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat; + typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat; + typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat; + typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat; #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat; - typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat; + typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat; + typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat; #endif }; template - static inline void print_stat( cc::SplitListSet const& s ) + static inline void print_stat( SplitListSet const& s ) { CPPUNIT_MSG( s.statistics() ); } -- 2.34.1