From 4ca7a52111a504c05818a718a21081fb04fea00e Mon Sep 17 00:00:00 2001 From: khizmax Date: Mon, 6 Apr 2015 18:29:49 +0300 Subject: [PATCH] Split up set2 unit test to reduce compiling time and memory --- cds/container/cuckoo_map.h | 5 +- cds/container/cuckoo_set.h | 5 +- cds/container/details/cuckoo_base.h | 1 + cds/container/details/ellen_bintree_base.h | 2 + cds/container/details/michael_map_base.h | 2 + cds/container/details/michael_set_base.h | 1 + cds/container/details/skip_list_base.h | 1 + cds/container/details/split_list_base.h | 2 + cds/container/ellen_bintree_map_rcu.h | 5 +- cds/container/ellen_bintree_set_rcu.h | 4 + cds/container/impl/ellen_bintree_map.h | 4 + cds/container/impl/ellen_bintree_set.h | 4 + cds/container/impl/skip_list_map.h | 4 + cds/container/impl/skip_list_set.h | 4 + cds/container/michael_map.h | 4 + cds/container/michael_map_nogc.h | 4 + cds/container/michael_map_rcu.h | 4 + cds/container/michael_set.h | 4 + cds/container/michael_set_nogc.h | 4 + cds/container/michael_set_rcu.h | 4 + cds/container/skip_list_map_nogc.h | 4 + cds/container/skip_list_map_rcu.h | 4 + cds/container/skip_list_set_nogc.h | 4 + cds/container/skip_list_set_rcu.h | 4 + cds/container/split_list_map.h | 4 + cds/container/split_list_map_nogc.h | 4 + cds/container/split_list_map_rcu.h | 4 + cds/container/split_list_set.h | 4 + cds/container/split_list_set_nogc.h | 4 + cds/container/split_list_set_rcu.h | 5 + cds/container/striped_map.h | 3 + cds/container/striped_set.h | 4 + cds/container/striped_set/adapter.h | 1 + cds/intrusive/cuckoo_set.h | 6 + cds/intrusive/details/ellen_bintree_base.h | 1 + cds/intrusive/details/michael_set_base.h | 6 +- cds/intrusive/details/skip_list_base.h | 3 + cds/intrusive/details/split_list_base.h | 6 +- cds/intrusive/ellen_bintree_rcu.h | 4 + cds/intrusive/impl/ellen_bintree.h | 4 + cds/intrusive/impl/skip_list.h | 3 + cds/intrusive/michael_set.h | 4 + cds/intrusive/michael_set_nogc.h | 4 + cds/intrusive/michael_set_rcu.h | 4 + cds/intrusive/skip_list_nogc.h | 1 + cds/intrusive/skip_list_rcu.h | 1 + cds/intrusive/split_list.h | 4 + cds/intrusive/split_list_nogc.h | 4 + cds/intrusive/split_list_rcu.h | 4 + cds/intrusive/striped_set.h | 4 + cds/intrusive/striped_set/adapter.h | 3 + projects/Win/vc12/cds.sln | 14 +- tests/cppunit/cppunit_mini.h | 2 + tests/unit/set2/set_defs.h | 666 ++++-- tests/unit/set2/set_delodd.h | 12 +- tests/unit/set2/set_delodd_cuckoo.cpp | 3 + tests/unit/set2/set_delodd_ellentree.cpp | 3 + tests/unit/set2/set_delodd_michael.cpp | 3 + tests/unit/set2/set_delodd_skip.cpp | 3 + tests/unit/set2/set_delodd_split.cpp | 3 + tests/unit/set2/set_insdel_func.cpp | 2 + tests/unit/set2/set_insdel_func.h | 11 +- tests/unit/set2/set_insdel_func_cuckoo.cpp | 3 + tests/unit/set2/set_insdel_func_ellentree.cpp | 3 + tests/unit/set2/set_insdel_func_refinable.cpp | 3 + tests/unit/set2/set_insdel_func_skip.cpp | 4 +- tests/unit/set2/set_insdel_func_split.cpp | 3 + tests/unit/set2/set_insdel_func_striped.cpp | 2 + tests/unit/set2/set_insdel_string.h | 10 +- tests/unit/set2/set_insdel_string_cuckoo.cpp | 3 + .../unit/set2/set_insdel_string_ellentree.cpp | 3 + tests/unit/set2/set_insdel_string_michael.cpp | 3 + .../unit/set2/set_insdel_string_refinable.cpp | 3 + tests/unit/set2/set_insdel_string_skip.cpp | 3 + tests/unit/set2/set_insdel_string_split.cpp | 3 + tests/unit/set2/set_insdel_string_std.cpp | 3 + tests/unit/set2/set_insdel_string_striped.cpp | 3 + tests/unit/set2/set_insdelfind.cpp | 13 - tests/unit/set2/set_insdelfind.h | 10 +- tests/unit/set2/set_insdelfind_cuckoo.cpp | 3 + tests/unit/set2/set_insdelfind_ellentree.cpp | 3 + tests/unit/set2/set_insdelfind_michael.cpp | 4 + tests/unit/set2/set_insdelfind_refinable.cpp | 3 + tests/unit/set2/set_insdelfind_skip.cpp | 3 + tests/unit/set2/set_insdelfind_split.cpp | 3 + tests/unit/set2/set_insdelfind_std.cpp | 3 + tests/unit/set2/set_insdelfind_striped.cpp | 3 + tests/unit/set2/set_type.h | 215 ++ tests/unit/set2/set_type_cuckoo.h | 170 ++ tests/unit/set2/set_type_ellen_bintree.h | 275 +++ tests/unit/set2/set_type_lazy_list.h | 116 ++ tests/unit/set2/set_type_michael.h | 150 ++ tests/unit/set2/set_type_michael_list.h | 116 ++ tests/unit/set2/set_type_skip_list.h | 183 ++ tests/unit/set2/set_type_split_list.h | 480 +++++ tests/unit/set2/set_type_std.h | 206 ++ tests/unit/set2/set_type_striped.h | 293 +++ tests/unit/set2/set_types.h | 1825 ----------------- tests/unit/set2/std_hash_set.h | 102 - tests/unit/set2/std_set.h | 90 - 100 files changed, 2960 insertions(+), 2266 deletions(-) create mode 100644 tests/unit/set2/set_type.h create mode 100644 tests/unit/set2/set_type_cuckoo.h create mode 100644 tests/unit/set2/set_type_ellen_bintree.h create mode 100644 tests/unit/set2/set_type_lazy_list.h create mode 100644 tests/unit/set2/set_type_michael.h create mode 100644 tests/unit/set2/set_type_michael_list.h create mode 100644 tests/unit/set2/set_type_skip_list.h create mode 100644 tests/unit/set2/set_type_split_list.h create mode 100644 tests/unit/set2/set_type_std.h create mode 100644 tests/unit/set2/set_type_striped.h delete mode 100644 tests/unit/set2/set_types.h delete mode 100644 tests/unit/set2/std_hash_set.h delete mode 100644 tests/unit/set2/std_set.h diff --git a/cds/container/cuckoo_map.h b/cds/container/cuckoo_map.h index d98a22bf..b5204ffd 100644 --- a/cds/container/cuckoo_map.h +++ b/cds/container/cuckoo_map.h @@ -267,6 +267,10 @@ namespace cds { namespace container { /// item counter type typedef typename traits::item_counter item_counter; + //@cond + typedef cds::container::cuckoo::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::scoped_cell_lock scoped_cell_lock; @@ -724,7 +728,6 @@ namespace cds { namespace container { { return base_class::mutex_policy_statistics(); } - }; }} // namespace cds::container diff --git a/cds/container/cuckoo_set.h b/cds/container/cuckoo_set.h index b2554a58..1142cce7 100644 --- a/cds/container/cuckoo_set.h +++ b/cds/container/cuckoo_set.h @@ -345,6 +345,10 @@ namespace cds { namespace container { /// item counter type typedef typename traits::item_counter item_counter; + //@cond + typedef cds::container::cuckoo::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::value_type node_type; @@ -824,7 +828,6 @@ namespace cds { namespace container { { return base_class::mutex_policy_statistics(); } - }; }} // namespace cds::container diff --git a/cds/container/details/cuckoo_base.h b/cds/container/details/cuckoo_base.h index bf2dcafa..34f07a2e 100644 --- a/cds/container/details/cuckoo_base.h +++ b/cds/container/details/cuckoo_base.h @@ -11,6 +11,7 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace cuckoo { + using cds::intrusive::cuckoo::implementation_tag; #ifdef CDS_DOXYGEN_INVOKED /// Lock striping concurrent access policy. This is typedef for intrusive::cuckoo::striping template diff --git a/cds/container/details/ellen_bintree_base.h b/cds/container/details/ellen_bintree_base.h index a8e847ed..3be1c584 100644 --- a/cds/container/details/ellen_bintree_base.h +++ b/cds/container/details/ellen_bintree_base.h @@ -14,6 +14,8 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace ellen_bintree { + using cds::intrusive::ellen_bintree::implementation_tag; + #ifdef CDS_DOXYGEN_INVOKED /// Typedef for \p cds::intrusive::ellen_bintree::update_desc diff --git a/cds/container/details/michael_map_base.h b/cds/container/details/michael_map_base.h index 2db63788..86ebcc1e 100644 --- a/cds/container/details/michael_map_base.h +++ b/cds/container/details/michael_map_base.h @@ -11,6 +11,8 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace michael_map { + using cds::intrusive::michael_set::implementation_tag; + /// \p MichaelHashMap traits typedef container::michael_set::traits traits; diff --git a/cds/container/details/michael_set_base.h b/cds/container/details/michael_set_base.h index bef183bd..2ab92012 100644 --- a/cds/container/details/michael_set_base.h +++ b/cds/container/details/michael_set_base.h @@ -11,6 +11,7 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace michael_set { + using cds::intrusive::michael_set::implementation_tag; /// MichaelHashSet traits typedef cds::intrusive::michael_set::traits traits; diff --git a/cds/container/details/skip_list_base.h b/cds/container/details/skip_list_base.h index d90aa426..609e96b7 100644 --- a/cds/container/details/skip_list_base.h +++ b/cds/container/details/skip_list_base.h @@ -12,6 +12,7 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace skip_list { + using cds::intrusive::skip_list::implementation_tag; /// Option specifying random level generator template diff --git a/cds/container/details/split_list_base.h b/cds/container/details/split_list_base.h index 38281da7..3e7d62f7 100644 --- a/cds/container/details/split_list_base.h +++ b/cds/container/details/split_list_base.h @@ -14,6 +14,8 @@ namespace cds { namespace container { /** @ingroup cds_nonintrusive_helper */ namespace split_list { + using cds::intrusive::split_list::implementation_tag; + /// Internal statistics, see \p cds::intrusive::split_list::stat template ::counter_type > using stat = cds::intrusive::split_list::stat; diff --git a/cds/container/ellen_bintree_map_rcu.h b/cds/container/ellen_bintree_map_rcu.h index d9c3e918..3d43f614 100644 --- a/cds/container/ellen_bintree_map_rcu.h +++ b/cds/container/ellen_bintree_map_rcu.h @@ -88,13 +88,16 @@ namespace cds { namespace container { typedef typename traits::copy_policy copy_policy; ///< key copy policy typedef typename traits::back_off back_off; ///< Back-off strategy - typedef typename traits::allocator allocator_type; ///< Allocator for leaf nodes typedef typename base_class::node_allocator node_allocator; ///< Internal node allocator typedef typename base_class::update_desc_allocator update_desc_allocator; ///< Update descriptor allocator static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; ///< Group of \p extract_xxx functions do not require external locking + //@cond + typedef cds::container::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::value_type leaf_node; diff --git a/cds/container/ellen_bintree_set_rcu.h b/cds/container/ellen_bintree_set_rcu.h index eaa41355..ecf292b2 100644 --- a/cds/container/ellen_bintree_set_rcu.h +++ b/cds/container/ellen_bintree_set_rcu.h @@ -133,6 +133,10 @@ namespace cds { namespace container { static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; ///< Group of \p extract_xxx functions do not require external locking + //@cond + typedef cds::container::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::cxx_leaf_node_allocator cxx_leaf_node_allocator; diff --git a/cds/container/impl/ellen_bintree_map.h b/cds/container/impl/ellen_bintree_map.h index 4dd23590..1c8a3a01 100644 --- a/cds/container/impl/ellen_bintree_map.h +++ b/cds/container/impl/ellen_bintree_map.h @@ -98,6 +98,10 @@ namespace cds { namespace container { typedef typename base_class::node_allocator node_allocator; ///< Internal node allocator typedef typename base_class::update_desc_allocator update_desc_allocator; ///< Update descriptor allocator + //@cond + typedef cds::container::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::value_type leaf_node; diff --git a/cds/container/impl/ellen_bintree_set.h b/cds/container/impl/ellen_bintree_set.h index 363f32b4..3eebc06d 100644 --- a/cds/container/impl/ellen_bintree_set.h +++ b/cds/container/impl/ellen_bintree_set.h @@ -135,6 +135,10 @@ namespace cds { namespace container { typedef typename base_class::node_allocator node_allocator; ///< Internal node allocator typedef typename base_class::update_desc_allocator update_desc_allocator; ///< Update descriptor allocator + //@cond + typedef cds::container::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::cxx_leaf_node_allocator cxx_leaf_node_allocator; diff --git a/cds/container/impl/skip_list_map.h b/cds/container/impl/skip_list_map.h index 6bae373b..29987199 100644 --- a/cds/container/impl/skip_list_map.h +++ b/cds/container/impl/skip_list_map.h @@ -134,6 +134,10 @@ namespace cds { namespace container { typedef typename traits::random_level_generator random_level_generator ; ///< random level generator typedef typename traits::stat stat; ///< internal statistics type + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::node_type node_type; diff --git a/cds/container/impl/skip_list_set.h b/cds/container/impl/skip_list_set.h index 66a100cf..0935780b 100644 --- a/cds/container/impl/skip_list_set.h +++ b/cds/container/impl/skip_list_set.h @@ -124,6 +124,10 @@ namespace cds { namespace container { typedef typename traits::random_level_generator random_level_generator; ///< random level generator typedef typename traits::stat stat; ///< internal statistics type + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::node_type node_type; diff --git a/cds/container/michael_map.h b/cds/container/michael_map.h index 899e0157..7e3c8e63 100644 --- a/cds/container/michael_map.h +++ b/cds/container/michael_map.h @@ -178,6 +178,10 @@ namespace cds { namespace container { typedef cds::details::Allocator< bucket_type, typename traits::allocator > bucket_table_allocator; typedef typename bucket_type::guarded_ptr guarded_ptr; ///< Guarded pointer + //@cond + typedef cds::container::michael_map::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/container/michael_map_nogc.h b/cds/container/michael_map_nogc.h index fedfc1cb..a85dd62d 100644 --- a/cds/container/michael_map_nogc.h +++ b/cds/container/michael_map_nogc.h @@ -46,6 +46,10 @@ namespace cds { namespace container { /// Bucket table allocator typedef cds::details::Allocator< bucket_type, typename traits::allocator > bucket_table_allocator; + //@cond + typedef cds::container::michael_map::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename bucket_type::iterator bucket_iterator; diff --git a/cds/container/michael_map_rcu.h b/cds/container/michael_map_rcu.h index c86aaad2..34e53c32 100644 --- a/cds/container/michael_map_rcu.h +++ b/cds/container/michael_map_rcu.h @@ -75,6 +75,10 @@ namespace cds { namespace container { /// Group of \p extract_xxx functions require external locking if underlying ordered list requires that static CDS_CONSTEXPR const bool c_bExtractLockExternal = bucket_type::c_bExtractLockExternal; + //@cond + typedef cds::container::michael_map::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h index 80c5a694..ce639de7 100644 --- a/cds/container/michael_set.h +++ b/cds/container/michael_set.h @@ -195,6 +195,10 @@ namespace cds { namespace container { typedef typename bucket_type::guarded_ptr guarded_ptr; ///< Guarded pointer + //@cond + typedef cds::container::michael_set::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/container/michael_set_nogc.h b/cds/container/michael_set_nogc.h index 28aa3cc1..b1cc9332 100644 --- a/cds/container/michael_set_nogc.h +++ b/cds/container/michael_set_nogc.h @@ -45,6 +45,10 @@ namespace cds { namespace container { /// Bucket table allocator typedef cds::details::Allocator< bucket_type, typename traits::allocator > bucket_table_allocator; + //@cond + typedef cds::container::michael_set::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename bucket_type::iterator bucket_iterator; diff --git a/cds/container/michael_set_rcu.h b/cds/container/michael_set_rcu.h index 86da400d..3bf12d8c 100644 --- a/cds/container/michael_set_rcu.h +++ b/cds/container/michael_set_rcu.h @@ -126,6 +126,10 @@ namespace cds { namespace container { /// Group of \p extract_xxx functions require external locking if underlying ordered list requires that static CDS_CONSTEXPR const bool c_bExtractLockExternal = bucket_type::c_bExtractLockExternal; + //@cond + typedef cds::container::michael_set::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/container/skip_list_map_nogc.h b/cds/container/skip_list_map_nogc.h index ffa37b53..57e1c5ad 100644 --- a/cds/container/skip_list_map_nogc.h +++ b/cds/container/skip_list_map_nogc.h @@ -77,6 +77,10 @@ namespace cds { namespace container { typedef typename base_class::stat stat; ///< internal statistics type typedef typename base_class::random_level_generator random_level_generator; ///< random level generator + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::node_type node_type; diff --git a/cds/container/skip_list_map_rcu.h b/cds/container/skip_list_map_rcu.h index 53bcf344..c5abe34a 100644 --- a/cds/container/skip_list_map_rcu.h +++ b/cds/container/skip_list_map_rcu.h @@ -124,6 +124,10 @@ namespace cds { namespace container { typedef typename traits::random_level_generator random_level_generator; ///< random level generator typedef typename traits::stat stat; ///< internal statistics type + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::node_type node_type; diff --git a/cds/container/skip_list_set_nogc.h b/cds/container/skip_list_set_nogc.h index a052ae1a..24f8171b 100644 --- a/cds/container/skip_list_set_nogc.h +++ b/cds/container/skip_list_set_nogc.h @@ -157,6 +157,10 @@ namespace cds { namespace container { typedef typename options::stat stat ; ///< internal statistics type typedef typename base_class::random_level_generator random_level_generator ; ///< random level generator + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::node_type node_type; diff --git a/cds/container/skip_list_set_rcu.h b/cds/container/skip_list_set_rcu.h index fb50c9d0..e57a8036 100644 --- a/cds/container/skip_list_set_rcu.h +++ b/cds/container/skip_list_set_rcu.h @@ -171,6 +171,10 @@ namespace cds { namespace container { typedef typename traits::stat stat ; ///< internal statistics type typedef typename traits::rcu_check_deadlock rcu_check_deadlock ; ///< Deadlock checking policy + //@cond + typedef cds::container::skip_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::node_type node_type; diff --git a/cds/container/split_list_map.h b/cds/container/split_list_map.h index 46f3a936..664cc7ae 100644 --- a/cds/container/split_list_map.h +++ b/cds/container/split_list_map.h @@ -137,6 +137,10 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counter type typedef typename base_class::stat stat; ///< Internal statistics + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::maker::traits::key_accessor key_accessor; diff --git a/cds/container/split_list_map_nogc.h b/cds/container/split_list_map_nogc.h index 60225731..dd5624aa 100644 --- a/cds/container/split_list_map_nogc.h +++ b/cds/container/split_list_map_nogc.h @@ -58,6 +58,10 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counter type typedef typename base_class::stat stat; ///< Internal statistics + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::traits::key_accessor key_accessor; diff --git a/cds/container/split_list_map_rcu.h b/cds/container/split_list_map_rcu.h index bb84fb2c..ed3c5899 100644 --- a/cds/container/split_list_map_rcu.h +++ b/cds/container/split_list_map_rcu.h @@ -179,6 +179,10 @@ namespace cds { namespace container { /// Group of \p extract_xxx functions require external locking if underlying ordered list requires that static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::maker::traits::key_accessor key_accessor; diff --git a/cds/container/split_list_set.h b/cds/container/split_list_set.h index 62028126..5c0ecaa7 100644 --- a/cds/container/split_list_set.h +++ b/cds/container/split_list_set.h @@ -152,6 +152,10 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counter type typedef typename base_class::stat stat; ///< Internal statistics + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::cxx_node_allocator cxx_node_allocator; diff --git a/cds/container/split_list_set_nogc.h b/cds/container/split_list_set_nogc.h index 6da18535..34c4b56a 100644 --- a/cds/container/split_list_set_nogc.h +++ b/cds/container/split_list_set_nogc.h @@ -58,6 +58,10 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counter type typedef typename base_class::stat stat; ///< Internal statistics + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::cxx_node_allocator cxx_node_allocator; diff --git a/cds/container/split_list_set_rcu.h b/cds/container/split_list_set_rcu.h index f70a8884..f6caeb73 100644 --- a/cds/container/split_list_set_rcu.h +++ b/cds/container/split_list_set_rcu.h @@ -5,6 +5,7 @@ #include #include +#include namespace cds { namespace container { @@ -192,6 +193,10 @@ namespace cds { namespace container { /// Group of \p extract_xxx functions require external locking if underlying ordered list requires that static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; + //@cond + typedef cds::container::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename maker::cxx_node_allocator cxx_node_allocator; diff --git a/cds/container/striped_map.h b/cds/container/striped_map.h index e66435af..17864e1b 100644 --- a/cds/container/striped_map.h +++ b/cds/container/striped_map.h @@ -491,6 +491,9 @@ template typedef typename base_class::allocator_type allocator_type ; ///< allocator type specified in options. typedef typename base_class::mutex_policy mutex_policy ; ///< Mutex policy + //@cond + typedef cds::container::striped_set::implementation_tag implementation_tag; + //@endcond protected: //@cond typedef typename base_class::scoped_cell_lock scoped_cell_lock; diff --git a/cds/container/striped_set.h b/cds/container/striped_set.h index c1828458..af53836a 100644 --- a/cds/container/striped_set.h +++ b/cds/container/striped_set.h @@ -482,6 +482,10 @@ namespace cds { namespace container { typedef typename base_class::allocator_type allocator_type ; ///< allocator type specified in options. typedef typename base_class::mutex_policy mutex_policy ; ///< Mutex policy + //@cond + typedef cds::container::striped_set::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef typename base_class::scoped_cell_lock scoped_cell_lock; diff --git a/cds/container/striped_set/adapter.h b/cds/container/striped_set/adapter.h index 52367e7d..f4f56b8d 100644 --- a/cds/container/striped_set/adapter.h +++ b/cds/container/striped_set/adapter.h @@ -9,6 +9,7 @@ namespace cds { namespace container { /// Striped hash set related definitions namespace striped_set { + using cds::intrusive::striped_set::implementation_tag; //@cond struct copy_item ; // copy_item_policy tag diff --git a/cds/intrusive/cuckoo_set.h b/cds/intrusive/cuckoo_set.h index 0fc53d7b..be873686 100644 --- a/cds/intrusive/cuckoo_set.h +++ b/cds/intrusive/cuckoo_set.h @@ -19,6 +19,9 @@ namespace cds { namespace intrusive { /// CuckooSet-related definitions namespace cuckoo { + //@cond + struct implementation_tag; + //@endcond /// Option to define probeset type /** @@ -1888,6 +1891,9 @@ namespace cds { namespace intrusive { /// node disposer typedef typename traits::disposer disposer; + //@cond + typedef cds::intrusive::cuckoo::implementation_tag implementation_tag; + //@endcond protected: //@cond typedef typename node_type::probeset_class probeset_class; diff --git a/cds/intrusive/details/ellen_bintree_base.h b/cds/intrusive/details/ellen_bintree_base.h index d80e5432..54e928b7 100644 --- a/cds/intrusive/details/ellen_bintree_base.h +++ b/cds/intrusive/details/ellen_bintree_base.h @@ -13,6 +13,7 @@ namespace cds { namespace intrusive { /// EllenBinTree related declarations namespace ellen_bintree { + struct implementation_tag; //Forwards template struct base_node; diff --git a/cds/intrusive/details/michael_set_base.h b/cds/intrusive/details/michael_set_base.h index aa2a3d45..4818a9ca 100644 --- a/cds/intrusive/details/michael_set_base.h +++ b/cds/intrusive/details/michael_set_base.h @@ -16,6 +16,10 @@ namespace cds { namespace intrusive { */ namespace michael_set { + //@cond + struct implementation_tag; + //@endcond + /// MichaelHashSet traits struct traits { /// Hash function @@ -190,7 +194,7 @@ namespace cds { namespace intrusive { }; } //@endcond - } + } // namespace michael_set //@cond // Forward declarations diff --git a/cds/intrusive/details/skip_list_base.h b/cds/intrusive/details/skip_list_base.h index ec4ec45d..be70fc1b 100644 --- a/cds/intrusive/details/skip_list_base.h +++ b/cds/intrusive/details/skip_list_base.h @@ -14,6 +14,9 @@ namespace cds { namespace intrusive { /** @ingroup cds_intrusive_helper */ namespace skip_list { + //@cond + struct implementation_tag; + //@endcond /// The maximum possible height of any skip-list static unsigned int const c_nHeightLimit = 32; diff --git a/cds/intrusive/details/split_list_base.h b/cds/intrusive/details/split_list_base.h index 2a57468e..cef83734 100644 --- a/cds/intrusive/details/split_list_base.h +++ b/cds/intrusive/details/split_list_base.h @@ -15,6 +15,10 @@ namespace cds { namespace intrusive { /** @ingroup cds_intrusive_helper */ namespace split_list { + //@cond + struct implementation_tag; + //@endcond + /// Split-ordered list node /** Template parameter: @@ -871,7 +875,7 @@ namespace cds { namespace intrusive { } //@endcond - } // namespace split_list + } // namespace split_list //@cond // Forward declaration diff --git a/cds/intrusive/ellen_bintree_rcu.h b/cds/intrusive/ellen_bintree_rcu.h index 45dc686f..0515bb99 100644 --- a/cds/intrusive/ellen_bintree_rcu.h +++ b/cds/intrusive/ellen_bintree_rcu.h @@ -438,6 +438,10 @@ namespace cds { namespace intrusive { typedef typename traits::disposer disposer; ///< leaf node disposer typedef typename traits::back_off back_off; ///< back-off strategy + //@cond + typedef cds::intrusive::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef ellen_bintree::base_node< gc > tree_node; ///< Base type of tree node diff --git a/cds/intrusive/impl/ellen_bintree.h b/cds/intrusive/impl/ellen_bintree.h index b250a7de..a6fcd1a2 100644 --- a/cds/intrusive/impl/ellen_bintree.h +++ b/cds/intrusive/impl/ellen_bintree.h @@ -120,6 +120,10 @@ namespace cds { namespace intrusive { typedef typename gc::template guarded_ptr< value_type > guarded_ptr; ///< Guarded pointer + //@cond + typedef cds::intrusive::ellen_bintree::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef ellen_bintree::base_node< gc > tree_node; ///< Base type of tree node diff --git a/cds/intrusive/impl/skip_list.h b/cds/intrusive/impl/skip_list.h index e57ff425..9abad6f5 100644 --- a/cds/intrusive/impl/skip_list.h +++ b/cds/intrusive/impl/skip_list.h @@ -345,6 +345,9 @@ namespace cds { namespace intrusive { typedef typename traits::back_off back_off; ///< Back-off strategy typedef typename traits::stat stat; ///< internal statistics type + //@cond + typedef cds::intrusive::skip_list::implementation_tag implementation_tag; + //@endcond public: typedef typename gc::template guarded_ptr< value_type > guarded_ptr; ///< Guarded pointer diff --git a/cds/intrusive/michael_set.h b/cds/intrusive/michael_set.h index 48e9c1b7..3f7944fc 100644 --- a/cds/intrusive/michael_set.h +++ b/cds/intrusive/michael_set.h @@ -236,6 +236,10 @@ namespace cds { namespace intrusive { /// Bucket table allocator typedef cds::details::Allocator< bucket_type, typename traits::allocator > bucket_table_allocator; + //@cond + typedef cds::intrusive::michael_set::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/intrusive/michael_set_nogc.h b/cds/intrusive/michael_set_nogc.h index d2cc7fa2..f64ec3f6 100644 --- a/cds/intrusive/michael_set_nogc.h +++ b/cds/intrusive/michael_set_nogc.h @@ -46,6 +46,10 @@ namespace cds { namespace intrusive { /// Bucket table allocator typedef cds::details::Allocator< bucket_type, typename traits::allocator > bucket_table_allocator; + //@cond + typedef cds::intrusive::michael_set::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/intrusive/michael_set_rcu.h b/cds/intrusive/michael_set_rcu.h index 7a200fde..75785021 100644 --- a/cds/intrusive/michael_set_rcu.h +++ b/cds/intrusive/michael_set_rcu.h @@ -94,6 +94,10 @@ namespace cds { namespace intrusive { /// Group of \p extract_xxx functions require external locking if underlying ordered list requires that static CDS_CONSTEXPR const bool c_bExtractLockExternal = bucket_type::c_bExtractLockExternal; + //@cond + typedef cds::intrusive::michael_set::implementation_tag implementation_tag; + //@endcond + protected: item_counter m_ItemCounter; ///< Item counter hash m_HashFunctor; ///< Hash functor diff --git a/cds/intrusive/skip_list_nogc.h b/cds/intrusive/skip_list_nogc.h index c72de416..6a8f4c3f 100644 --- a/cds/intrusive/skip_list_nogc.h +++ b/cds/intrusive/skip_list_nogc.h @@ -363,6 +363,7 @@ namespace cds { namespace intrusive { //@cond static unsigned int const c_nMinHeight = 3; + typedef cds::intrusive::skip_list::implementation_tag implementation_tag; //@endcond protected: diff --git a/cds/intrusive/skip_list_rcu.h b/cds/intrusive/skip_list_rcu.h index 6153b559..9655545a 100644 --- a/cds/intrusive/skip_list_rcu.h +++ b/cds/intrusive/skip_list_rcu.h @@ -532,6 +532,7 @@ namespace cds { namespace intrusive { //@cond static unsigned int const c_nMinHeight = 5; + typedef cds::intrusive::skip_list::implementation_tag implementation_tag; //@endcond protected: diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h index 782b59b8..933c9943 100644 --- a/cds/intrusive/split_list.h +++ b/cds/intrusive/split_list.h @@ -195,6 +195,10 @@ namespace cds { namespace intrusive { typedef GC gc; ///< Garbage collector typedef Traits traits; ///< Set traits + //@cond + typedef cds::intrusive::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef split_list::details::rebind_list_traits wrapped_ordered_list; diff --git a/cds/intrusive/split_list_nogc.h b/cds/intrusive/split_list_nogc.h index 195f63dc..04994be5 100644 --- a/cds/intrusive/split_list_nogc.h +++ b/cds/intrusive/split_list_nogc.h @@ -37,6 +37,10 @@ namespace cds { namespace intrusive { /// Hash functor for \p value_type and all its derivatives that you use typedef typename cds::opt::v::hash_selector< typename traits::hash >::type hash; + //@cond + typedef cds::intrusive::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef split_list::details::rebind_list_traits wrapped_ordered_list; diff --git a/cds/intrusive/split_list_rcu.h b/cds/intrusive/split_list_rcu.h index 6ca39c32..70f9ff3f 100644 --- a/cds/intrusive/split_list_rcu.h +++ b/cds/intrusive/split_list_rcu.h @@ -68,6 +68,10 @@ namespace cds { namespace intrusive { /// Hash functor for \ref value_type and all its derivatives that you use typedef typename cds::opt::v::hash_selector< typename traits::hash >::type hash; + //@cond + typedef cds::intrusive::split_list::implementation_tag implementation_tag; + //@endcond + protected: //@cond typedef split_list::details::rebind_list_traits wrapped_ordered_list; diff --git a/cds/intrusive/striped_set.h b/cds/intrusive/striped_set.h index eba6dbf0..62c0799d 100644 --- a/cds/intrusive/striped_set.h +++ b/cds/intrusive/striped_set.h @@ -296,6 +296,10 @@ namespace cds { namespace intrusive { typedef cds::details::Allocator< bucket_type, allocator_type > bucket_allocator; ///< bucket allocator type based on allocator_type + //@cond + typedef cds::intrusive::striped_set::implementation_tag implementation_tag; + //@endcond + protected: bucket_type * m_Buckets ; ///< Bucket table size_t m_nBucketMask ; ///< Bucket table size - 1. m_nBucketMask + 1 should be power of two. diff --git a/cds/intrusive/striped_set/adapter.h b/cds/intrusive/striped_set/adapter.h index 6c043672..a34ab4f4 100644 --- a/cds/intrusive/striped_set/adapter.h +++ b/cds/intrusive/striped_set/adapter.h @@ -12,6 +12,9 @@ namespace cds { namespace intrusive { /// StripedSet related definitions namespace striped_set { + //@cond + struct implementation_tag; + //@endcond /// Default adapter for intrusive striped/refinable hash set /** diff --git a/projects/Win/vc12/cds.sln b/projects/Win/vc12/cds.sln index d731825b..a6a447da 100644 --- a/projects/Win/vc12/cds.sln +++ b/projects/Win/vc12/cds.sln @@ -14,6 +14,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "unit-test", "unit-test", "{ ..\..\..\tests\unit\print_skip_list_stat.h = ..\..\..\tests\unit\print_skip_list_stat.h ..\..\..\tests\unit\print_split_list_stat.h = ..\..\..\tests\unit\print_split_list_stat.h ..\..\..\tests\unit\print_sync_monitor_stat.h = ..\..\..\tests\unit\print_sync_monitor_stat.h + ..\..\..\tests\unit\set2\set_type_cuckoo.h = ..\..\..\tests\unit\set2\set_type_cuckoo.h EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unit-prerequisites", "unit-prerequisites.vcxproj", "{61179F2F-07E1-490D-B64D-D85A90B6EF81}" @@ -79,9 +80,16 @@ EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "set", "set", "{A64449B7-90FB-4E2B-A686-9EFC0E298644}" ProjectSection(SolutionItems) = preProject ..\..\..\tests\unit\set2\set_defs.h = ..\..\..\tests\unit\set2\set_defs.h - ..\..\..\tests\unit\set2\set_types.h = ..\..\..\tests\unit\set2\set_types.h - ..\..\..\tests\unit\set2\std_hash_set.h = ..\..\..\tests\unit\set2\std_hash_set.h - ..\..\..\tests\unit\set2\std_set.h = ..\..\..\tests\unit\set2\std_set.h + ..\..\..\tests\unit\set2\set_type.h = ..\..\..\tests\unit\set2\set_type.h + ..\..\..\tests\unit\set2\set_type_cuckoo.h = ..\..\..\tests\unit\set2\set_type_cuckoo.h + ..\..\..\tests\unit\set2\set_type_ellen_bintree.h = ..\..\..\tests\unit\set2\set_type_ellen_bintree.h + ..\..\..\tests\unit\set2\set_type_lazy_list.h = ..\..\..\tests\unit\set2\set_type_lazy_list.h + ..\..\..\tests\unit\set2\set_type_michael.h = ..\..\..\tests\unit\set2\set_type_michael.h + ..\..\..\tests\unit\set2\set_type_michael_list.h = ..\..\..\tests\unit\set2\set_type_michael_list.h + ..\..\..\tests\unit\set2\set_type_skip_list.h = ..\..\..\tests\unit\set2\set_type_skip_list.h + ..\..\..\tests\unit\set2\set_type_split_list.h = ..\..\..\tests\unit\set2\set_type_split_list.h + ..\..\..\tests\unit\set2\set_type_std.h = ..\..\..\tests\unit\set2\set_type_std.h + ..\..\..\tests\unit\set2\set_type_striped.h = ..\..\..\tests\unit\set2\set_type_striped.h EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unit-map-delodd", "unit-map-delodd.vcxproj", "{3C598F96-FB84-4D42-9B43-F697F53B0221}" diff --git a/tests/cppunit/cppunit_mini.h b/tests/cppunit/cppunit_mini.h index 714b0883..e0a8507b 100644 --- a/tests/cppunit/cppunit_mini.h +++ b/tests/cppunit/cppunit_mini.h @@ -277,6 +277,8 @@ namespace CppUnitMini #define CPPUNIT_TEST(X) CPPUNIT_TEST_BASE(X, false) #define CPPUNIT_EXPLICIT_TEST(X) CPPUNIT_TEST_BASE(X, true) +#define CDSUNIT_DECLARE_TEST(X) void X(); + #define CPPUNIT_IGNORE \ ignoring = true diff --git a/tests/unit/set2/set_defs.h b/tests/unit/set2/set_defs.h index e57384ef..030eaa9e 100644 --- a/tests/unit/set2/set_defs.h +++ b/tests/unit/set2/set_defs.h @@ -4,22 +4,37 @@ #define CDSUNIT_SET_DEFS_H #define CDSUNIT_DECLARE_StdSet \ - TEST_SET(StdSet_Spin) \ - TEST_SET(StdHashSet_Spin) + CDSUNIT_DECLARE_TEST(StdSet_Spin) \ + CDSUNIT_DECLARE_TEST(StdHashSet_Spin) + +#define CDSUNIT_DEFINE_StdSet(IMPL, C) \ + TEST_SET(IMPL, C, StdSet_Spin) \ + TEST_SET(IMPL, C, StdHashSet_Spin) + #define CDSUNIT_TEST_StdSet \ CPPUNIT_TEST(StdSet_Spin) \ CPPUNIT_TEST(StdHashSet_Spin) #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_MichaelSet_RCU_signal \ - TEST_SET_EXTRACT(MichaelSet_RCU_SHB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_SHB_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_SHT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_SHT_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_SHT_less_michaelAlloc) + 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) # define CDSUNIT_TEST_MichaelSet_RCU_signal \ CPPUNIT_TEST(MichaelSet_RCU_SHB_cmp_stdAlloc) \ @@ -32,33 +47,57 @@ 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 \ - TEST_SET_EXTRACT(MichaelSet_HP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_HP_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_DHP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_DHP_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPI_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPI_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPB_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_RCU_GPT_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_HP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_HP_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_DHP_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_DHP_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \ - TEST_SET_EXTRACT(MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \ + 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) \ 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) \ @@ -85,30 +124,56 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_SplitList_RCU_signal \ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHB_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_SHT_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHB_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_SHT_st_less_stat) + 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) # define CDSUNIT_TEST_SplitList_RCU_signal \ CPPUNIT_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\ @@ -138,72 +203,136 @@ #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 \ - TEST_SET_EXTRACT(SplitList_Michael_HP_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_HP_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_HP_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_HP_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_HP_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_HP_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_DHP_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPI_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPB_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_st_less)\ - TEST_SET_EXTRACT(SplitList_Michael_RCU_GPT_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_HP_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_DHP_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPI_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPB_st_less_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_dyn_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_st_cmp)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_dyn_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_st_less)\ - TEST_SET_EXTRACT(SplitList_Lazy_RCU_GPT_st_less_stat)\ + 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)\ 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)\ @@ -269,30 +398,56 @@ #define CDSUNIT_DECLARE_CuckooSet \ - TEST_SET(CuckooStripedSet_list_unord)\ - TEST_SET(CuckooStripedSet_list_unord_stat)\ - TEST_SET(CuckooStripedSet_list_ord)\ - TEST_SET(CuckooStripedSet_list_ord_stat)\ - TEST_SET(CuckooStripedSet_vector_unord)\ - TEST_SET(CuckooStripedSet_vector_ord)\ - TEST_SET(CuckooStripedSet_vector_unord_stat)\ - TEST_SET(CuckooStripedSet_vector_ord_stat)\ - TEST_SET(CuckooRefinableSet_list_unord)\ - TEST_SET(CuckooRefinableSet_list_ord)\ - TEST_SET(CuckooRefinableSet_list_unord_stat)\ - TEST_SET(CuckooRefinableSet_list_ord_stat)\ - TEST_SET(CuckooRefinableSet_vector_unord)\ - TEST_SET(CuckooRefinableSet_vector_unord_stat)\ - TEST_SET(CuckooRefinableSet_vector_ord) \ - TEST_SET(CuckooRefinableSet_vector_ord_stat) \ - TEST_SET(CuckooStripedSet_list_unord_storehash)\ - TEST_SET(CuckooStripedSet_list_ord_storehash)\ - TEST_SET(CuckooStripedSet_vector_unord_storehash)\ - TEST_SET(CuckooStripedSet_vector_ord_storehash)\ - TEST_SET(CuckooRefinableSet_list_unord_storehash)\ - TEST_SET(CuckooRefinableSet_list_ord_storehash)\ - TEST_SET(CuckooRefinableSet_vector_unord_storehash)\ - TEST_SET(CuckooRefinableSet_vector_ord_storehash) + 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) #define CDSUNIT_TEST_CuckooSet \ @@ -325,14 +480,24 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_SkipListSet_RCU_signal \ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_shb_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_shb_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_shb_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_shb_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_sht_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_sht_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_sht_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_sht_cmp_xorshift_stat) + 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) # define CDSUNIT_TEST_SkipListSet_RCU_signal \ CPPUNIT_TEST(SkipListSet_rcu_shb_less_pascal)\ @@ -346,32 +511,56 @@ #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 \ - TEST_SET_NOLF_EXTRACT(SkipListSet_hp_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_hp_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_hp_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_hp_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_dhp_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_dhp_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_dhp_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_dhp_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpi_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpi_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpi_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpi_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpb_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpb_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpb_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpb_cmp_xorshift_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpt_less_pascal)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpt_cmp_pascal_stat)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpt_less_xorshift)\ - TEST_SET_NOLF_EXTRACT(SkipListSet_rcu_gpt_cmp_xorshift_stat)\ + 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)\ 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)\ @@ -398,10 +587,16 @@ #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED # define CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal \ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_shb)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_shb_stat)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_sht)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_sht_stat) + 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) # define CDSUNIT_TEST_EllenBinTreeSet_RCU_signal \ CPPUNIT_TEST(EllenBinTreeSet_rcu_shb)\ @@ -410,25 +605,42 @@ 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 \ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_hp)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_yield_hp)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_hp_stat)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_dhp)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_yield_dhp)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_dhp_stat)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpi)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpi_stat)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpb)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_yield_rcu_gpb)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpb_stat)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpt)\ - TEST_SET_NOLF_EXTRACT(EllenBinTreeSet_rcu_gpt_stat)\ + 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)\ 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)\ @@ -448,11 +660,19 @@ #define CDSUNIT_DECLARE_StripedSet_common \ - TEST_SET(StripedSet_list) \ - TEST_SET(StripedSet_vector) \ - TEST_SET(StripedSet_set) \ - TEST_SET(StripedSet_hashset) \ - TEST_SET(StripedSet_boost_unordered_set) + CDSUNIT_DECLARE_TEST(StripedSet_list) \ + CDSUNIT_DECLARE_TEST(StripedSet_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_set) \ + CDSUNIT_DECLARE_TEST(StripedSet_hashset) \ + CDSUNIT_DECLARE_TEST(StripedSet_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) + #define CDSUNIT_TEST_StripedSet_common \ CPPUNIT_TEST(StripedSet_list) \ CPPUNIT_TEST(StripedSet_vector) \ @@ -462,11 +682,19 @@ #if BOOST_VERSION >= 104800 # define CDSUNIT_DECLARE_StripedSet_boost_container \ - TEST_SET(StripedSet_boost_list) \ - TEST_SET(StripedSet_boost_slist) \ - TEST_SET(StripedSet_boost_vector) \ - TEST_SET(StripedSet_boost_stable_vector) \ - TEST_SET(StripedSet_boost_set) + CDSUNIT_DECLARE_TEST(StripedSet_boost_list) \ + CDSUNIT_DECLARE_TEST(StripedSet_boost_slist) \ + CDSUNIT_DECLARE_TEST(StripedSet_boost_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_boost_stable_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_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) + # define CDSUNIT_TEST_StripedSet_boost_container \ CPPUNIT_TEST(StripedSet_boost_list) \ CPPUNIT_TEST(StripedSet_boost_slist) \ @@ -475,16 +703,20 @@ CPPUNIT_TEST(StripedSet_boost_set) #else # define CDSUNIT_DECLARE_StripedSet_boost_container +# define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) # define CDSUNIT_TEST_StripedSet_boost_container #endif #if BOOST_VERSION >= 104800 && defined(CDS_UNIT_SET_TYPES_ENABLE_BOOST_FLAT_CONTAINERS) # define CDSUNIT_DECLARE_StripedSet_boost_flat_container \ - TEST_SET(StripedSet_boost_flat_set) + CDSUNIT_DECLARE_TEST(StripedSet_boost_flat_set) +# define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) \ + TEST_SET(IMPL, C, StripedSet_boost_flat_set) # define CDSUNIT_TEST_StripedSet_boost_flat_container \ CPPUNIT_TEST(StripedSet_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 @@ -492,6 +724,10 @@ 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 \ @@ -499,11 +735,17 @@ #define CDSUNIT_DECLARE_RefinableSet_common \ - TEST_SET(RefinableSet_list) \ - TEST_SET(RefinableSet_vector) \ - TEST_SET(RefinableSet_set) \ - TEST_SET(RefinableSet_hashset) \ - TEST_SET(RefinableSet_boost_unordered_set) + CDSUNIT_DECLARE_TEST(RefinableSet_list) \ + CDSUNIT_DECLARE_TEST(RefinableSet_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_set) \ + CDSUNIT_DECLARE_TEST(RefinableSet_hashset) \ + CDSUNIT_DECLARE_TEST(RefinableSet_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) #define CDSUNIT_TEST_RefinableSet_common \ CPPUNIT_TEST(RefinableSet_list) \ CPPUNIT_TEST(RefinableSet_vector) \ @@ -513,11 +755,17 @@ #if BOOST_VERSION >= 104800 # define CDSUNIT_DECLARE_RefinableSet_boost_container \ - TEST_SET(RefinableSet_boost_list) \ - TEST_SET(RefinableSet_boost_slist) \ - TEST_SET(RefinableSet_boost_vector) \ - TEST_SET(RefinableSet_boost_stable_vector) \ - TEST_SET(RefinableSet_boost_set) + CDSUNIT_DECLARE_TEST(RefinableSet_boost_list) \ + CDSUNIT_DECLARE_TEST(RefinableSet_boost_slist) \ + CDSUNIT_DECLARE_TEST(RefinableSet_boost_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_boost_stable_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_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) # define CDSUNIT_TEST_RefinableSet_boost_container \ CPPUNIT_TEST(RefinableSet_boost_list) \ CPPUNIT_TEST(RefinableSet_boost_slist) \ @@ -526,16 +774,20 @@ CPPUNIT_TEST(RefinableSet_boost_set) #else # define CDSUNIT_DECLARE_RefinableSet_boost_container +# define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ # define CDSUNIT_TEST_RefinableSet_boost_container #endif #if BOOST_VERSION >= 104800 && defined(CDS_UNIT_SET_TYPES_ENABLE_BOOST_FLAT_CONTAINERS) # define CDSUNIT_DECLARE_RefinableSet_boost_flat_container \ - TEST_SET(RefinableSet_boost_flat_set) + CDSUNIT_DECLARE_TEST(RefinableSet_boost_flat_set) +# define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) \ + TEST_SET(IMPL, C, RefinableSet_boost_flat_set) # define CDSUNIT_TEST_RefinableSet_boost_flat_container \ CPPUNIT_TEST(RefinableSet_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 @@ -543,6 +795,10 @@ 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.h b/tests/unit/set2/set_delodd.h index f06102c9..b6291a14 100644 --- a/tests/unit/set2/set_delodd.h +++ b/tests/unit/set2/set_delodd.h @@ -1,15 +1,15 @@ //$$CDS-header$$ #include "cppunit/thread.h" -#include "set2/set_types.h" +#include "set2/set_type.h" #include // random_shuffle namespace set2 { -# define TEST_SET(X) void X() { test::X >() ; } -# define TEST_SET_EXTRACT(X) void X() { test_extract::X >() ; } -# define TEST_SET_NOLF(X) void X() { test_nolf::X >() ; } -# define TEST_SET_NOLF_EXTRACT(X) void X() { test_nolf_extract::X >() ; } +# 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 >(); } namespace { struct key_thread @@ -26,7 +26,7 @@ namespace set2 { {} }; - typedef SetTypes::key_val key_value_pair; + typedef set_type_base::key_val key_value_pair; } template <> diff --git a/tests/unit/set2/set_delodd_cuckoo.cpp b/tests/unit/set2/set_delodd_cuckoo.cpp index 80ca8d5c..2e543c20 100644 --- a/tests/unit/set2/set_delodd_cuckoo.cpp +++ b/tests/unit/set2/set_delodd_cuckoo.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #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() diff --git a/tests/unit/set2/set_delodd_ellentree.cpp b/tests/unit/set2/set_delodd_ellentree.cpp index 6bd29b49..e4f85627 100644 --- a/tests/unit/set2/set_delodd_ellentree.cpp +++ b/tests/unit/set2/set_delodd_ellentree.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #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() diff --git a/tests/unit/set2/set_delodd_michael.cpp b/tests/unit/set2/set_delodd_michael.cpp index a9884721..ac7c470c 100644 --- a/tests/unit/set2/set_delodd_michael.cpp +++ b/tests/unit/set2/set_delodd_michael.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #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() diff --git a/tests/unit/set2/set_delodd_skip.cpp b/tests/unit/set2/set_delodd_skip.cpp index 2a072999..58a00472 100644 --- a/tests/unit/set2/set_delodd_skip.cpp +++ b/tests/unit/set2/set_delodd_skip.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #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() diff --git a/tests/unit/set2/set_delodd_split.cpp b/tests/unit/set2/set_delodd_split.cpp index 85e8ba08..993fdcdf 100644 --- a/tests/unit/set2/set_delodd_split.cpp +++ b/tests/unit/set2/set_delodd_split.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #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() diff --git a/tests/unit/set2/set_insdel_func.cpp b/tests/unit/set2/set_insdel_func.cpp index cb72e34c..4ec5714c 100644 --- a/tests/unit/set2/set_insdel_func.cpp +++ b/tests/unit/set2/set_insdel_func.cpp @@ -1,6 +1,7 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_michael.h" namespace set2 { @@ -14,6 +15,7 @@ namespace set2 { size_t Set_InsDel_func::c_nMaxLoadFactor = 8 ; // maximum load factor bool Set_InsDel_func::c_bPrintGCState = true; + CDSUNIT_DEFINE_MichaelSet( cc::michael_set::implementation_tag, Set_InsDel_func ) CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_MichaelSet ) CDSUNIT_TEST_MichaelSet diff --git a/tests/unit/set2/set_insdel_func.h b/tests/unit/set2/set_insdel_func.h index 4d38066a..88b2ff82 100644 --- a/tests/unit/set2/set_insdel_func.h +++ b/tests/unit/set2/set_insdel_func.h @@ -4,17 +4,16 @@ #include #include //unique_lock -#include "set2/set_types.h" +#include "set2/set_type.h" #include "cppunit/thread.h" - #include namespace set2 { -# define TEST_SET(X) void X() { test::X >() ; } -# define TEST_SET_EXTRACT(X) TEST_SET(X) -# define TEST_SET_NOLF(X) void X() { test_nolf::X >() ; } -# define TEST_SET_NOLF_EXTRACT(X) TEST_SET_NOLF(X) +# define TEST_SET(IMPL, C, X) void C::X() { test::X >(); } +# define TEST_SET_EXTRACT(IMPL, C, X) TEST_SET(IMPL, C, X) +# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf::X >(); } +# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) TEST_SET_NOLF(IMPL, C, X) class Set_InsDel_func: public CppUnitMini::TestCase { diff --git a/tests/unit/set2/set_insdel_func_cuckoo.cpp b/tests/unit/set2/set_insdel_func_cuckoo.cpp index 5db70204..ce87451b 100644 --- a/tests/unit/set2/set_insdel_func_cuckoo.cpp +++ b/tests/unit/set2/set_insdel_func_cuckoo.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_cuckoo.h" namespace set2 { + CDSUNIT_DEFINE_CuckooSet( cc::cuckoo::implementation_tag, Set_InsDel_func ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_CuckooSet ) CDSUNIT_TEST_CuckooSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_func_ellentree.cpp b/tests/unit/set2/set_insdel_func_ellentree.cpp index d7118570..58028ca6 100644 --- a/tests/unit/set2/set_insdel_func_ellentree.cpp +++ b/tests/unit/set2/set_insdel_func_ellentree.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_ellen_bintree.h" namespace set2 { + CDSUNIT_DEFINE_EllenBinTreeSet( cc::ellen_bintree::implementation_tag, Set_InsDel_func ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_EllenBinTreeSet ) CDSUNIT_TEST_EllenBinTreeSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_func_refinable.cpp b/tests/unit/set2/set_insdel_func_refinable.cpp index ac6ef504..c990bfd8 100644 --- a/tests/unit/set2/set_insdel_func_refinable.cpp +++ b/tests/unit/set2/set_insdel_func_refinable.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_RefinableSet( cc::striped_set::implementation_tag, Set_InsDel_func ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_RefinableSet ) CDSUNIT_TEST_RefinableSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_func_skip.cpp b/tests/unit/set2/set_insdel_func_skip.cpp index 3a2765a4..cc77d2a7 100644 --- a/tests/unit/set2/set_insdel_func_skip.cpp +++ b/tests/unit/set2/set_insdel_func_skip.cpp @@ -1,10 +1,12 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_skip_list.h" namespace set2 { + CDSUNIT_DEFINE_SkipListSet(cc::skip_list::implementation_tag, Set_InsDel_func) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_SkipListSet ) CDSUNIT_TEST_SkipListSet CPPUNIT_TEST_SUITE_END_PART() - } // namespace set2 diff --git a/tests/unit/set2/set_insdel_func_split.cpp b/tests/unit/set2/set_insdel_func_split.cpp index fc77c6e2..c80a878a 100644 --- a/tests/unit/set2/set_insdel_func_split.cpp +++ b/tests/unit/set2/set_insdel_func_split.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_split_list.h" namespace set2 { + CDSUNIT_DEFINE_SplitList(cc::split_list::implementation_tag, Set_InsDel_func) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_SplitList ) CDSUNIT_TEST_SplitList CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_func_striped.cpp b/tests/unit/set2/set_insdel_func_striped.cpp index f1951abe..492492f2 100644 --- a/tests/unit/set2/set_insdel_func_striped.cpp +++ b/tests/unit/set2/set_insdel_func_striped.cpp @@ -1,8 +1,10 @@ //$$CDS-header$$ #include "set2/set_insdel_func.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_StripedSet( cc::striped_set::implementation_tag, Set_InsDel_func ) CPPUNIT_TEST_SUITE_PART( Set_InsDel_func, run_StripedSet ) CDSUNIT_TEST_StripedSet diff --git a/tests/unit/set2/set_insdel_string.h b/tests/unit/set2/set_insdel_string.h index 359368fa..fb3a01a0 100644 --- a/tests/unit/set2/set_insdel_string.h +++ b/tests/unit/set2/set_insdel_string.h @@ -1,16 +1,16 @@ //$$CDS-header$$ -#include "set2/set_types.h" +#include "set2/set_type.h" #include "cppunit/thread.h" #include namespace set2 { -# define TEST_SET(X) void X() { test::X >(); } -# define TEST_SET_EXTRACT(X) void X() { test_extract::X >(); } -# define TEST_SET_NOLF(X) void X() { test_nolf::X >(); } -# define TEST_SET_NOLF_EXTRACT(X) void X() { test_nolf_extract::X >(); } +# 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 >(); } class Set_InsDel_string: public CppUnitMini::TestCase { diff --git a/tests/unit/set2/set_insdel_string_cuckoo.cpp b/tests/unit/set2/set_insdel_string_cuckoo.cpp index 0f5e506d..ee7219c2 100644 --- a/tests/unit/set2/set_insdel_string_cuckoo.cpp +++ b/tests/unit/set2/set_insdel_string_cuckoo.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_cuckoo.h" namespace set2 { + CDSUNIT_DEFINE_CuckooSet( cc::cuckoo::implementation_tag, Set_InsDel_string ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_CuckooSet ) CDSUNIT_TEST_CuckooSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_ellentree.cpp b/tests/unit/set2/set_insdel_string_ellentree.cpp index cb6bec8b..e05d42b2 100644 --- a/tests/unit/set2/set_insdel_string_ellentree.cpp +++ b/tests/unit/set2/set_insdel_string_ellentree.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_ellen_bintree.h" namespace set2 { + CDSUNIT_DEFINE_EllenBinTreeSet( cc::ellen_bintree::implementation_tag, Set_InsDel_string ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_EllenBinTreeSet ) CDSUNIT_TEST_EllenBinTreeSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_michael.cpp b/tests/unit/set2/set_insdel_string_michael.cpp index b7be88fc..7c45b807 100644 --- a/tests/unit/set2/set_insdel_string_michael.cpp +++ b/tests/unit/set2/set_insdel_string_michael.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_michael.h" namespace set2 { + CDSUNIT_DEFINE_MichaelSet( cc::michael_set::implementation_tag, Set_InsDel_string ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_MichaelSet ) CDSUNIT_TEST_MichaelSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_refinable.cpp b/tests/unit/set2/set_insdel_string_refinable.cpp index fb14006e..33c2a0d0 100644 --- a/tests/unit/set2/set_insdel_string_refinable.cpp +++ b/tests/unit/set2/set_insdel_string_refinable.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_RefinableSet( cc::striped_set::implementation_tag, Set_InsDel_string ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_RefinableSet ) CDSUNIT_TEST_RefinableSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_skip.cpp b/tests/unit/set2/set_insdel_string_skip.cpp index 4c98a6ad..562cba26 100644 --- a/tests/unit/set2/set_insdel_string_skip.cpp +++ b/tests/unit/set2/set_insdel_string_skip.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_skip_list.h" namespace set2 { + CDSUNIT_DEFINE_SkipListSet(cc::skip_list::implementation_tag, Set_InsDel_string) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_SkipListSet ) CDSUNIT_TEST_SkipListSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_split.cpp b/tests/unit/set2/set_insdel_string_split.cpp index 821d0bdb..d851e9b2 100644 --- a/tests/unit/set2/set_insdel_string_split.cpp +++ b/tests/unit/set2/set_insdel_string_split.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_split_list.h" namespace set2 { + CDSUNIT_DEFINE_SplitList(cc::split_list::implementation_tag, Set_InsDel_string) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_SplitList ) CDSUNIT_TEST_SplitList CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_std.cpp b/tests/unit/set2/set_insdel_string_std.cpp index 8a8f3cce..b383122c 100644 --- a/tests/unit/set2/set_insdel_string_std.cpp +++ b/tests/unit/set2/set_insdel_string_std.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_std.h" namespace set2 { + CDSUNIT_DEFINE_StdSet(std_implementation_tag, Set_InsDel_string) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_StdSet ) CDSUNIT_TEST_StdSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdel_string_striped.cpp b/tests/unit/set2/set_insdel_string_striped.cpp index c823c560..e478bdf3 100644 --- a/tests/unit/set2/set_insdel_string_striped.cpp +++ b/tests/unit/set2/set_insdel_string_striped.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdel_string.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_StripedSet( cc::striped_set::implementation_tag, Set_InsDel_string ) + CPPUNIT_TEST_SUITE_PART( Set_InsDel_string, run_StripedSet ) CDSUNIT_TEST_StripedSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind.cpp b/tests/unit/set2/set_insdelfind.cpp index 82c61d74..be326ac3 100644 --- a/tests/unit/set2/set_insdelfind.cpp +++ b/tests/unit/set2/set_insdelfind.cpp @@ -55,17 +55,4 @@ namespace set2 { endTestCase(); } - - /* - CPPUNIT_TEST_SUITE_( Set_InsDelFind, "Map_InsDelFind" ) - CDSUNIT_TEST_MichaelSet - CDSUNIT_TEST_SplitList - CDSUNIT_TEST_SkipListSet - CDSUNIT_TEST_EllenBinTreeSet - CDSUNIT_TEST_StripedSet - CDSUNIT_TEST_RefinableSet - CDSUNIT_TEST_CuckooSet - CDSUNIT_TEST_StdSet - CPPUNIT_TEST_SUITE_END() - */ } // namespace set2 diff --git a/tests/unit/set2/set_insdelfind.h b/tests/unit/set2/set_insdelfind.h index 2a128cbd..fbf82887 100644 --- a/tests/unit/set2/set_insdelfind.h +++ b/tests/unit/set2/set_insdelfind.h @@ -1,15 +1,15 @@ //$$CDS-header$$ -#include "set2/set_types.h" +#include "set2/set_type.h" #include "cppunit/thread.h" #include // random_shuffle namespace set2 { -# define TEST_SET(X) void X() { test::X >() ; } -# define TEST_SET_EXTRACT(X) TEST_SET(X) -# define TEST_SET_NOLF(X) void X() { test_nolf::X >() ; } -# define TEST_SET_NOLF_EXTRACT(X) TEST_SET_NOLF(X) +# define TEST_SET(IMPL, C, X) void C::X() { test::X >() ; } +# define TEST_SET_EXTRACT(IMPL, C, X) TEST_SET(IMPL, C, X) +# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf::X >() ; } +# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) TEST_SET_NOLF(IMPL, C, X) class Set_InsDelFind: public CppUnitMini::TestCase { diff --git a/tests/unit/set2/set_insdelfind_cuckoo.cpp b/tests/unit/set2/set_insdelfind_cuckoo.cpp index f5986abd..fee46ea3 100644 --- a/tests/unit/set2/set_insdelfind_cuckoo.cpp +++ b/tests/unit/set2/set_insdelfind_cuckoo.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_cuckoo.h" namespace set2 { + CDSUNIT_DEFINE_CuckooSet( cc::cuckoo::implementation_tag, Set_InsDelFind ) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_CuckooSet ) CDSUNIT_TEST_CuckooSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_ellentree.cpp b/tests/unit/set2/set_insdelfind_ellentree.cpp index db2a7e37..55012370 100644 --- a/tests/unit/set2/set_insdelfind_ellentree.cpp +++ b/tests/unit/set2/set_insdelfind_ellentree.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_ellen_bintree.h" namespace set2 { + CDSUNIT_DEFINE_EllenBinTreeSet( cc::ellen_bintree::implementation_tag, Set_InsDelFind ) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_EllenBinTreeSet ) CDSUNIT_TEST_EllenBinTreeSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_michael.cpp b/tests/unit/set2/set_insdelfind_michael.cpp index 631111ff..dc4ca564 100644 --- a/tests/unit/set2/set_insdelfind_michael.cpp +++ b/tests/unit/set2/set_insdelfind_michael.cpp @@ -1,8 +1,12 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_michael.h" + namespace set2 { + CDSUNIT_DEFINE_MichaelSet( cc::michael_set::implementation_tag, Set_InsDelFind ) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_MichaelSet ) CDSUNIT_TEST_MichaelSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_refinable.cpp b/tests/unit/set2/set_insdelfind_refinable.cpp index 942113e5..ac969d47 100644 --- a/tests/unit/set2/set_insdelfind_refinable.cpp +++ b/tests/unit/set2/set_insdelfind_refinable.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_RefinableSet( cc::striped_set::implementation_tag, Set_InsDelFind ) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_RefinableSet ) CDSUNIT_TEST_RefinableSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_skip.cpp b/tests/unit/set2/set_insdelfind_skip.cpp index 8e498651..102c51d3 100644 --- a/tests/unit/set2/set_insdelfind_skip.cpp +++ b/tests/unit/set2/set_insdelfind_skip.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_skip_list.h" namespace set2 { + CDSUNIT_DEFINE_SkipListSet(cc::skip_list::implementation_tag, Set_InsDelFind) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_SkipListSet ) CDSUNIT_TEST_SkipListSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_split.cpp b/tests/unit/set2/set_insdelfind_split.cpp index c16b8523..4c393df3 100644 --- a/tests/unit/set2/set_insdelfind_split.cpp +++ b/tests/unit/set2/set_insdelfind_split.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_split_list.h" namespace set2 { + CDSUNIT_DEFINE_SplitList(cc::split_list::implementation_tag, Set_InsDelFind) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_SplitList ) CDSUNIT_TEST_SplitList CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_std.cpp b/tests/unit/set2/set_insdelfind_std.cpp index 7543b88a..d5e999d9 100644 --- a/tests/unit/set2/set_insdelfind_std.cpp +++ b/tests/unit/set2/set_insdelfind_std.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_std.h" namespace set2 { + CDSUNIT_DEFINE_StdSet(std_implementation_tag, Set_InsDelFind) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_StdSet ) CDSUNIT_TEST_StdSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_insdelfind_striped.cpp b/tests/unit/set2/set_insdelfind_striped.cpp index f98d69f9..15bb7888 100644 --- a/tests/unit/set2/set_insdelfind_striped.cpp +++ b/tests/unit/set2/set_insdelfind_striped.cpp @@ -1,8 +1,11 @@ //$$CDS-header$$ #include "set2/set_insdelfind.h" +#include "set2/set_type_striped.h" namespace set2 { + CDSUNIT_DEFINE_StripedSet( cc::striped_set::implementation_tag, Set_InsDelFind ) + CPPUNIT_TEST_SUITE_PART( Set_InsDelFind, run_StripedSet ) CDSUNIT_TEST_StripedSet CPPUNIT_TEST_SUITE_END_PART() diff --git a/tests/unit/set2/set_type.h b/tests/unit/set2/set_type.h new file mode 100644 index 00000000..b36e8b7d --- /dev/null +++ b/tests/unit/set2/set_type.h @@ -0,0 +1,215 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_H +#define CDSUNIT_SET_TYPE_H + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "cppunit/cppunit_mini.h" +#include "lock/nolock.h" +#include "michael_alloc.h" + +namespace set2 { + namespace cc = cds::container; + namespace co = cds::opt; + + typedef cds::urcu::gc< cds::urcu::general_instant<> > rcu_gpi; + typedef cds::urcu::gc< cds::urcu::general_buffered<> > rcu_gpb; + typedef cds::urcu::gc< cds::urcu::general_threaded<> > rcu_gpt; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cds::urcu::gc< cds::urcu::signal_buffered<> > rcu_shb; + typedef cds::urcu::gc< cds::urcu::signal_threaded<> > rcu_sht; +#endif + + template + struct cmp { + int operator ()(Key const& k1, Key const& k2) const + { + if ( std::less( k1, k2 ) ) + return -1; + return std::less( k2, k1 ) ? 1 : 0; + } + }; + +#define CDSUNIT_INT_COMPARE(t) template <> struct cmp { int operator()( t k1, t k2 ){ return (int)(k1 - k2); } } + CDSUNIT_INT_COMPARE(char); + CDSUNIT_INT_COMPARE(unsigned char); + CDSUNIT_INT_COMPARE(int); + CDSUNIT_INT_COMPARE(unsigned int); + CDSUNIT_INT_COMPARE(long); + CDSUNIT_INT_COMPARE(unsigned long); + CDSUNIT_INT_COMPARE(long long); + CDSUNIT_INT_COMPARE(unsigned long long); +#undef CDSUNIT_INT_COMPARE + + template <> + struct cmp + { + int operator()(std::string const& s1, std::string const& s2) + { + return s1.compare( s2 ); + } + int operator()(std::string const& s1, char const * s2) + { + return s1.compare( s2 ); + } + int operator()(char const * s1, std::string const& s2) + { + return -s2.compare( s1 ); + } + }; + + // forward + template + struct set_type; + + template + struct set_type_base + { + typedef Key key_type; + typedef Value value_type; + + struct key_val { + key_type key; + value_type val; + + /*explicit*/ key_val( key_type const& k ): key(k), val() {} + key_val( key_type const& k, value_type const& v ): key(k), val(v) {} + + template + /*explicit*/ key_val( K const& k ): key(k) {} + + template + key_val( K const& k, T const& v ): key(k), val(v) {} + }; + + typedef co::v::hash key_hash; + typedef std::less key_less; + typedef cmp key_compare; + + struct less { + bool operator()( key_val const& k1, key_val const& k2 ) const + { + return key_less()( k1.key, k2.key ); + } + bool operator()( key_type const& k1, key_val const& k2 ) const + { + return key_less()( k1, k2.key ); + } + bool operator()( key_val const& k1, key_type const& k2 ) const + { + return key_less()( k1.key, k2 ); + } + }; + + struct compare { + int operator()( key_val const& k1, key_val const& k2 ) const + { + return key_compare()( k1.key, k2.key ); + } + int operator()( key_type const& k1, key_val const& k2 ) const + { + return key_compare()( k1, k2.key ); + } + int operator()( key_val const& k1, key_type const& k2 ) const + { + return key_compare()( k1.key, k2 ); + } + }; + + struct equal_to { + bool operator()( key_val const& k1, key_val const& k2 ) const + { + return key_compare()( k1.key, k2.key ) == 0; + } + bool operator()( key_type const& k1, key_val const& k2 ) const + { + return key_compare()( k1, k2.key ) == 0; + } + bool operator()( key_val const& k1, key_type const& k2 ) const + { + return key_compare()( k1.key, k2 ) == 0; + } + }; + + + struct hash: public key_hash + { + size_t operator()( key_val const& v ) const + { + return key_hash::operator()( v.key ); + } + size_t operator()( key_type const& key ) const + { + return key_hash::operator()( key ); + } + template + size_t operator()( Q const& k ) const + { + return key_hash::operator()( k ); + } + }; + + struct hash2: public hash + { + size_t operator()( key_val const& k ) const + { + size_t seed = ~hash::operator ()( k ); + boost::hash_combine( seed, k.key ); + return seed; + } + size_t operator()( key_type const& k ) const + { + size_t seed = ~hash::operator ()( k ); + boost::hash_combine( seed, k ); + return seed; + } + template + size_t operator()( Q const& k ) const + { + return key_hash::operator()( k ); + } + }; + }; + + + // ************************************************* + // print_stat + // ************************************************* + + template + static inline void print_stat( Set const& /*s*/ ) + {} + + + //******************************************************* + // additional_check + //******************************************************* + + template + static inline void additional_check( Set& /*set*/ ) + {} + + template + static inline void additional_cleanup( Set& /*set*/ ) + {} + + //******************************************************* + // check_before_clear + //******************************************************* + + template + static inline void check_before_clear( Set& /*s*/ ) + {} + +} // namespace set2 + +#endif // ifndef CDSUNIT_SET_TYPE_H diff --git a/tests/unit/set2/set_type_cuckoo.h b/tests/unit/set2/set_type_cuckoo.h new file mode 100644 index 00000000..bd868bd2 --- /dev/null +++ b/tests/unit/set2/set_type_cuckoo.h @@ -0,0 +1,170 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_CUCKOO_H +#define CDSUNIT_SET_TYPE_CUCKOO_H + +#include "set2/set_type.h" + +#include +#include "print_cuckoo_stat.h" + +namespace set2 { + + template + class CuckooSet : public cc::CuckooSet< V, Traits > + { + public: + 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 + bool erase_with( Q const& key, Pred /*pred*/ ) + { + return cuckoo_base_class::erase_with( key, typename std::conditional< cuckoo_base_class::c_isSorted, Pred, typename Pred::equal_to>::type() ); + } + }; + + + template + struct set_type< cds::intrusive::cuckoo::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + using base_class::hash2; + + // *************************************************************************** + // CuckooSet + + template + struct traits_CuckooStripedSet : public Traits + { + typedef cc::cuckoo::striping<> mutex_policy; + }; + template + struct traits_CuckooRefinableSet : public Traits + { + typedef cc::cuckoo::refinable<> mutex_policy; + }; + + struct traits_CuckooSet_list_unord : + public cc::cuckoo::make_traits < + cc::cuckoo::probeset_type< cc::cuckoo::list > + , co::equal_to< equal_to > + , co::hash< std::tuple< hash, hash2 > > + > ::type + {}; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord; + + struct traits_CuckooSet_list_unord_stat : public traits_CuckooSet_list_unord + { + typedef cc::cuckoo::stat stat; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord_stat; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord_stat; + + struct traits_CuckooSet_list_unord_storehash : public traits_CuckooSet_list_unord + { + static CDS_CONSTEXPR const bool store_hash = true; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord_storehash; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord_storehash; + + struct traits_CuckooSet_list_ord : + public cc::cuckoo::make_traits < + cc::cuckoo::probeset_type< cc::cuckoo::list > + , co::compare< compare > + , co::hash< std::tuple< hash, hash2 > > + > ::type + {}; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord; + + struct traits_CuckooSet_list_ord_stat : public traits_CuckooSet_list_ord + { + typedef cc::cuckoo::stat stat; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord_stat; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord_stat; + + struct traits_CuckooSet_list_ord_storehash : public traits_CuckooSet_list_ord + { + static CDS_CONSTEXPR const bool store_hash = true; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord_storehash; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord_storehash; + + + struct traits_CuckooSet_vector_unord : + public cc::cuckoo::make_traits < + cc::cuckoo::probeset_type< cc::cuckoo::vector<4> > + , co::equal_to< equal_to > + , co::hash< std::tuple< hash, hash2 > > + > ::type + {}; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord; + + struct traits_CuckooSet_vector_unord_stat : public traits_CuckooSet_vector_unord + { + typedef cc::cuckoo::stat stat; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord_stat; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord_stat; + + struct traits_CuckooSet_vector_unord_storehash : public traits_CuckooSet_vector_unord + { + static CDS_CONSTEXPR const bool store_hash = true; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord_storehash; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord_storehash; + + struct traits_CuckooSet_vector_ord : + public cc::cuckoo::make_traits < + cc::cuckoo::probeset_type< cc::cuckoo::vector<4> > + , co::compare< compare > + , co::hash< std::tuple< hash, hash2 > > + > ::type + {}; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord; + + struct traits_CuckooSet_vector_ord_stat : public traits_CuckooSet_vector_ord + { + typedef cc::cuckoo::stat stat; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord_stat; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord_stat; + + struct traits_CuckooSet_vector_ord_storehash : public traits_CuckooSet_vector_ord + { + static CDS_CONSTEXPR const bool store_hash = true; + }; + typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord_storehash; + typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord_storehash; + + }; + + template + static inline void print_stat( cc::CuckooSet< T, Traits > const& s ) + { + CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() ); + } + + template + static inline void print_stat( CuckooSet< V, Traits > const& s ) + { + typedef CuckooSet< V, Traits > set_type; + print_stat( static_cast(s) ); + } + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_CUCKOO_H diff --git a/tests/unit/set2/set_type_ellen_bintree.h b/tests/unit/set2/set_type_ellen_bintree.h new file mode 100644 index 00000000..2a5b1732 --- /dev/null +++ b/tests/unit/set2/set_type_ellen_bintree.h @@ -0,0 +1,275 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_ELLEN_BINTREE_H +#define CDSUNIT_SET_TYPE_ELLEN_BINTREE_H + +#include "set2/set_type.h" + +#include +#include +#include + +#include "print_ellenbintree_stat.h" + +namespace set2 { + + template + struct set_type< cc::ellen_bintree::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + struct ellen_bintree_props { + struct key_extractor { + void operator()( key_type& dest, key_val const& src ) const + { + dest = src.key; + } + }; + + struct less { + bool operator()( key_val const& v1, key_val const& v2 ) const + { + return key_less()( v1.key, v2.key ); + } + bool operator()( key_type const& k, key_val const& v ) const + { + return key_less()( k, v.key ); + } + bool operator()( key_val const& v, key_type const& k ) const + { + return key_less()( v.key, k ); + } + bool operator()( key_type const& k1, key_type const& k2 ) const + { + return key_less()( k1, k2 ); + } + }; + + struct hp_gc { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; + + struct dhp_gc { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; + + struct gpi { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; + struct gpb { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; + struct gpt { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + struct shb { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; + struct sht { + typedef cc::ellen_bintree::node leaf_node; + typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; + typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; + }; +#endif + }; + + struct traits_EllenBinTreeSet: public cc::ellen_bintree::make_set_traits< + cc::ellen_bintree::key_extractor< typename ellen_bintree_props::key_extractor > + ,co::less< typename ellen_bintree_props::less > + ,co::node_allocator< ellen_bintree_pool::internal_node_allocator< int > > + >::type + {}; + + struct traits_EllenBinTreeSet_hp : public traits_EllenBinTreeSet + { + 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; + + 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; + + 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; + + 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; + + 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; + +#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; + + 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; +#endif + + // + struct traits_EllenBinTreeSet_yield : public traits_EllenBinTreeSet + { + typedef cds::backoff::yield back_off; + }; + + struct traits_EllenBinTreeSet_yield_hp : public traits_EllenBinTreeSet_yield + { + 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; + + 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; + + + 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; + + + struct traits_EllenBinTreeSet_stat: public cc::ellen_bintree::make_set_traits< + cc::ellen_bintree::key_extractor< typename ellen_bintree_props::key_extractor > + ,co::less< typename ellen_bintree_props::less > + ,co::node_allocator< ellen_bintree_pool::internal_node_allocator< int > > + ,co::stat< cc::ellen_bintree::stat<> > + >::type + {}; + + struct traits_EllenBinTreeSet_stat_hp : public traits_EllenBinTreeSet_stat + { + 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; + + 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; + + 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; + + 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; + + 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; + +#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; + + 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; +#endif + + }; + + template + static inline void print_stat( cc::EllenBinTreeSet const& s ) + { + CPPUNIT_MSG( s.statistics() ); + } + + namespace ellen_bintree_check { + static inline void check_stat( cds::intrusive::ellen_bintree::empty_stat const& /*s*/ ) + { + // Not true for threaded RCU + /* + CPPUNIT_CHECK_CURRENT_EX( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == ellen_bintree_pool::internal_node_counter::m_nFree.get(), + "m_nAlloc=" << ellen_bintree_pool::internal_node_counter::m_nAlloc.get() + << ", m_nFree=" << ellen_bintree_pool::internal_node_counter::m_nFree.get() + ); + */ + } + + static inline void check_stat( cds::intrusive::ellen_bintree::stat<> const& stat ) + { + CPPUNIT_CHECK_CURRENT( stat.m_nInternalNodeCreated == stat.m_nInternalNodeDeleted ); + CPPUNIT_CHECK_CURRENT( stat.m_nUpdateDescCreated == stat.m_nUpdateDescDeleted ); + //CPPUNIT_CHECK_CURRENT( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == ellen_bintree_pool::internal_node_counter::m_nFree.get() ); + CPPUNIT_CHECK_CURRENT( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == stat.m_nInternalNodeCreated ); + // true if RCU is not threaded + //CPPUNIT_CHECK_CURRENT( stat.m_nInternalNodeDeleted == ellen_bintree_pool::internal_node_counter::m_nFree.get() ); + } + } // namespace ellen_bintree_check + + template + static inline void additional_check( cc::EllenBinTreeSet& s ) + { + GC::force_dispose(); + ellen_bintree_check::check_stat( s.statistics() ); + } + + template + static inline void additional_cleanup( cc::EllenBinTreeSet& /*s*/ ) + { + ellen_bintree_pool::internal_node_counter::reset(); + } + + template + static inline void check_before_clear( cds::container::EllenBinTreeSet& s ) + { + CPPUNIT_CHECK_CURRENT( s.check_consistency() ); + } + + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_ELLEN_BINTREE_H diff --git a/tests/unit/set2/set_type_lazy_list.h b/tests/unit/set2/set_type_lazy_list.h new file mode 100644 index 00000000..ca1c8873 --- /dev/null +++ b/tests/unit/set2/set_type_lazy_list.h @@ -0,0 +1,116 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_LAZY_LIST_H +#define CDSUNIT_SET_TYPE_LAZY_LIST_H + +#include "set2/set_type.h" + +#include +#include +#include + +namespace set2 { + + template + struct lazy_list_type + { + typedef typename set_type_base< Key, Val >::key_val key_val; + typedef typename set_type_base< Key, Val >::compare compare; + typedef typename set_type_base< Key, Val >::less less; + + struct traits_LazyList_cmp_stdAlloc : + public cc::lazy_list::make_traits< + co::compare< compare > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_stdAlloc > LazyList_HP_cmp_stdAlloc; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_stdAlloc > LazyList_DHP_cmp_stdAlloc; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPI_cmp_stdAlloc; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPB_cmp_stdAlloc; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPT_cmp_stdAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHB_cmp_stdAlloc; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHT_cmp_stdAlloc; +#endif + struct traits_LazyList_cmp_stdAlloc_seqcst : + public cc::lazy_list::make_traits< + co::compare< compare > + ,co::memory_model< co::v::sequential_consistent > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_HP_cmp_stdAlloc_seqcst; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_DHP_cmp_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPI_cmp_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPB_cmp_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPT_cmp_stdAlloc_seqcst; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_SHB_cmp_stdAlloc_seqcst; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_SHT_cmp_stdAlloc_seqcst; +#endif + struct traits_LazyList_cmp_michaelAlloc : + public cc::lazy_list::make_traits< + co::compare< compare >, + co::allocator< memory::MichaelAllocator > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_HP_cmp_michaelAlloc; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_DHP_cmp_michaelAlloc; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPI_cmp_michaelAlloc; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPB_cmp_michaelAlloc; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPT_cmp_michaelAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_SHB_cmp_michaelAlloc; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_SHT_cmp_michaelAlloc; +#endif + + struct traits_LazyList_less_stdAlloc: + public cc::lazy_list::make_traits< + co::less< less > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_stdAlloc > LazyList_HP_less_stdAlloc; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_stdAlloc > LazyList_DHP_less_stdAlloc; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPI_less_stdAlloc; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPB_less_stdAlloc; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPT_less_stdAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_SHB_less_stdAlloc; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_SHT_less_stdAlloc; +#endif + + struct traits_LazyList_less_stdAlloc_seqcst : + public cc::lazy_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_HP_less_stdAlloc_seqcst; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_DHP_less_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPI_less_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPB_less_stdAlloc_seqcst; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPT_less_stdAlloc_seqcst; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_SHB_less_stdAlloc_seqcst; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_SHT_less_stdAlloc_seqcst; +#endif + + struct traits_LazyList_less_michaelAlloc : + public cc::lazy_list::make_traits< + co::less< less >, + co::allocator< memory::MichaelAllocator > + >::type + {}; + typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_michaelAlloc > LazyList_HP_less_michaelAlloc; + typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_michaelAlloc > LazyList_DHP_less_michaelAlloc; + typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPI_less_michaelAlloc; + typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPB_less_michaelAlloc; + typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPT_less_michaelAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_SHB_less_michaelAlloc; + typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_SHT_less_michaelAlloc; +#endif + }; + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_LAZY_LIST_H diff --git a/tests/unit/set2/set_type_michael.h b/tests/unit/set2/set_type_michael.h new file mode 100644 index 00000000..4d66236c --- /dev/null +++ b/tests/unit/set2/set_type_michael.h @@ -0,0 +1,150 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_MICHAEL_H +#define CDSUNIT_SET_TYPE_MICHAEL_H + +#include "set2/set_type_michael_list.h" +#include "set2/set_type_lazy_list.h" + +#include +#include + +#include "michael_alloc.h" + +namespace set2 { + + template + struct set_type< cc::michael_set::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + // *************************************************************************** + // MichaelHashSet based on MichaelList + + typedef michael_list_type< Key, Val > ml; + + struct traits_MichaelSet_stdAlloc : + public cc::michael_set::make_traits< + 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; +#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; +#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; +#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; +#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; +#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; +#endif + + struct traits_MichaelSet_michaelAlloc : + public cc::michael_set::make_traits< + co::hash< hash >, + 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; +#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; +#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; +#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; +#endif + + + // *************************************************************************** + // MichaelHashSet based on LazyList + + 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; +#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; +#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; +#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; +#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; +#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; +#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; +#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; +#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; +#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; +#endif + }; + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_MICHAEL_H diff --git a/tests/unit/set2/set_type_michael_list.h b/tests/unit/set2/set_type_michael_list.h new file mode 100644 index 00000000..bccd4964 --- /dev/null +++ b/tests/unit/set2/set_type_michael_list.h @@ -0,0 +1,116 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_MICHAEL_LIST_H +#define CDSUNIT_SET_TYPE_MICHAEL_LIST_H + +#include "set2/set_type.h" + +#include +#include +#include + +namespace set2 { + + template + struct michael_list_type + { + typedef typename set_type_base< Key, Val >::key_val key_val; + typedef typename set_type_base< Key, Val >::compare compare; + typedef typename set_type_base< Key, Val >::less less; + + struct traits_MichaelList_cmp_stdAlloc: + public cc::michael_list::make_traits< + co::compare< compare > + >::type + {}; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_HP_cmp_stdAlloc; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_DHP_cmp_stdAlloc; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPI_cmp_stdAlloc; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPB_cmp_stdAlloc; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPT_cmp_stdAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_SHB_cmp_stdAlloc; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_SHT_cmp_stdAlloc; +#endif + + struct traits_MichaelList_cmp_stdAlloc_seqcst : public traits_MichaelList_cmp_stdAlloc + { + typedef co::v::sequential_consistent memory_model; + }; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_HP_cmp_stdAlloc_seqcst; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_DHP_cmp_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPI_cmp_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPB_cmp_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPT_cmp_stdAlloc_seqcst; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_SHB_cmp_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_SHT_cmp_stdAlloc_seqcst; +#endif + + struct traits_MichaelList_less_stdAlloc : + public cc::michael_list::make_traits< + co::less< less > + >::type + {}; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_stdAlloc > MichaelList_HP_less_stdAlloc; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_stdAlloc > MichaelList_DHP_less_stdAlloc; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPI_less_stdAlloc; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPB_less_stdAlloc; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPT_less_stdAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_SHB_less_stdAlloc; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_SHT_less_stdAlloc; +#endif + + struct traits_MichaelList_less_stdAlloc_seqcst : + public cc::michael_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + {}; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_HP_less_stdAlloc_seqcst; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_DHP_less_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPI_less_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPB_less_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPT_less_stdAlloc_seqcst; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_SHB_less_stdAlloc_seqcst; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_SHT_less_stdAlloc_seqcst; +#endif + + struct traits_MichaelList_cmp_michaelAlloc : + public cc::michael_list::make_traits< + co::compare< compare >, + co::allocator< memory::MichaelAllocator > + >::type + {}; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_HP_cmp_michaelAlloc; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_DHP_cmp_michaelAlloc; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPI_cmp_michaelAlloc; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPB_cmp_michaelAlloc; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPT_cmp_michaelAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_SHB_cmp_michaelAlloc; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_SHT_cmp_michaelAlloc; +#endif + + struct traits_MichaelList_less_michaelAlloc : + public cc::michael_list::make_traits< + co::less< less >, + co::allocator< memory::MichaelAllocator > + >::type + {}; + typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_HP_less_michaelAlloc; + typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_DHP_less_michaelAlloc; + typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPI_less_michaelAlloc; + typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPB_less_michaelAlloc; + typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPT_less_michaelAlloc; +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_SHB_less_michaelAlloc; + typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_SHT_less_michaelAlloc; +#endif + }; + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_MICHAEL_LIST_H diff --git a/tests/unit/set2/set_type_skip_list.h b/tests/unit/set2/set_type_skip_list.h new file mode 100644 index 00000000..27e31038 --- /dev/null +++ b/tests/unit/set2/set_type_skip_list.h @@ -0,0 +1,183 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_SKIP_LIST_H +#define CDSUNIT_SET_TYPE_SKIP_LIST_H + +#include "set2/set_type.h" + +#include +#include +#include + +#include "print_skip_list_stat.h" + +namespace set2 { + + template + struct set_type< cc::skip_list::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + class traits_SkipListSet_less_pascal: public cc::skip_list::make_traits < + co::less< less > + ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > + ,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; +#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; +#endif + + class traits_SkipListSet_less_pascal_seqcst: public cc::skip_list::make_traits < + co::less< less > + ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > + ,co::memory_model< co::v::sequential_consistent > + ,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; +#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; +#endif + + class traits_SkipListSet_less_pascal_stat: public cc::skip_list::make_traits < + co::less< less > + ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > + ,co::stat< cc::skip_list::stat<> > + ,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; +#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; +#endif + + class traits_SkipListSet_cmp_pascal: public cc::skip_list::make_traits < + co::compare< compare > + ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > + ,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; +#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; +#endif + + class traits_SkipListSet_cmp_pascal_stat: public cc::skip_list::make_traits < + co::compare< compare > + ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > + ,co::stat< cc::skip_list::stat<> > + ,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; +#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; +#endif + + class traits_SkipListSet_less_xorshift: public cc::skip_list::make_traits < + co::less< less > + ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > + ,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; +#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; +#endif + + class traits_SkipListSet_less_xorshift_stat: public cc::skip_list::make_traits < + co::less< less > + ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > + ,co::stat< cc::skip_list::stat<> > + ,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; +#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; +#endif + + class traits_SkipListSet_cmp_xorshift: public cc::skip_list::make_traits < + co::compare< compare > + ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > + ,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; +#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; +#endif + + class traits_SkipListSet_cmp_xorshift_stat: public cc::skip_list::make_traits < + co::compare< compare > + ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > + ,co::stat< cc::skip_list::stat<> > + ,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; +#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; +#endif + }; + + template + static inline void print_stat( cc::SkipListSet const& s ) + { + CPPUNIT_MSG( s.statistics() ); + } + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_SKIP_LIST_H diff --git a/tests/unit/set2/set_type_split_list.h b/tests/unit/set2/set_type_split_list.h new file mode 100644 index 00000000..dfbbc12f --- /dev/null +++ b/tests/unit/set2/set_type_split_list.h @@ -0,0 +1,480 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H +#define CDSUNIT_SET_TYPE_SPLIT_LIST_H + +#include "set2/set_type.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "print_split_list_stat.h" + +namespace set2 { + + template + struct set_type< cc::split_list::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + // *************************************************************************** + // SplitListSet based on MichaelList + + struct traits_SplitList_Michael_dyn_cmp : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::compare< compare > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_dyn_cmp_stat : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,co::stat< cc::split_list::stat<> > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::compare< compare > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_dyn_cmp_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::compare< compare > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_st_cmp : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,cc::split_list::dynamic_bucket_table< false > + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::compare< compare > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_st_cmp_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::dynamic_bucket_table< false > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::compare< compare > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + //HP + less + struct traits_SplitList_Michael_dyn_less : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::less< less > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_dyn_less_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_st_less : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,cc::split_list::dynamic_bucket_table< false > + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::less< less > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_st_less_stat : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,cc::split_list::dynamic_bucket_table< false > + ,co::hash< hash > + ,co::stat< cc::split_list::stat<>> + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::less< less > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Michael_st_less_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::dynamic_bucket_table< false > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + // *************************************************************************** + // SplitListSet based on LazyList + + struct traits_SplitList_Lazy_dyn_cmp : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::compare< compare > + >::type + > + >::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; +#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; +#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; +#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; +#endif + + struct traits_SplitList_Lazy_dyn_cmp_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::compare< compare > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_st_cmp : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,cc::split_list::dynamic_bucket_table< false > + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::compare< compare > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_st_cmp_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::dynamic_bucket_table< false > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::compare< compare > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_dyn_less : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::less< less > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_dyn_less_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_st_less : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,cc::split_list::dynamic_bucket_table< false > + ,co::hash< hash > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::less< less > + >::type + > + >::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; +#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; +#endif + + struct traits_SplitList_Lazy_st_less_seqcst : + public cc::split_list::make_traits< + cc::split_list::ordered_list + ,co::hash< hash > + ,cc::split_list::dynamic_bucket_table< false > + ,co::memory_model< co::v::sequential_consistent > + ,cc::split_list::ordered_list_traits< + typename cc::lazy_list::make_traits< + co::less< less > + ,co::memory_model< co::v::sequential_consistent > + >::type + > + >::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; +#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; +#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; +#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; +#endif + }; + + template + static inline void print_stat( cc::SplitListSet const& s ) + { + CPPUNIT_MSG( s.statistics() ); + } + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H diff --git a/tests/unit/set2/set_type_std.h b/tests/unit/set2/set_type_std.h new file mode 100644 index 00000000..fd441be0 --- /dev/null +++ b/tests/unit/set2/set_type_std.h @@ -0,0 +1,206 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_STD_H +#define CDSUNIT_SET_TYPE_STD_H + +#include +#include +#include //unique_lock + +#include "set2/set_type.h" + +namespace set2 { + + struct std_implementation_tag; + + template ::other + > + class StdHashSet + : public std::unordered_set< + Value + , Hash + , EqualTo + , Alloc + > + { + public: + Lock m_lock; + typedef std::unique_lock scoped_lock; + typedef std::unordered_set< + Value + , Hash + , EqualTo + , Alloc + > base_class; + + public: + typedef typename base_class::value_type value_type; + typedef std_implementation_tag implementation_tag; + + StdHashSet( size_t /*nSetSize*/, size_t /*nLoadFactor*/ ) + {} + + template + bool find( const Key& key ) + { + scoped_lock al( m_lock ); + return base_class::find( value_type(key) ) != base_class::end(); + } + + template + bool insert( Key const& key ) + { + scoped_lock al( m_lock ); + std::pair pRet = base_class::insert( value_type( key )); + return pRet.second; + } + + template + bool insert( Key const& key, Func func ) + { + scoped_lock al( m_lock ); + std::pair pRet = base_class::insert( value_type( key )); + if ( pRet.second ) { + func( *pRet.first ); + return true; + } + return false; + } + + template + std::pair ensure( const T& key, Func func ) + { + scoped_lock al( m_lock ); + std::pair pRet = base_class::insert( value_type( key )); + if ( pRet.second ) { + func( true, *pRet.first, key ); + return std::make_pair( true, true ); + } + else { + func( false, *pRet.first, key ); + return std::make_pair( true, false ); + } + } + + template + bool erase( const Key& key ) + { + scoped_lock al( m_lock ); + return base_class::erase( value_type(key) ) != 0; + } + + template + bool erase( const T& key, Func func ) + { + scoped_lock al( m_lock ); + typename base_class::iterator it = base_class::find( value_type(key) ); + if ( it != base_class::end() ) { + func( *it ); + return base_class::erase( it ) != base_class::end(); + } + return false; + } + + std::ostream& dump( std::ostream& stm ) { return stm; } + }; + + template ::other + > + class StdSet: public std::set + { + Lock m_lock; + typedef std::unique_lock scoped_lock; + typedef std::set base_class; + public: + typedef typename base_class::key_type value_type; + typedef std_implementation_tag implementation_tag; + + StdSet( size_t /*nMapSize*/, size_t /*nLoadFactor*/ ) + {} + + template + bool find( const Key& key ) + { + value_type v( key ); + scoped_lock al( m_lock ); + return base_class::find( v ) != base_class::end(); + } + + bool insert( value_type const& v ) + { + scoped_lock al( m_lock ); + return base_class::insert( v ).second; + } + + template + bool insert( Key const& key, Func func ) + { + scoped_lock al( m_lock ); + std::pair pRet = base_class::insert( value_type( key )); + if ( pRet.second ) { + func( *pRet.first ); + return true; + } + return false; + } + + template + std::pair ensure( const T& key, Func func ) + { + scoped_lock al( m_lock ); + std::pair pRet = base_class::insert( value_type( key )); + if ( pRet.second ) { + func( true, *pRet.first, key ); + return std::make_pair( true, true ); + } + else { + func( false, *pRet.first, key ); + return std::make_pair( true, false ); + } + } + + template + bool erase( const Key& key ) + { + scoped_lock al( m_lock ); + return base_class::erase( value_type(key) ) != 0; + } + + template + bool erase( const T& key, Func func ) + { + scoped_lock al( m_lock ); + typename base_class::iterator it = base_class::find( value_type(key) ); + if ( it != base_class::end() ) { + func( *it ); + + base_class::erase( it ); + return true; + } + return false; + } + + std::ostream& dump( std::ostream& stm ) { return stm; } + }; + + template + struct set_type< std_implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + typedef StdSet< key_val, less, cds::sync::spin > StdSet_Spin; + typedef StdSet< key_val, less, lock::NoLock> StdSet_NoLock; + + typedef StdHashSet< key_val, hash, less, equal_to, cds::sync::spin > StdHashSet_Spin; + typedef StdHashSet< key_val, hash, less, equal_to, lock::NoLock > StdHashSet_NoLock; + }; + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_STD_H diff --git a/tests/unit/set2/set_type_striped.h b/tests/unit/set2/set_type_striped.h new file mode 100644 index 00000000..38076038 --- /dev/null +++ b/tests/unit/set2/set_type_striped.h @@ -0,0 +1,293 @@ +//$$CDS-header$$ + +#ifndef CDSUNIT_SET_TYPE_STRIPED_H +#define CDSUNIT_SET_TYPE_STRIPED_H + +#include "set2/set_type.h" + +#include +#include +#include +#include +#include + +#include +#if BOOST_VERSION >= 104800 +# include +# include +# include +# include +# include +# include +#endif +#include + +namespace set2 { + + template + struct set_type< cc::striped_set::implementation_tag, Key, Val >: public set_type_base< Key, Val > + { + typedef set_type_base< Key, Val > base_class; + using base_class::key_val; + using base_class::compare; + using base_class::less; + using base_class::hash; + + + // *************************************************************************** + // StripedSet + + // for sequential containers + template + class StripedHashSet_seq: + public cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::striping<> > + ,co::resizing_policy > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::striping<> > + ,co::resizing_policy > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + StripedHashSet_seq( size_t nCapacity, size_t nLoadFactor ) + : base_class( nCapacity / nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + + // for non-sequential ordered containers + template + class StripedHashSet_ord: + public cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::striping<> > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::striping<> > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + StripedHashSet_ord( size_t /*nCapacity*/, size_t nLoadFactor ) + : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor * 1024 )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + + typedef StripedHashSet_seq< + std::list< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_list; + + typedef StripedHashSet_seq< + std::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_vector; + +#if BOOST_VERSION >= 104800 + typedef StripedHashSet_seq< + boost::container::slist< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_boost_slist; + + typedef StripedHashSet_seq< + boost::container::list< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_boost_list; + + typedef StripedHashSet_seq< + boost::container::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_boost_vector; + + typedef StripedHashSet_seq< + boost::container::stable_vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_boost_stable_vector; +#endif + + typedef StripedHashSet_ord< + std::set< key_val, less > + , co::hash< hash2 > + > StripedSet_set; + + typedef StripedHashSet_ord< + std::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > StripedSet_hashset; + +#if BOOST_VERSION >= 104800 + typedef StripedHashSet_ord< + boost::container::set< key_val, less > + , co::hash< hash2 > + > StripedSet_boost_set; + + typedef StripedHashSet_ord< + boost::container::flat_set< key_val, less > + , co::hash< hash2 > + > StripedSet_boost_flat_set; +#endif + + typedef StripedHashSet_ord< + boost::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > StripedSet_boost_unordered_set; + + + // *************************************************************************** + // RefinableSet + + // for sequential containers + template + class RefinableHashSet_seq: + public cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::refinable<> > + ,co::resizing_policy > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::refinable<> > + ,co::resizing_policy > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + RefinableHashSet_seq( size_t nCapacity, size_t nLoadFactor ) + : base_class( nCapacity / nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + + // for non-sequential ordered containers + template + class RefinableHashSet_ord: + public cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::refinable<> > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::refinable<> > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + RefinableHashSet_ord( size_t /*nCapacity*/, size_t nLoadFactor ) + : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor * 1024 )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + + typedef RefinableHashSet_seq< + std::list< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_list; + + typedef RefinableHashSet_seq< + std::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_vector; + +#if BOOST_VERSION >= 104800 + typedef RefinableHashSet_seq< + boost::container::slist< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_boost_slist; + + typedef RefinableHashSet_seq< + boost::container::list< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_boost_list; + + typedef RefinableHashSet_seq< + boost::container::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_boost_vector; + + typedef RefinableHashSet_seq< + boost::container::stable_vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_boost_stable_vector; +#endif + + typedef RefinableHashSet_ord< + std::set< key_val, less > + , co::hash< hash2 > + > RefinableSet_set; + + typedef RefinableHashSet_ord< + std::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > RefinableSet_hashset; + +#if BOOST_VERSION >= 104800 + typedef RefinableHashSet_ord< + boost::container::set< key_val, less > + , co::hash< hash2 > + > RefinableSet_boost_set; + + typedef RefinableHashSet_ord< + boost::container::flat_set< key_val, less > + , co::hash< hash2 > + > RefinableSet_boost_flat_set; +#endif + + typedef RefinableHashSet_ord< + boost::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > RefinableSet_boost_unordered_set; + }; + +} // namespace set2 + +#endif // #ifndef CDSUNIT_SET_TYPE_STRIPED_H diff --git a/tests/unit/set2/set_types.h b/tests/unit/set2/set_types.h deleted file mode 100644 index 1e163239..00000000 --- a/tests/unit/set2/set_types.h +++ /dev/null @@ -1,1825 +0,0 @@ -//$$CDS-header$$ - -#ifndef CDSUNIT_SET_TYPES_H -#define CDSUNIT_SET_TYPES_H - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include -#include - -#include -#include - -#include - -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#if BOOST_VERSION >= 104800 -# include -# include -# include -# include -# include -# include -#endif -#include - -#include -#include - -#include "cppunit/cppunit_mini.h" -#include "lock/nolock.h" -#include "set2/std_set.h" -#include "set2/std_hash_set.h" -#include "michael_alloc.h" -#include "print_cuckoo_stat.h" -#include "print_split_list_stat.h" -#include "print_skip_list_stat.h" -#include "print_ellenbintree_stat.h" -#include "ellen_bintree_update_desc_pool.h" - -namespace set2 { - namespace cc = cds::container; - namespace co = cds::opt; - - typedef cds::urcu::gc< cds::urcu::general_instant<> > rcu_gpi; - typedef cds::urcu::gc< cds::urcu::general_buffered<> > rcu_gpb; - typedef cds::urcu::gc< cds::urcu::general_threaded<> > rcu_gpt; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cds::urcu::gc< cds::urcu::signal_buffered<> > rcu_shb; - typedef cds::urcu::gc< cds::urcu::signal_threaded<> > rcu_sht; -#endif - - template - class CuckooSet : public cc::CuckooSet< V, Traits > - { - public: - 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 - bool erase_with( Q const& key, Pred /*pred*/ ) - { - return cuckoo_base_class::erase_with( key, typename std::conditional< cuckoo_base_class::c_isSorted, Pred, typename Pred::equal_to>::type() ); - } - }; - - template - struct cmp { - int operator ()(Key const& k1, Key const& k2) const - { - if ( std::less( k1, k2 ) ) - return -1; - return std::less( k2, k1 ) ? 1 : 0; - } - }; - -#define CDSUNIT_INT_COMPARE(t) template <> struct cmp { int operator()( t k1, t k2 ){ return (int)(k1 - k2); } } - CDSUNIT_INT_COMPARE(char); - CDSUNIT_INT_COMPARE(unsigned char); - CDSUNIT_INT_COMPARE(int); - CDSUNIT_INT_COMPARE(unsigned int); - CDSUNIT_INT_COMPARE(long); - CDSUNIT_INT_COMPARE(unsigned long); - CDSUNIT_INT_COMPARE(long long); - CDSUNIT_INT_COMPARE(unsigned long long); -#undef CDSUNIT_INT_COMPARE - - template <> - struct cmp - { - int operator()(std::string const& s1, std::string const& s2) - { - return s1.compare( s2 ); - } - int operator()(std::string const& s1, char const * s2) - { - return s1.compare( s2 ); - } - int operator()(char const * s1, std::string const& s2) - { - return -s2.compare( s1 ); - } - }; - - template - struct SetTypes { - - typedef Key key_type; - typedef Value value_type; - - struct key_val { - key_type key; - value_type val; - - /*explicit*/ key_val( key_type const& k ): key(k), val() {} - key_val( key_type const& k, value_type const& v ): key(k), val(v) {} - - template - /*explicit*/ key_val( K const& k ): key(k) {} - - template - key_val( K const& k, T const& v ): key(k), val(v) {} - }; - - typedef co::v::hash key_hash; - typedef std::less key_less; - typedef cmp key_compare; - - struct less { - bool operator()( key_val const& k1, key_val const& k2 ) const - { - return key_less()( k1.key, k2.key ); - } - bool operator()( key_type const& k1, key_val const& k2 ) const - { - return key_less()( k1, k2.key ); - } - bool operator()( key_val const& k1, key_type const& k2 ) const - { - return key_less()( k1.key, k2 ); - } - }; - - struct compare { - int operator()( key_val const& k1, key_val const& k2 ) const - { - return key_compare()( k1.key, k2.key ); - } - int operator()( key_type const& k1, key_val const& k2 ) const - { - return key_compare()( k1, k2.key ); - } - int operator()( key_val const& k1, key_type const& k2 ) const - { - return key_compare()( k1.key, k2 ); - } - }; - - struct equal_to { - bool operator()( key_val const& k1, key_val const& k2 ) const - { - return key_compare()( k1.key, k2.key ) == 0; - } - bool operator()( key_type const& k1, key_val const& k2 ) const - { - return key_compare()( k1, k2.key ) == 0; - } - bool operator()( key_val const& k1, key_type const& k2 ) const - { - return key_compare()( k1.key, k2 ) == 0; - } - }; - - - struct hash: public key_hash - { - size_t operator()( key_val const& v ) const - { - return key_hash::operator()( v.key ); - } - size_t operator()( key_type const& key ) const - { - return key_hash::operator()( key ); - } - template - size_t operator()( Q const& k ) const - { - return key_hash::operator()( k ); - } - }; - - struct hash2: public hash - { - size_t operator()( key_val const& k ) const - { - size_t seed = ~hash::operator ()( k ); - boost::hash_combine( seed, k.key ); - return seed; - } - size_t operator()( key_type const& k ) const - { - size_t seed = ~hash::operator ()( k ); - boost::hash_combine( seed, k ); - return seed; - } - template - size_t operator()( Q const& k ) const - { - return key_hash::operator()( k ); - } - }; - - // *************************************************************************** - // MichaelList - - struct traits_MichaelList_cmp_stdAlloc: - public cc::michael_list::make_traits< - co::compare< compare > - >::type - {}; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_HP_cmp_stdAlloc; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_DHP_cmp_stdAlloc; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPI_cmp_stdAlloc; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPB_cmp_stdAlloc; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_GPT_cmp_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_SHB_cmp_stdAlloc; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_SHT_cmp_stdAlloc; -#endif - - struct traits_MichaelList_cmp_stdAlloc_seqcst : public traits_MichaelList_cmp_stdAlloc - { - typedef co::v::sequential_consistent memory_model; - }; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_HP_cmp_stdAlloc_seqcst; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_DHP_cmp_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPI_cmp_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPB_cmp_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_GPT_cmp_stdAlloc_seqcst; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_SHB_cmp_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc_seqcst > MichaelList_RCU_SHT_cmp_stdAlloc_seqcst; -#endif - - struct traits_MichaelList_less_stdAlloc : - public cc::michael_list::make_traits< - co::less< less > - >::type - {}; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_stdAlloc > MichaelList_HP_less_stdAlloc; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_stdAlloc > MichaelList_DHP_less_stdAlloc; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPI_less_stdAlloc; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPB_less_stdAlloc; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_GPT_less_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_SHB_less_stdAlloc; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_SHT_less_stdAlloc; -#endif - - struct traits_MichaelList_less_stdAlloc_seqcst : - public cc::michael_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - {}; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_HP_less_stdAlloc_seqcst; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_DHP_less_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_GPT_less_stdAlloc_seqcst; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc_seqcst > MichaelList_RCU_SHT_less_stdAlloc_seqcst; -#endif - - struct traits_MichaelList_cmp_michaelAlloc : - public cc::michael_list::make_traits< - co::compare< compare >, - co::allocator< memory::MichaelAllocator > - >::type - {}; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_HP_cmp_michaelAlloc; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_DHP_cmp_michaelAlloc; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPI_cmp_michaelAlloc; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPB_cmp_michaelAlloc; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_GPT_cmp_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_SHB_cmp_michaelAlloc; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_michaelAlloc > MichaelList_RCU_SHT_cmp_michaelAlloc; -#endif - - struct traits_MichaelList_less_michaelAlloc : - public cc::michael_list::make_traits< - co::less< less >, - co::allocator< memory::MichaelAllocator > - >::type - {}; - typedef cc::MichaelList< cds::gc::HP, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_HP_less_michaelAlloc; - typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_DHP_less_michaelAlloc; - typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPI_less_michaelAlloc; - typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPB_less_michaelAlloc; - typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_GPT_less_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_SHB_less_michaelAlloc; - typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_michaelAlloc > MichaelList_RCU_SHT_less_michaelAlloc; -#endif - - // *************************************************************************** - // MichaelHashSet based on MichaelList - - struct traits_MichaelSet_stdAlloc : - public cc::michael_set::make_traits< - co::hash< hash > - >::type - {}; - typedef cc::MichaelHashSet< cds::gc::HP, MichaelList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, MichaelList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, MichaelList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, MichaelList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, MichaelList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, MichaelList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, MichaelList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, MichaelList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, MichaelList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< cds::gc::DHP, MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpi, MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpb, MichaelList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpt, 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, MichaelList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst; -#endif - - struct traits_MichaelSet_michaelAlloc : - public cc::michael_set::make_traits< - co::hash< hash >, - co::allocator< memory::MichaelAllocator > - >::type - {}; - typedef cc::MichaelHashSet< cds::gc::HP, MichaelList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, MichaelList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, MichaelList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, MichaelList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, MichaelList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_cmp_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, MichaelList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_cmp_michaelAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, MichaelList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_less_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, MichaelList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, MichaelList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, MichaelList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, MichaelList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_less_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::MichaelHashSet< rcu_shb, MichaelList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_less_michaelAlloc; -#endif - - - // *************************************************************************** - // LazyList - - struct traits_LazyList_cmp_stdAlloc : - public cc::lazy_list::make_traits< - co::compare< compare > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_stdAlloc > LazyList_HP_cmp_stdAlloc; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_stdAlloc > LazyList_DHP_cmp_stdAlloc; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPI_cmp_stdAlloc; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPB_cmp_stdAlloc; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_GPT_cmp_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHB_cmp_stdAlloc; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHT_cmp_stdAlloc; -#endif - struct traits_LazyList_cmp_stdAlloc_seqcst : - public cc::lazy_list::make_traits< - co::compare< compare > - ,co::memory_model< co::v::sequential_consistent > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_HP_cmp_stdAlloc_seqcst; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_DHP_cmp_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPI_cmp_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPB_cmp_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_GPT_cmp_stdAlloc_seqcst; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_SHB_cmp_stdAlloc_seqcst; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc_seqcst > LazyList_RCU_SHT_cmp_stdAlloc_seqcst; -#endif - struct traits_LazyList_cmp_michaelAlloc : - public cc::lazy_list::make_traits< - co::compare< compare >, - co::allocator< memory::MichaelAllocator > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_HP_cmp_michaelAlloc; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_DHP_cmp_michaelAlloc; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPI_cmp_michaelAlloc; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPB_cmp_michaelAlloc; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_GPT_cmp_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_SHB_cmp_michaelAlloc; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_michaelAlloc > LazyList_RCU_SHT_cmp_michaelAlloc; -#endif - - struct traits_LazyList_less_stdAlloc: - public cc::lazy_list::make_traits< - co::less< less > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_stdAlloc > LazyList_HP_less_stdAlloc; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_stdAlloc > LazyList_DHP_less_stdAlloc; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPI_less_stdAlloc; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPB_less_stdAlloc; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_GPT_less_stdAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_SHB_less_stdAlloc; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_SHT_less_stdAlloc; -#endif - - struct traits_LazyList_less_stdAlloc_seqcst : - public cc::lazy_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_HP_less_stdAlloc_seqcst; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_DHP_less_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_GPT_less_stdAlloc_seqcst; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc_seqcst > LazyList_RCU_SHT_less_stdAlloc_seqcst; -#endif - - struct traits_LazyList_less_michaelAlloc : - public cc::lazy_list::make_traits< - co::less< less >, - co::allocator< memory::MichaelAllocator > - >::type - {}; - typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_michaelAlloc > LazyList_HP_less_michaelAlloc; - typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_michaelAlloc > LazyList_DHP_less_michaelAlloc; - typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPI_less_michaelAlloc; - typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPB_less_michaelAlloc; - typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_GPT_less_michaelAlloc; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_SHB_less_michaelAlloc; - typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_michaelAlloc > LazyList_RCU_SHT_less_michaelAlloc; -#endif - - // *************************************************************************** - // MichaelHashSet based on LazyList - - typedef cc::MichaelHashSet< cds::gc::HP, LazyList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, LazyList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, LazyList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, LazyList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, 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, LazyList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpi, LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpb, LazyList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_gpt, 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, LazyList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc; - typedef cc::MichaelHashSet< rcu_sht, LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< cds::gc::DHP, LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpi, LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpb, LazyList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_gpt, 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, LazyList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_seqcst; - typedef cc::MichaelHashSet< rcu_sht, LazyList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_seqcst; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, LazyList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, LazyList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, LazyList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, LazyList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, 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, LazyList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, LazyList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc; -#endif - - typedef cc::MichaelHashSet< cds::gc::HP, LazyList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_less_michaelAlloc; - typedef cc::MichaelHashSet< cds::gc::DHP, LazyList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpi, LazyList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpb, LazyList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_gpt, 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, LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc; - typedef cc::MichaelHashSet< rcu_sht, LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc; -#endif - - // *************************************************************************** - // SplitListSet based on MichaelList - - struct traits_SplitList_Michael_dyn_cmp : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::compare< compare > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_dyn_cmp_stat : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,co::stat< cc::split_list::stat<> > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::compare< compare > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_dyn_cmp_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::compare< compare > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_st_cmp : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,cc::split_list::dynamic_bucket_table< false > - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::compare< compare > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_st_cmp_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::dynamic_bucket_table< false > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::compare< compare > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - //HP + less - struct traits_SplitList_Michael_dyn_less : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::less< less > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_dyn_less_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_st_less : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,cc::split_list::dynamic_bucket_table< false > - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::less< less > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_st_less_stat : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,cc::split_list::dynamic_bucket_table< false > - ,co::hash< hash > - ,co::stat< cc::split_list::stat<>> - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::less< less > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Michael_st_less_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::dynamic_bucket_table< false > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::michael_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - // *************************************************************************** - // SplitListSet based on LazyList - - struct traits_SplitList_Lazy_dyn_cmp : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::compare< compare > - >::type - > - >::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; -#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; -#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; -#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; -#endif - - struct traits_SplitList_Lazy_dyn_cmp_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::compare< compare > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_st_cmp : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,cc::split_list::dynamic_bucket_table< false > - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::compare< compare > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_st_cmp_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::dynamic_bucket_table< false > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::compare< compare > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_dyn_less : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::less< less > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_dyn_less_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_st_less : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,cc::split_list::dynamic_bucket_table< false > - ,co::hash< hash > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::less< less > - >::type - > - >::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; -#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; -#endif - - struct traits_SplitList_Lazy_st_less_seqcst : - public cc::split_list::make_traits< - cc::split_list::ordered_list - ,co::hash< hash > - ,cc::split_list::dynamic_bucket_table< false > - ,co::memory_model< co::v::sequential_consistent > - ,cc::split_list::ordered_list_traits< - typename cc::lazy_list::make_traits< - co::less< less > - ,co::memory_model< co::v::sequential_consistent > - >::type - > - >::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; -#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; -#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; -#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; -#endif - - - // *************************************************************************** - // StripedSet - - // for sequential containers - template - class StripedHashSet_seq: - public cc::StripedSet< BucketEntry, - co::mutex_policy< cc::striped_set::striping<> > - ,co::resizing_policy > - , Options... - > - { - typedef cc::StripedSet< BucketEntry, - co::mutex_policy< cc::striped_set::striping<> > - ,co::resizing_policy > - , Options... - > base_class; - typedef typename base_class::resizing_policy resizing_policy_t; - - resizing_policy_t m_placeHolder; - public: - StripedHashSet_seq( size_t nCapacity, size_t nLoadFactor ) - : base_class( nCapacity / nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor )) ) - {} - - template - bool erase_with( Q const& v, Less /*pred*/ ) - { - return base_class::erase( v ); - } - }; - - // for non-sequential ordered containers - template - class StripedHashSet_ord: - public cc::StripedSet< BucketEntry, - co::resizing_policy > - ,co::mutex_policy< cc::striped_set::striping<> > - , Options... - > - { - typedef cc::StripedSet< BucketEntry, - co::resizing_policy > - ,co::mutex_policy< cc::striped_set::striping<> > - , Options... - > base_class; - typedef typename base_class::resizing_policy resizing_policy_t; - - resizing_policy_t m_placeHolder; - public: - StripedHashSet_ord( size_t /*nCapacity*/, size_t nLoadFactor ) - : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor * 1024 )) ) - {} - - template - bool erase_with( Q const& v, Less /*pred*/ ) - { - return base_class::erase( v ); - } - }; - - typedef StripedHashSet_seq< - std::list< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_list; - - typedef StripedHashSet_seq< - std::vector< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_vector; - -#if BOOST_VERSION >= 104800 - typedef StripedHashSet_seq< - boost::container::slist< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_boost_slist; - - typedef StripedHashSet_seq< - boost::container::list< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_boost_list; - - typedef StripedHashSet_seq< - boost::container::vector< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_boost_vector; - - typedef StripedHashSet_seq< - boost::container::stable_vector< key_val > - , co::hash< hash2 > - , co::less< less > - > StripedSet_boost_stable_vector; -#endif - - typedef StripedHashSet_ord< - std::set< key_val, less > - , co::hash< hash2 > - > StripedSet_set; - - typedef StripedHashSet_ord< - std::unordered_set< key_val, hash, equal_to > - , co::hash< hash2 > - > StripedSet_hashset; - -#if BOOST_VERSION >= 104800 - typedef StripedHashSet_ord< - boost::container::set< key_val, less > - , co::hash< hash2 > - > StripedSet_boost_set; - - typedef StripedHashSet_ord< - boost::container::flat_set< key_val, less > - , co::hash< hash2 > - > StripedSet_boost_flat_set; -#endif - - typedef StripedHashSet_ord< - boost::unordered_set< key_val, hash, equal_to > - , co::hash< hash2 > - > StripedSet_boost_unordered_set; - - - - // *************************************************************************** - // RefinableSet - - // for sequential containers - template - class RefinableHashSet_seq: - public cc::StripedSet< BucketEntry, - co::mutex_policy< cc::striped_set::refinable<> > - ,co::resizing_policy > - , Options... - > - { - typedef cc::StripedSet< BucketEntry, - co::mutex_policy< cc::striped_set::refinable<> > - ,co::resizing_policy > - , Options... - > base_class; - typedef typename base_class::resizing_policy resizing_policy_t; - - resizing_policy_t m_placeHolder; - public: - RefinableHashSet_seq( size_t nCapacity, size_t nLoadFactor ) - : base_class( nCapacity / nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor )) ) - {} - - template - bool erase_with( Q const& v, Less /*pred*/ ) - { - return base_class::erase( v ); - } - }; - - // for non-sequential ordered containers - template - class RefinableHashSet_ord: - public cc::StripedSet< BucketEntry, - co::resizing_policy > - ,co::mutex_policy< cc::striped_set::refinable<> > - , Options... - > - { - typedef cc::StripedSet< BucketEntry, - co::resizing_policy > - ,co::mutex_policy< cc::striped_set::refinable<> > - , Options... - > base_class; - typedef typename base_class::resizing_policy resizing_policy_t; - - resizing_policy_t m_placeHolder; - public: - RefinableHashSet_ord( size_t /*nCapacity*/, size_t nLoadFactor ) - : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( nLoadFactor * 1024 )) ) - {} - - template - bool erase_with( Q const& v, Less /*pred*/ ) - { - return base_class::erase( v ); - } - }; - - typedef RefinableHashSet_seq< - std::list< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_list; - - typedef RefinableHashSet_seq< - std::vector< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_vector; - -#if BOOST_VERSION >= 104800 - typedef RefinableHashSet_seq< - boost::container::slist< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_boost_slist; - - typedef RefinableHashSet_seq< - boost::container::list< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_boost_list; - - typedef RefinableHashSet_seq< - boost::container::vector< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_boost_vector; - - typedef RefinableHashSet_seq< - boost::container::stable_vector< key_val > - , co::hash< hash2 > - , co::less< less > - > RefinableSet_boost_stable_vector; -#endif - - typedef RefinableHashSet_ord< - std::set< key_val, less > - , co::hash< hash2 > - > RefinableSet_set; - - typedef RefinableHashSet_ord< - std::unordered_set< key_val, hash, equal_to > - , co::hash< hash2 > - > RefinableSet_hashset; - -#if BOOST_VERSION >= 104800 - typedef RefinableHashSet_ord< - boost::container::set< key_val, less > - , co::hash< hash2 > - > RefinableSet_boost_set; - - typedef RefinableHashSet_ord< - boost::container::flat_set< key_val, less > - , co::hash< hash2 > - > RefinableSet_boost_flat_set; -#endif - - typedef RefinableHashSet_ord< - boost::unordered_set< key_val, hash, equal_to > - , co::hash< hash2 > - > RefinableSet_boost_unordered_set; - - // *************************************************************************** - // CuckooSet - - template - struct traits_CuckooStripedSet : public Traits - { - typedef cc::cuckoo::striping<> mutex_policy; - }; - template - struct traits_CuckooRefinableSet : public Traits - { - typedef cc::cuckoo::refinable<> mutex_policy; - }; - - struct traits_CuckooSet_list_unord : - public cc::cuckoo::make_traits < - cc::cuckoo::probeset_type< cc::cuckoo::list > - , co::equal_to< equal_to > - , co::hash< std::tuple< hash, hash2 > > - > ::type - {}; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord; - - struct traits_CuckooSet_list_unord_stat : public traits_CuckooSet_list_unord - { - typedef cc::cuckoo::stat stat; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord_stat; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord_stat; - - struct traits_CuckooSet_list_unord_storehash : public traits_CuckooSet_list_unord - { - static CDS_CONSTEXPR const bool store_hash = true; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_unord_storehash; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_unord_storehash; - - struct traits_CuckooSet_list_ord : - public cc::cuckoo::make_traits < - cc::cuckoo::probeset_type< cc::cuckoo::list > - , co::compare< compare > - , co::hash< std::tuple< hash, hash2 > > - > ::type - {}; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord; - - struct traits_CuckooSet_list_ord_stat : public traits_CuckooSet_list_ord - { - typedef cc::cuckoo::stat stat; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord_stat; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord_stat; - - struct traits_CuckooSet_list_ord_storehash : public traits_CuckooSet_list_ord - { - static CDS_CONSTEXPR const bool store_hash = true; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_list_ord_storehash; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_list_ord_storehash; - - - struct traits_CuckooSet_vector_unord : - public cc::cuckoo::make_traits < - cc::cuckoo::probeset_type< cc::cuckoo::vector<4> > - , co::equal_to< equal_to > - , co::hash< std::tuple< hash, hash2 > > - > ::type - {}; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord; - - struct traits_CuckooSet_vector_unord_stat : public traits_CuckooSet_vector_unord - { - typedef cc::cuckoo::stat stat; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord_stat; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord_stat; - - struct traits_CuckooSet_vector_unord_storehash : public traits_CuckooSet_vector_unord - { - static CDS_CONSTEXPR const bool store_hash = true; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_unord_storehash; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_unord_storehash; - - struct traits_CuckooSet_vector_ord : - public cc::cuckoo::make_traits < - cc::cuckoo::probeset_type< cc::cuckoo::vector<4> > - , co::compare< compare > - , co::hash< std::tuple< hash, hash2 > > - > ::type - {}; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord; - - struct traits_CuckooSet_vector_ord_stat : public traits_CuckooSet_vector_ord - { - typedef cc::cuckoo::stat stat; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord_stat; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord_stat; - - struct traits_CuckooSet_vector_ord_storehash : public traits_CuckooSet_vector_ord - { - static CDS_CONSTEXPR const bool store_hash = true; - }; - typedef CuckooSet< key_val, traits_CuckooStripedSet> CuckooStripedSet_vector_ord_storehash; - typedef CuckooSet< key_val, traits_CuckooRefinableSet> CuckooRefinableSet_vector_ord_storehash; - - - // *************************************************************************** - // SkipListSet - - class traits_SkipListSet_less_pascal: public cc::skip_list::make_traits < - co::less< less > - ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > - ,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; -#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; -#endif - - class traits_SkipListSet_less_pascal_seqcst: public cc::skip_list::make_traits < - co::less< less > - ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > - ,co::memory_model< co::v::sequential_consistent > - ,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; -#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; -#endif - - class traits_SkipListSet_less_pascal_stat: public cc::skip_list::make_traits < - co::less< less > - ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > - ,co::stat< cc::skip_list::stat<> > - ,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; -#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; -#endif - - class traits_SkipListSet_cmp_pascal: public cc::skip_list::make_traits < - co::compare< compare > - ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > - ,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; -#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; -#endif - - class traits_SkipListSet_cmp_pascal_stat: public cc::skip_list::make_traits < - co::compare< compare > - ,cc::skip_list::random_level_generator< cc::skip_list::turbo_pascal > - ,co::stat< cc::skip_list::stat<> > - ,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; -#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; -#endif - - class traits_SkipListSet_less_xorshift: public cc::skip_list::make_traits < - co::less< less > - ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > - ,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; -#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; -#endif - - class traits_SkipListSet_less_xorshift_stat: public cc::skip_list::make_traits < - co::less< less > - ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > - ,co::stat< cc::skip_list::stat<> > - ,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; -#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; -#endif - - class traits_SkipListSet_cmp_xorshift: public cc::skip_list::make_traits < - co::compare< compare > - ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > - ,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; -#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; -#endif - - class traits_SkipListSet_cmp_xorshift_stat: public cc::skip_list::make_traits < - co::compare< compare > - ,cc::skip_list::random_level_generator< cc::skip_list::xorshift > - ,co::stat< cc::skip_list::stat<> > - ,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; -#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; -#endif - - - // *************************************************************************** - // EllenBinTreeSet - struct ellen_bintree_props { - struct key_extractor { - void operator()( key_type& dest, key_val const& src ) const - { - dest = src.key; - } - }; - - struct less { - bool operator()( key_val const& v1, key_val const& v2 ) const - { - return key_less()( v1.key, v2.key ); - } - bool operator()( key_type const& k, key_val const& v ) const - { - return key_less()( k, v.key ); - } - bool operator()( key_val const& v, key_type const& k ) const - { - return key_less()( v.key, k ); - } - bool operator()( key_type const& k1, key_type const& k2 ) const - { - return key_less()( k1, k2 ); - } - }; - - struct hp_gc { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; - - struct dhp_gc { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; - - struct gpi { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; - struct gpb { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; - struct gpt { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; -#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED - struct shb { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; - struct sht { - typedef cc::ellen_bintree::node leaf_node; - typedef cc::ellen_bintree::internal_node< key_type, leaf_node > internal_node; - typedef cc::ellen_bintree::update_desc< leaf_node, internal_node > update_desc; - }; -#endif - }; - - struct traits_EllenBinTreeSet: public cc::ellen_bintree::make_set_traits< - cc::ellen_bintree::key_extractor< typename ellen_bintree_props::key_extractor > - ,co::less< typename ellen_bintree_props::less > - ,co::node_allocator< ellen_bintree_pool::internal_node_allocator< int > > - >::type - {}; - - struct traits_EllenBinTreeSet_hp : public traits_EllenBinTreeSet - { - 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; - - 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; - - 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; - - 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; - - 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; - -#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; - - 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; -#endif - - // - struct traits_EllenBinTreeSet_yield : public traits_EllenBinTreeSet - { - typedef cds::backoff::yield back_off; - }; - - struct traits_EllenBinTreeSet_yield_hp : public traits_EllenBinTreeSet_yield - { - 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; - - 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; - - - 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; - - - struct traits_EllenBinTreeSet_stat: public cc::ellen_bintree::make_set_traits< - cc::ellen_bintree::key_extractor< typename ellen_bintree_props::key_extractor > - ,co::less< typename ellen_bintree_props::less > - ,co::node_allocator< ellen_bintree_pool::internal_node_allocator< int > > - ,co::stat< cc::ellen_bintree::stat<> > - >::type - {}; - - struct traits_EllenBinTreeSet_stat_hp : public traits_EllenBinTreeSet_stat - { - 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; - - 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; - - 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; - - 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; - - 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; - -#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; - - 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; -#endif - - // *************************************************************************** - // Standard implementations - - typedef StdSet< key_val, less, cds::sync::spin > StdSet_Spin; - typedef StdSet< key_val, less, lock::NoLock> StdSet_NoLock; - - typedef StdHashSet< key_val, hash, less, equal_to, cds::sync::spin > StdHashSet_Spin; - typedef StdHashSet< key_val, hash, less, equal_to, lock::NoLock > StdHashSet_NoLock; - - }; - - - // ************************************************* - // print_stat - // ************************************************* - - template - static inline void print_stat( Set const& /*s*/ ) - {} - - template - static inline void print_stat( cc::SplitListSet const& s ) - { - CPPUNIT_MSG( s.statistics() ); - } - - template - static inline void print_stat( cc::SkipListSet const& s ) - { - CPPUNIT_MSG( s.statistics() ); - } - - template - static inline void print_stat( cc::EllenBinTreeSet const& s ) - { - CPPUNIT_MSG( s.statistics() ); - } - - template - static inline void print_stat( cc::CuckooSet< T, Traits > const& s ) - { - CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() ); - } - - template - static inline void print_stat( CuckooSet< V, Traits > const& s ) - { - typedef CuckooSet< V, Traits > set_type; - print_stat( static_cast(s) ); - } - - - //******************************************************* - // additional_check - //******************************************************* - - template - static inline void additional_check( Set& /*set*/ ) - {} - - template - static inline void additional_cleanup( Set& /*set*/ ) - {} - - namespace ellen_bintree_check { - static inline void check_stat( cds::intrusive::ellen_bintree::empty_stat const& /*s*/ ) - { - // Not true for threaded RCU - /* - CPPUNIT_CHECK_CURRENT_EX( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == ellen_bintree_pool::internal_node_counter::m_nFree.get(), - "m_nAlloc=" << ellen_bintree_pool::internal_node_counter::m_nAlloc.get() - << ", m_nFree=" << ellen_bintree_pool::internal_node_counter::m_nFree.get() - ); - */ - } - - static inline void check_stat( cds::intrusive::ellen_bintree::stat<> const& stat ) - { - CPPUNIT_CHECK_CURRENT( stat.m_nInternalNodeCreated == stat.m_nInternalNodeDeleted ); - CPPUNIT_CHECK_CURRENT( stat.m_nUpdateDescCreated == stat.m_nUpdateDescDeleted ); - //CPPUNIT_CHECK_CURRENT( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == ellen_bintree_pool::internal_node_counter::m_nFree.get() ); - CPPUNIT_CHECK_CURRENT( ellen_bintree_pool::internal_node_counter::m_nAlloc.get() == stat.m_nInternalNodeCreated ); - // true if RCU is not threaded - //CPPUNIT_CHECK_CURRENT( stat.m_nInternalNodeDeleted == ellen_bintree_pool::internal_node_counter::m_nFree.get() ); - } - } // namespace ellen_bintree_check - - template - static inline void additional_check( cc::EllenBinTreeSet& s ) - { - GC::force_dispose(); - ellen_bintree_check::check_stat( s.statistics() ); - } - - template - static inline void additional_cleanup( cc::EllenBinTreeSet& /*s*/ ) - { - ellen_bintree_pool::internal_node_counter::reset(); - } - - //******************************************************* - // check_before_clear - //******************************************************* - - template - static inline void check_before_clear( Set& /*s*/ ) - {} - - template - static inline void check_before_clear( cds::container::EllenBinTreeSet& s ) - { - CPPUNIT_CHECK_CURRENT( s.check_consistency() ); - } - -} // namespace set2 - -#endif // ifndef CDSUNIT_SET_TYPES_H diff --git a/tests/unit/set2/std_hash_set.h b/tests/unit/set2/std_hash_set.h deleted file mode 100644 index 5338c13f..00000000 --- a/tests/unit/set2/std_hash_set.h +++ /dev/null @@ -1,102 +0,0 @@ -//$$CDS-header$$ - -#ifndef CDSUNIT_STD_HASH_SET_H -#define CDSUNIT_STD_HASH_SET_H - -#include -#include //unique_lock - -namespace set2 { - - template ::other - > - class StdHashSet - : public std::unordered_set< - Value - , Hash - , EqualTo - , Alloc - > - { - public: - Lock m_lock; - typedef std::unique_lock scoped_lock; - typedef std::unordered_set< - Value - , Hash - , EqualTo - , Alloc - > base_class; - public: - typedef typename base_class::value_type value_type; - - StdHashSet( size_t /*nSetSize*/, size_t /*nLoadFactor*/ ) - {} - - template - bool find( const Key& key ) - { - scoped_lock al( m_lock ); - return base_class::find( value_type(key) ) != base_class::end(); - } - - template - bool insert( Key const& key ) - { - scoped_lock al( m_lock ); - std::pair pRet = base_class::insert( value_type( key )); - return pRet.second; - } - - template - bool insert( Key const& key, Func func ) - { - scoped_lock al( m_lock ); - std::pair pRet = base_class::insert( value_type( key )); - if ( pRet.second ) { - func( *pRet.first ); - return true; - } - return false; - } - - template - std::pair ensure( const T& key, Func func ) - { - scoped_lock al( m_lock ); - std::pair pRet = base_class::insert( value_type( key )); - if ( pRet.second ) { - func( true, *pRet.first, key ); - return std::make_pair( true, true ); - } - else { - func( false, *pRet.first, key ); - return std::make_pair( true, false ); - } - } - - template - bool erase( const Key& key ) - { - scoped_lock al( m_lock ); - return base_class::erase( value_type(key) ) != 0; - } - - template - bool erase( const T& key, Func func ) - { - scoped_lock al( m_lock ); - typename base_class::iterator it = base_class::find( value_type(key) ); - if ( it != base_class::end() ) { - func( *it ); - return base_class::erase( it ) != base_class::end(); - } - return false; - } - - std::ostream& dump( std::ostream& stm ) { return stm; } - }; -} // namespace set2 - -#endif // #ifndef CDSUNIT_STD_HASH_SET_H diff --git a/tests/unit/set2/std_set.h b/tests/unit/set2/std_set.h deleted file mode 100644 index 3ad196e8..00000000 --- a/tests/unit/set2/std_set.h +++ /dev/null @@ -1,90 +0,0 @@ -//$$CDS-header$$ - -#ifndef CDSUNIT_STD_SET_H -#define CDSUNIT_STD_SET_H - -#include -#include //unique_lock - -namespace set2 { - template ::other - > - class StdSet: public std::set - { - Lock m_lock; - typedef std::unique_lock scoped_lock; - typedef std::set base_class; - public: - typedef typename base_class::key_type value_type; - - StdSet( size_t /*nMapSize*/, size_t /*nLoadFactor*/ ) - {} - - template - bool find( const Key& key ) - { - value_type v( key ); - scoped_lock al( m_lock ); - return base_class::find( v ) != base_class::end(); - } - - bool insert( value_type const& v ) - { - scoped_lock al( m_lock ); - return base_class::insert( v ).second; - } - - template - bool insert( Key const& key, Func func ) - { - scoped_lock al( m_lock ); - std::pair pRet = base_class::insert( value_type( key )); - if ( pRet.second ) { - func( *pRet.first ); - return true; - } - return false; - } - - template - std::pair ensure( const T& key, Func func ) - { - scoped_lock al( m_lock ); - std::pair pRet = base_class::insert( value_type( key )); - if ( pRet.second ) { - func( true, *pRet.first, key ); - return std::make_pair( true, true ); - } - else { - func( false, *pRet.first, key ); - return std::make_pair( true, false ); - } - } - - template - bool erase( const Key& key ) - { - scoped_lock al( m_lock ); - return base_class::erase( value_type(key) ) != 0; - } - - template - bool erase( const T& key, Func func ) - { - scoped_lock al( m_lock ); - typename base_class::iterator it = base_class::find( value_type(key) ); - if ( it != base_class::end() ) { - func( *it ); - - base_class::erase( it ); - return true; - } - return false; - } - - std::ostream& dump( std::ostream& stm ) { return stm; } - }; -} // namespace set2 - -#endif // #ifndef CDSUNIT_STD_MAP_H -- 2.34.1