/// 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;
{
return base_class::mutex_policy_statistics();
}
-
};
}} // namespace cds::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;
{
return base_class::mutex_policy_statistics();
}
-
};
}} // namespace cds::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
/** @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
/** @ingroup cds_nonintrusive_helper
*/
namespace michael_map {
+ using cds::intrusive::michael_set::implementation_tag;
+
/// \p MichaelHashMap traits
typedef container::michael_set::traits traits;
/** @ingroup cds_nonintrusive_helper
*/
namespace michael_set {
+ using cds::intrusive::michael_set::implementation_tag;
/// MichaelHashSet traits
typedef cds::intrusive::michael_set::traits traits;
/** @ingroup cds_nonintrusive_helper
*/
namespace skip_list {
+ using cds::intrusive::skip_list::implementation_tag;
/// Option specifying random level generator
template <typename Type>
/** @ingroup cds_nonintrusive_helper
*/
namespace split_list {
+ using cds::intrusive::split_list::implementation_tag;
+
/// Internal statistics, see \p cds::intrusive::split_list::stat
template <typename Counter = cds::intrusive::split_list::stat<>::counter_type >
using stat = cds::intrusive::split_list::stat<Counter>;
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;
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;
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;
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;
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;
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;
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
/// 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;
/// 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
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
/// 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;
/// 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
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;
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;
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;
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;
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;
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;
/// 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;
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;
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;
#include <cds/intrusive/split_list_rcu.h>
#include <cds/container/details/make_split_list_set.h>
+#include <cds/urcu/exempt_ptr.h>
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;
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;
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;
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
/// CuckooSet-related definitions
namespace cuckoo {
+ //@cond
+ struct implementation_tag;
+ //@endcond
/// Option to define probeset type
/**
/// 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;
/// EllenBinTree related declarations
namespace ellen_bintree {
+ struct implementation_tag;
//Forwards
template <class GC> struct base_node;
*/
namespace michael_set {
+ //@cond
+ struct implementation_tag;
+ //@endcond
+
/// MichaelHashSet traits
struct traits {
/// Hash function
};
}
//@endcond
- }
+ } // namespace michael_set
//@cond
// Forward declarations
/** @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;
/** @ingroup cds_intrusive_helper
*/
namespace split_list {
+ //@cond
+ struct implementation_tag;
+ //@endcond
+
/// Split-ordered list node
/**
Template parameter:
}
//@endcond
- } // namespace split_list
+ } // namespace split_list
//@cond
// Forward declaration
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
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
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
/// 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
/// 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
/// 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
//@cond
static unsigned int const c_nMinHeight = 3;
+ typedef cds::intrusive::skip_list::implementation_tag implementation_tag;
//@endcond
protected:
//@cond
static unsigned int const c_nMinHeight = 5;
+ typedef cds::intrusive::skip_list::implementation_tag implementation_tag;
//@endcond
protected:
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<OrderedList, traits> wrapped_ordered_list;
/// 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<OrderedList, traits> wrapped_ordered_list;
/// 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<OrderedList, traits> wrapped_ordered_list;
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.
/// StripedSet related definitions
namespace striped_set {
+ //@cond
+ struct implementation_tag;
+ //@endcond
/// Default adapter for intrusive striped/refinable hash set
/**
..\..\..\tests\unit\print_skip_list_stat.h = ..\..\..\tests\unit\print_skip_list_stat.h\r
..\..\..\tests\unit\print_split_list_stat.h = ..\..\..\tests\unit\print_split_list_stat.h\r
..\..\..\tests\unit\print_sync_monitor_stat.h = ..\..\..\tests\unit\print_sync_monitor_stat.h\r
+ ..\..\..\tests\unit\set2\set_type_cuckoo.h = ..\..\..\tests\unit\set2\set_type_cuckoo.h\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unit-prerequisites", "unit-prerequisites.vcxproj", "{61179F2F-07E1-490D-B64D-D85A90B6EF81}"\r
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "set", "set", "{A64449B7-90FB-4E2B-A686-9EFC0E298644}"\r
ProjectSection(SolutionItems) = preProject\r
..\..\..\tests\unit\set2\set_defs.h = ..\..\..\tests\unit\set2\set_defs.h\r
- ..\..\..\tests\unit\set2\set_types.h = ..\..\..\tests\unit\set2\set_types.h\r
- ..\..\..\tests\unit\set2\std_hash_set.h = ..\..\..\tests\unit\set2\std_hash_set.h\r
- ..\..\..\tests\unit\set2\std_set.h = ..\..\..\tests\unit\set2\std_set.h\r
+ ..\..\..\tests\unit\set2\set_type.h = ..\..\..\tests\unit\set2\set_type.h\r
+ ..\..\..\tests\unit\set2\set_type_cuckoo.h = ..\..\..\tests\unit\set2\set_type_cuckoo.h\r
+ ..\..\..\tests\unit\set2\set_type_ellen_bintree.h = ..\..\..\tests\unit\set2\set_type_ellen_bintree.h\r
+ ..\..\..\tests\unit\set2\set_type_lazy_list.h = ..\..\..\tests\unit\set2\set_type_lazy_list.h\r
+ ..\..\..\tests\unit\set2\set_type_michael.h = ..\..\..\tests\unit\set2\set_type_michael.h\r
+ ..\..\..\tests\unit\set2\set_type_michael_list.h = ..\..\..\tests\unit\set2\set_type_michael_list.h\r
+ ..\..\..\tests\unit\set2\set_type_skip_list.h = ..\..\..\tests\unit\set2\set_type_skip_list.h\r
+ ..\..\..\tests\unit\set2\set_type_split_list.h = ..\..\..\tests\unit\set2\set_type_split_list.h\r
+ ..\..\..\tests\unit\set2\set_type_std.h = ..\..\..\tests\unit\set2\set_type_std.h\r
+ ..\..\..\tests\unit\set2\set_type_striped.h = ..\..\..\tests\unit\set2\set_type_striped.h\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unit-map-delodd", "unit-map-delodd.vcxproj", "{3C598F96-FB84-4D42-9B43-F697F53B0221}"\r
#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
#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) \
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) \
#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)\
#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)\
#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 \
#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)\
#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)\
#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)\
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)\
#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) \
#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) \
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
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 \
#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) \
#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) \
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
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 \
//$$CDS-header$$
#include "cppunit/thread.h"
-#include "set2/set_types.h"
+#include "set2/set_type.h"
#include <algorithm> // random_shuffle
namespace set2 {
-# define TEST_SET(X) void X() { test<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_EXTRACT(X) void X() { test_extract<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_NOLF(X) void X() { test_nolf<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_NOLF_EXTRACT(X) void X() { test_nolf_extract<SetTypes<key_type, value_type>::X >() ; }
+# define TEST_SET(IMPL, C, X) void C::X() { test<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_EXTRACT(IMPL, C, X) void C::X() { test_extract<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) void C::X() { test_nolf_extract<set_type<IMPL, key_type, value_type>::X >(); }
namespace {
struct key_thread
{}
};
- typedef SetTypes<key_thread, size_t>::key_val key_value_pair;
+ typedef set_type_base<key_thread, size_t>::key_val key_value_pair;
}
template <>
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$CDS-header$$
#include "set2/set_insdel_func.h"
+#include "set2/set_type_michael.h"
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
#include <vector>
#include <mutex> //unique_lock
-#include "set2/set_types.h"
+#include "set2/set_type.h"
#include "cppunit/thread.h"
-
#include <cds/sync/spinlock.h>
namespace set2 {
-# define TEST_SET(X) void X() { test<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_EXTRACT(X) TEST_SET(X)
-# define TEST_SET_NOLF(X) void X() { test_nolf<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_NOLF_EXTRACT(X) TEST_SET_NOLF(X)
+# define TEST_SET(IMPL, C, X) void C::X() { test<set_type<IMPL, key_type, value_type>::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<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) TEST_SET_NOLF(IMPL, C, X)
class Set_InsDel_func: public CppUnitMini::TestCase
{
//$$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()
//$$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()
//$$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()
//$$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
//$$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()
//$$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
//$$CDS-header$$
-#include "set2/set_types.h"
+#include "set2/set_type.h"
#include "cppunit/thread.h"
#include <vector>
namespace set2 {
-# define TEST_SET(X) void X() { test<SetTypes<key_type, value_type>::X >(); }
-# define TEST_SET_EXTRACT(X) void X() { test_extract<SetTypes<key_type, value_type>::X >(); }
-# define TEST_SET_NOLF(X) void X() { test_nolf<SetTypes<key_type, value_type>::X >(); }
-# define TEST_SET_NOLF_EXTRACT(X) void X() { test_nolf_extract<SetTypes<key_type, value_type>::X >(); }
+# define TEST_SET(IMPL, C, X) void C::X() { test<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_EXTRACT(IMPL, C, X) void C::X() { test_extract<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf<set_type<IMPL, key_type, value_type>::X >(); }
+# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) void C::X() { test_nolf_extract<set_type<IMPL, key_type, value_type>::X >(); }
class Set_InsDel_string: public CppUnitMini::TestCase
{
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
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
//$$CDS-header$$
-#include "set2/set_types.h"
+#include "set2/set_type.h"
#include "cppunit/thread.h"
#include <algorithm> // random_shuffle
namespace set2 {
-# define TEST_SET(X) void X() { test<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_EXTRACT(X) TEST_SET(X)
-# define TEST_SET_NOLF(X) void X() { test_nolf<SetTypes<key_type, value_type>::X >() ; }
-# define TEST_SET_NOLF_EXTRACT(X) TEST_SET_NOLF(X)
+# define TEST_SET(IMPL, C, X) void C::X() { test<set_type<IMPL, key_type, value_type>::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<set_type<IMPL, key_type, value_type>::X >() ; }
+# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) TEST_SET_NOLF(IMPL, C, X)
class Set_InsDelFind: public CppUnitMini::TestCase
{
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
//$$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()
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_H
+#define CDSUNIT_SET_TYPE_H
+
+#include <cds/urcu/general_instant.h>
+#include <cds/urcu/general_buffered.h>
+#include <cds/urcu/general_threaded.h>
+#include <cds/urcu/signal_buffered.h>
+#include <cds/urcu/signal_threaded.h>
+
+#include <cds/opt/hash.h>
+#include <cds/sync/spinlock.h>
+#include <boost/functional/hash/hash.hpp>
+
+#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 <typename Key>
+ struct cmp {
+ int operator ()(Key const& k1, Key const& k2) const
+ {
+ if ( std::less<Key>( k1, k2 ) )
+ return -1;
+ return std::less<Key>( k2, k1 ) ? 1 : 0;
+ }
+ };
+
+#define CDSUNIT_INT_COMPARE(t) template <> struct cmp<t> { 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<std::string>
+ {
+ 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 <typename ImplSelector, typename Key, typename Value>
+ struct set_type;
+
+ template <typename Key, typename Value>
+ 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 <typename K>
+ /*explicit*/ key_val( K const& k ): key(k) {}
+
+ template <typename K, typename T>
+ key_val( K const& k, T const& v ): key(k), val(v) {}
+ };
+
+ typedef co::v::hash<key_type> key_hash;
+ typedef std::less<key_type> key_less;
+ typedef cmp<key_type> 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 <typename Q>
+ 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 <typename Q>
+ size_t operator()( Q const& k ) const
+ {
+ return key_hash::operator()( k );
+ }
+ };
+ };
+
+
+ // *************************************************
+ // print_stat
+ // *************************************************
+
+ template <typename Set>
+ static inline void print_stat( Set const& /*s*/ )
+ {}
+
+
+ //*******************************************************
+ // additional_check
+ //*******************************************************
+
+ template <typename Set>
+ static inline void additional_check( Set& /*set*/ )
+ {}
+
+ template <typename Set>
+ static inline void additional_cleanup( Set& /*set*/ )
+ {}
+
+ //*******************************************************
+ // check_before_clear
+ //*******************************************************
+
+ template <typename Set>
+ static inline void check_before_clear( Set& /*s*/ )
+ {}
+
+} // namespace set2
+
+#endif // ifndef CDSUNIT_SET_TYPE_H
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_CUCKOO_H
+#define CDSUNIT_SET_TYPE_CUCKOO_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/cuckoo_set.h>
+#include "print_cuckoo_stat.h"
+
+namespace set2 {
+
+ template <typename V, typename Traits>
+ 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 <typename Q, typename Pred>
+ 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 <typename Key, typename Val>
+ 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 <typename Traits>
+ struct traits_CuckooStripedSet : public Traits
+ {
+ typedef cc::cuckoo::striping<> mutex_policy;
+ };
+ template <typename Traits>
+ 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<traits_CuckooSet_list_unord>> CuckooStripedSet_list_unord;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord>> 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<traits_CuckooSet_list_unord_stat>> CuckooStripedSet_list_unord_stat;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord_stat>> 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<traits_CuckooSet_list_unord_storehash>> CuckooStripedSet_list_unord_storehash;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord_storehash>> 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<traits_CuckooSet_list_ord>> CuckooStripedSet_list_ord;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord>> 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<traits_CuckooSet_list_ord_stat>> CuckooStripedSet_list_ord_stat;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord_stat>> 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<traits_CuckooSet_list_ord_storehash>> CuckooStripedSet_list_ord_storehash;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord_storehash>> 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<traits_CuckooSet_vector_unord>> CuckooStripedSet_vector_unord;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord>> 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<traits_CuckooSet_vector_unord_stat>> CuckooStripedSet_vector_unord_stat;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord_stat>> 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<traits_CuckooSet_vector_unord_storehash>> CuckooStripedSet_vector_unord_storehash;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord_storehash>> 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<traits_CuckooSet_vector_ord>> CuckooStripedSet_vector_ord;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord>> 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<traits_CuckooSet_vector_ord_stat>> CuckooStripedSet_vector_ord_stat;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord_stat>> 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<traits_CuckooSet_vector_ord_storehash>> CuckooStripedSet_vector_ord_storehash;
+ typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord_storehash>> CuckooRefinableSet_vector_ord_storehash;
+
+ };
+
+ template <typename T, typename Traits >
+ static inline void print_stat( cc::CuckooSet< T, Traits > const& s )
+ {
+ CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() );
+ }
+
+ template <typename V, typename Traits>
+ static inline void print_stat( CuckooSet< V, Traits > const& s )
+ {
+ typedef CuckooSet< V, Traits > set_type;
+ print_stat( static_cast<typename set_type::cuckoo_base_class const&>(s) );
+ }
+
+} // namespace set2
+
+#endif // #ifndef CDSUNIT_SET_TYPE_CUCKOO_H
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_ELLEN_BINTREE_H
+#define CDSUNIT_SET_TYPE_ELLEN_BINTREE_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/ellen_bintree_set_rcu.h>
+#include <cds/container/ellen_bintree_set_hp.h>
+#include <cds/container/ellen_bintree_set_dhp.h>
+
+#include "print_ellenbintree_stat.h"
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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<cds::gc::HP, key_val> 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<cds::gc::DHP, key_val> 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<rcu_gpi, key_val> 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<rcu_gpb, key_val> 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<rcu_gpt, key_val> 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<rcu_shb, key_val> 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<rcu_sht, key_val> 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 <typename GC, typename Key, typename T, typename Traits>
+ static inline void print_stat( cc::EllenBinTreeSet<GC, Key, T, Traits> 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 <typename GC, typename Key, typename T, typename Traits>
+ static inline void additional_check( cc::EllenBinTreeSet<GC, Key, T, Traits>& s )
+ {
+ GC::force_dispose();
+ ellen_bintree_check::check_stat( s.statistics() );
+ }
+
+ template <typename GC, typename Key, typename T, typename Traits>
+ static inline void additional_cleanup( cc::EllenBinTreeSet<GC, Key, T, Traits>& /*s*/ )
+ {
+ ellen_bintree_pool::internal_node_counter::reset();
+ }
+
+ template <typename GC, typename Key, typename T, typename Traits>
+ static inline void check_before_clear( cds::container::EllenBinTreeSet<GC, Key, T, Traits>& s )
+ {
+ CPPUNIT_CHECK_CURRENT( s.check_consistency() );
+ }
+
+
+} // namespace set2
+
+#endif // #ifndef CDSUNIT_SET_TYPE_ELLEN_BINTREE_H
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_LAZY_LIST_H
+#define CDSUNIT_SET_TYPE_LAZY_LIST_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/lazy_list_hp.h>
+#include <cds/container/lazy_list_dhp.h>
+#include <cds/container/lazy_list_rcu.h>
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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<int> >
+ >::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<int> >
+ >::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
--- /dev/null
+//$$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 <cds/container/michael_set.h>
+#include <cds/container/michael_set_rcu.h>
+
+#include "michael_alloc.h"
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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<int> >
+ >::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
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_MICHAEL_LIST_H
+#define CDSUNIT_SET_TYPE_MICHAEL_LIST_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/michael_list_hp.h>
+#include <cds/container/michael_list_dhp.h>
+#include <cds/container/michael_list_rcu.h>
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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<int> >
+ >::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<int> >
+ >::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
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_SKIP_LIST_H
+#define CDSUNIT_SET_TYPE_SKIP_LIST_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/skip_list_set_hp.h>
+#include <cds/container/skip_list_set_dhp.h>
+#include <cds/container/skip_list_set_rcu.h>
+
+#include "print_skip_list_stat.h"
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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 <typename GC, typename T, typename Traits>
+ static inline void print_stat( cc::SkipListSet<GC, T, Traits> const& s )
+ {
+ CPPUNIT_MSG( s.statistics() );
+ }
+
+} // namespace set2
+
+#endif // #ifndef CDSUNIT_SET_TYPE_SKIP_LIST_H
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H
+#define CDSUNIT_SET_TYPE_SPLIT_LIST_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/michael_list_hp.h>
+#include <cds/container/michael_list_dhp.h>
+#include <cds/container/michael_list_rcu.h>
+#include <cds/container/lazy_list_hp.h>
+#include <cds/container/lazy_list_dhp.h>
+#include <cds/container/lazy_list_rcu.h>
+
+#include <cds/container/split_list_set.h>
+#include <cds/container/split_list_set_rcu.h>
+
+#include "print_split_list_stat.h"
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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<cc::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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::michael_list_tag>
+ ,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::michael_list_tag>
+ ,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<cc::michael_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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::lazy_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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::lazy_list_tag>
+ ,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<cc::lazy_list_tag>
+ ,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 <typename GC, typename T, typename Traits>
+ static inline void print_stat( cc::SplitListSet<GC, T, Traits> const& s )
+ {
+ CPPUNIT_MSG( s.statistics() );
+ }
+
+} // namespace set2
+
+#endif // #ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_STD_H
+#define CDSUNIT_SET_TYPE_STD_H
+
+#include <unordered_set>
+#include <set>
+#include <mutex> //unique_lock
+
+#include "set2/set_type.h"
+
+namespace set2 {
+
+ struct std_implementation_tag;
+
+ template <typename Value, typename Hash, typename Less, typename EqualTo, typename Lock,
+ class Alloc = typename CDS_DEFAULT_ALLOCATOR::template rebind<Value>::other
+ >
+ class StdHashSet
+ : public std::unordered_set<
+ Value
+ , Hash
+ , EqualTo
+ , Alloc
+ >
+ {
+ public:
+ Lock m_lock;
+ typedef std::unique_lock<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 <typename Key>
+ bool find( const Key& key )
+ {
+ scoped_lock al( m_lock );
+ return base_class::find( value_type(key) ) != base_class::end();
+ }
+
+ template <typename Key>
+ bool insert( Key const& key )
+ {
+ scoped_lock al( m_lock );
+ std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
+ return pRet.second;
+ }
+
+ template <typename Key, typename Func>
+ bool insert( Key const& key, Func func )
+ {
+ scoped_lock al( m_lock );
+ std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
+ if ( pRet.second ) {
+ func( *pRet.first );
+ return true;
+ }
+ return false;
+ }
+
+ template <typename T, typename Func>
+ std::pair<bool, bool> ensure( const T& key, Func func )
+ {
+ scoped_lock al( m_lock );
+ std::pair<typename base_class::iterator, bool> 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 <typename Key>
+ bool erase( const Key& key )
+ {
+ scoped_lock al( m_lock );
+ return base_class::erase( value_type(key) ) != 0;
+ }
+
+ template <typename T, typename Func>
+ 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 <typename Value, typename Less, typename Lock,
+ class Alloc = typename CDS_DEFAULT_ALLOCATOR::template rebind<Value>::other
+ >
+ class StdSet: public std::set<Value, Less, Alloc>
+ {
+ Lock m_lock;
+ typedef std::unique_lock<Lock> scoped_lock;
+ typedef std::set<Value, Less, Alloc> 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 <typename Key>
+ 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 <typename Key, typename Func>
+ bool insert( Key const& key, Func func )
+ {
+ scoped_lock al( m_lock );
+ std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
+ if ( pRet.second ) {
+ func( *pRet.first );
+ return true;
+ }
+ return false;
+ }
+
+ template <typename T, typename Func>
+ std::pair<bool, bool> ensure( const T& key, Func func )
+ {
+ scoped_lock al( m_lock );
+ std::pair<typename base_class::iterator, bool> 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 <typename Key>
+ bool erase( const Key& key )
+ {
+ scoped_lock al( m_lock );
+ return base_class::erase( value_type(key) ) != 0;
+ }
+
+ template <typename T, typename Func>
+ 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 <typename Key, typename Val>
+ 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
--- /dev/null
+//$$CDS-header$$
+
+#ifndef CDSUNIT_SET_TYPE_STRIPED_H
+#define CDSUNIT_SET_TYPE_STRIPED_H
+
+#include "set2/set_type.h"
+
+#include <cds/container/striped_set/std_list.h>
+#include <cds/container/striped_set/std_vector.h>
+#include <cds/container/striped_set/std_set.h>
+#include <cds/container/striped_set/std_hash_set.h>
+#include <cds/container/striped_set/boost_unordered_set.h>
+
+#include <boost/version.hpp>
+#if BOOST_VERSION >= 104800
+# include <cds/container/striped_set/boost_slist.h>
+# include <cds/container/striped_set/boost_list.h>
+# include <cds/container/striped_set/boost_vector.h>
+# include <cds/container/striped_set/boost_stable_vector.h>
+# include <cds/container/striped_set/boost_set.h>
+# include <cds/container/striped_set/boost_flat_set.h>
+#endif
+#include <cds/container/striped_set.h>
+
+namespace set2 {
+
+ template <typename Key, typename Val>
+ 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 BucketEntry, typename... Options>
+ class StripedHashSet_seq:
+ public cc::StripedSet< BucketEntry,
+ co::mutex_policy< cc::striped_set::striping<> >
+ ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ , Options...
+ >
+ {
+ typedef cc::StripedSet< BucketEntry,
+ co::mutex_policy< cc::striped_set::striping<> >
+ ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ , 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 <typename Q, typename Less>
+ bool erase_with( Q const& v, Less /*pred*/ )
+ {
+ return base_class::erase( v );
+ }
+ };
+
+ // for non-sequential ordered containers
+ template <class BucketEntry, typename... Options>
+ class StripedHashSet_ord:
+ public cc::StripedSet< BucketEntry,
+ co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ ,co::mutex_policy< cc::striped_set::striping<> >
+ , Options...
+ >
+ {
+ typedef cc::StripedSet< BucketEntry,
+ co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ ,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 <typename Q, typename Less>
+ 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 BucketEntry, typename... Options>
+ class RefinableHashSet_seq:
+ public cc::StripedSet< BucketEntry,
+ co::mutex_policy< cc::striped_set::refinable<> >
+ ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ , Options...
+ >
+ {
+ typedef cc::StripedSet< BucketEntry,
+ co::mutex_policy< cc::striped_set::refinable<> >
+ ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ , 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 <typename Q, typename Less>
+ bool erase_with( Q const& v, Less /*pred*/ )
+ {
+ return base_class::erase( v );
+ }
+ };
+
+ // for non-sequential ordered containers
+ template <class BucketEntry, typename... Options>
+ class RefinableHashSet_ord:
+ public cc::StripedSet< BucketEntry,
+ co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ ,co::mutex_policy< cc::striped_set::refinable<> >
+ , Options...
+ >
+ {
+ typedef cc::StripedSet< BucketEntry,
+ co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
+ ,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 <typename Q, typename Less>
+ 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
+++ /dev/null
-//$$CDS-header$$
-
-#ifndef CDSUNIT_SET_TYPES_H
-#define CDSUNIT_SET_TYPES_H
-
-#include <cds/urcu/general_instant.h>
-#include <cds/urcu/general_buffered.h>
-#include <cds/urcu/general_threaded.h>
-#include <cds/urcu/signal_buffered.h>
-#include <cds/urcu/signal_threaded.h>
-
-#include <cds/container/michael_list_hp.h>
-#include <cds/container/michael_list_dhp.h>
-#include <cds/container/michael_list_rcu.h>
-#include <cds/container/lazy_list_hp.h>
-#include <cds/container/lazy_list_dhp.h>
-#include <cds/container/lazy_list_rcu.h>
-
-#include <cds/container/michael_set.h>
-#include <cds/container/michael_set_rcu.h>
-
-#include <cds/container/split_list_set.h>
-#include <cds/container/split_list_set_rcu.h>
-
-#include <cds/container/cuckoo_set.h>
-
-#include <cds/container/skip_list_set_hp.h>
-#include <cds/container/skip_list_set_dhp.h>
-#include <cds/container/skip_list_set_rcu.h>
-
-#include <cds/container/ellen_bintree_set_rcu.h>
-#include <cds/container/ellen_bintree_set_hp.h>
-#include <cds/container/ellen_bintree_set_dhp.h>
-
-#include <cds/container/striped_set/std_list.h>
-#include <cds/container/striped_set/std_vector.h>
-#include <cds/container/striped_set/std_set.h>
-#include <cds/container/striped_set/std_hash_set.h>
-#include <cds/container/striped_set/boost_unordered_set.h>
-
-#include <boost/version.hpp>
-#if BOOST_VERSION >= 104800
-# include <cds/container/striped_set/boost_slist.h>
-# include <cds/container/striped_set/boost_list.h>
-# include <cds/container/striped_set/boost_vector.h>
-# include <cds/container/striped_set/boost_stable_vector.h>
-# include <cds/container/striped_set/boost_set.h>
-# include <cds/container/striped_set/boost_flat_set.h>
-#endif
-#include <cds/container/striped_set.h>
-
-#include <cds/sync/spinlock.h>
-#include <boost/functional/hash/hash.hpp>
-
-#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 <typename V, typename Traits>
- 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 <typename Q, typename Pred>
- 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 <typename Key>
- struct cmp {
- int operator ()(Key const& k1, Key const& k2) const
- {
- if ( std::less<Key>( k1, k2 ) )
- return -1;
- return std::less<Key>( k2, k1 ) ? 1 : 0;
- }
- };
-
-#define CDSUNIT_INT_COMPARE(t) template <> struct cmp<t> { 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<std::string>
- {
- 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 <typename Key, typename Value>
- 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 <typename K>
- /*explicit*/ key_val( K const& k ): key(k) {}
-
- template <typename K, typename T>
- key_val( K const& k, T const& v ): key(k), val(v) {}
- };
-
- typedef co::v::hash<key_type> key_hash;
- typedef std::less<key_type> key_less;
- typedef cmp<key_type> 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 <typename Q>
- 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 <typename Q>
- 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<int> >
- >::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<int> >
- >::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<int> >
- >::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<int> >
- >::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<int> >
- >::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<cc::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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::michael_list_tag>
- ,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::michael_list_tag>
- ,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<cc::michael_list_tag>
- ,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<cc::lazy_list_tag>
- ,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<cc::lazy_list_tag>
- ,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::lazy_list_tag>
- ,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<cc::lazy_list_tag>
- ,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<cc::lazy_list_tag>
- ,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<cc::lazy_list_tag>
- ,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::lazy_list_tag>
- ,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<cc::lazy_list_tag>
- ,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 BucketEntry, typename... Options>
- class StripedHashSet_seq:
- public cc::StripedSet< BucketEntry,
- co::mutex_policy< cc::striped_set::striping<> >
- ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- , Options...
- >
- {
- typedef cc::StripedSet< BucketEntry,
- co::mutex_policy< cc::striped_set::striping<> >
- ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- , 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 <typename Q, typename Less>
- bool erase_with( Q const& v, Less /*pred*/ )
- {
- return base_class::erase( v );
- }
- };
-
- // for non-sequential ordered containers
- template <class BucketEntry, typename... Options>
- class StripedHashSet_ord:
- public cc::StripedSet< BucketEntry,
- co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- ,co::mutex_policy< cc::striped_set::striping<> >
- , Options...
- >
- {
- typedef cc::StripedSet< BucketEntry,
- co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- ,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 <typename Q, typename Less>
- 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 BucketEntry, typename... Options>
- class RefinableHashSet_seq:
- public cc::StripedSet< BucketEntry,
- co::mutex_policy< cc::striped_set::refinable<> >
- ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- , Options...
- >
- {
- typedef cc::StripedSet< BucketEntry,
- co::mutex_policy< cc::striped_set::refinable<> >
- ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- , 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 <typename Q, typename Less>
- bool erase_with( Q const& v, Less /*pred*/ )
- {
- return base_class::erase( v );
- }
- };
-
- // for non-sequential ordered containers
- template <class BucketEntry, typename... Options>
- class RefinableHashSet_ord:
- public cc::StripedSet< BucketEntry,
- co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- ,co::mutex_policy< cc::striped_set::refinable<> >
- , Options...
- >
- {
- typedef cc::StripedSet< BucketEntry,
- co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
- ,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 <typename Q, typename Less>
- 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 <typename Traits>
- struct traits_CuckooStripedSet : public Traits
- {
- typedef cc::cuckoo::striping<> mutex_policy;
- };
- template <typename Traits>
- 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<traits_CuckooSet_list_unord>> CuckooStripedSet_list_unord;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord>> 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<traits_CuckooSet_list_unord_stat>> CuckooStripedSet_list_unord_stat;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord_stat>> 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<traits_CuckooSet_list_unord_storehash>> CuckooStripedSet_list_unord_storehash;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_unord_storehash>> 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<traits_CuckooSet_list_ord>> CuckooStripedSet_list_ord;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord>> 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<traits_CuckooSet_list_ord_stat>> CuckooStripedSet_list_ord_stat;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord_stat>> 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<traits_CuckooSet_list_ord_storehash>> CuckooStripedSet_list_ord_storehash;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_list_ord_storehash>> 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<traits_CuckooSet_vector_unord>> CuckooStripedSet_vector_unord;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord>> 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<traits_CuckooSet_vector_unord_stat>> CuckooStripedSet_vector_unord_stat;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord_stat>> 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<traits_CuckooSet_vector_unord_storehash>> CuckooStripedSet_vector_unord_storehash;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_unord_storehash>> 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<traits_CuckooSet_vector_ord>> CuckooStripedSet_vector_ord;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord>> 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<traits_CuckooSet_vector_ord_stat>> CuckooStripedSet_vector_ord_stat;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord_stat>> 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<traits_CuckooSet_vector_ord_storehash>> CuckooStripedSet_vector_ord_storehash;
- typedef CuckooSet< key_val, traits_CuckooRefinableSet<traits_CuckooSet_vector_ord_storehash>> 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<cds::gc::HP, key_val> 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<cds::gc::DHP, key_val> 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<rcu_gpi, key_val> 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<rcu_gpb, key_val> 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<rcu_gpt, key_val> 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<rcu_shb, key_val> 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<rcu_sht, key_val> 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 <typename Set>
- static inline void print_stat( Set const& /*s*/ )
- {}
-
- template <typename GC, typename T, typename Traits>
- static inline void print_stat( cc::SplitListSet<GC, T, Traits> const& s )
- {
- CPPUNIT_MSG( s.statistics() );
- }
-
- template <typename GC, typename T, typename Traits>
- static inline void print_stat( cc::SkipListSet<GC, T, Traits> const& s )
- {
- CPPUNIT_MSG( s.statistics() );
- }
-
- template <typename GC, typename Key, typename T, typename Traits>
- static inline void print_stat( cc::EllenBinTreeSet<GC, Key, T, Traits> const& s )
- {
- CPPUNIT_MSG( s.statistics() );
- }
-
- template <typename T, typename Traits >
- static inline void print_stat( cc::CuckooSet< T, Traits > const& s )
- {
- CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() );
- }
-
- template <typename V, typename Traits>
- static inline void print_stat( CuckooSet< V, Traits > const& s )
- {
- typedef CuckooSet< V, Traits > set_type;
- print_stat( static_cast<typename set_type::cuckoo_base_class const&>(s) );
- }
-
-
- //*******************************************************
- // additional_check
- //*******************************************************
-
- template <typename Set>
- static inline void additional_check( Set& /*set*/ )
- {}
-
- template <typename Set>
- 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 <typename GC, typename Key, typename T, typename Traits>
- static inline void additional_check( cc::EllenBinTreeSet<GC, Key, T, Traits>& s )
- {
- GC::force_dispose();
- ellen_bintree_check::check_stat( s.statistics() );
- }
-
- template <typename GC, typename Key, typename T, typename Traits>
- static inline void additional_cleanup( cc::EllenBinTreeSet<GC, Key, T, Traits>& /*s*/ )
- {
- ellen_bintree_pool::internal_node_counter::reset();
- }
-
- //*******************************************************
- // check_before_clear
- //*******************************************************
-
- template <typename Set>
- static inline void check_before_clear( Set& /*s*/ )
- {}
-
- template <typename GC, typename Key, typename T, typename Traits>
- static inline void check_before_clear( cds::container::EllenBinTreeSet<GC, Key, T, Traits>& s )
- {
- CPPUNIT_CHECK_CURRENT( s.check_consistency() );
- }
-
-} // namespace set2
-
-#endif // ifndef CDSUNIT_SET_TYPES_H
+++ /dev/null
-//$$CDS-header$$
-
-#ifndef CDSUNIT_STD_HASH_SET_H
-#define CDSUNIT_STD_HASH_SET_H
-
-#include <unordered_set>
-#include <mutex> //unique_lock
-
-namespace set2 {
-
- template <typename Value, typename Hash, typename Less, typename EqualTo, typename Lock,
- class Alloc = typename CDS_DEFAULT_ALLOCATOR::template rebind<Value>::other
- >
- class StdHashSet
- : public std::unordered_set<
- Value
- , Hash
- , EqualTo
- , Alloc
- >
- {
- public:
- Lock m_lock;
- typedef std::unique_lock<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 <typename Key>
- bool find( const Key& key )
- {
- scoped_lock al( m_lock );
- return base_class::find( value_type(key) ) != base_class::end();
- }
-
- template <typename Key>
- bool insert( Key const& key )
- {
- scoped_lock al( m_lock );
- std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
- return pRet.second;
- }
-
- template <typename Key, typename Func>
- bool insert( Key const& key, Func func )
- {
- scoped_lock al( m_lock );
- std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
- if ( pRet.second ) {
- func( *pRet.first );
- return true;
- }
- return false;
- }
-
- template <typename T, typename Func>
- std::pair<bool, bool> ensure( const T& key, Func func )
- {
- scoped_lock al( m_lock );
- std::pair<typename base_class::iterator, bool> 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 <typename Key>
- bool erase( const Key& key )
- {
- scoped_lock al( m_lock );
- return base_class::erase( value_type(key) ) != 0;
- }
-
- template <typename T, typename Func>
- 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
+++ /dev/null
-//$$CDS-header$$
-
-#ifndef CDSUNIT_STD_SET_H
-#define CDSUNIT_STD_SET_H
-
-#include <set>
-#include <mutex> //unique_lock
-
-namespace set2 {
- template <typename Value, typename Less, typename Lock,
- class Alloc = typename CDS_DEFAULT_ALLOCATOR::template rebind<Value>::other
- >
- class StdSet: public std::set<Value, Less, Alloc>
- {
- Lock m_lock;
- typedef std::unique_lock<Lock> scoped_lock;
- typedef std::set<Value, Less, Alloc> base_class;
- public:
- typedef typename base_class::key_type value_type;
-
- StdSet( size_t /*nMapSize*/, size_t /*nLoadFactor*/ )
- {}
-
- template <typename Key>
- 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 <typename Key, typename Func>
- bool insert( Key const& key, Func func )
- {
- scoped_lock al( m_lock );
- std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
- if ( pRet.second ) {
- func( *pRet.first );
- return true;
- }
- return false;
- }
-
- template <typename T, typename Func>
- std::pair<bool, bool> ensure( const T& key, Func func )
- {
- scoped_lock al( m_lock );
- std::pair<typename base_class::iterator, bool> 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 <typename Key>
- bool erase( const Key& key )
- {
- scoped_lock al( m_lock );
- return base_class::erase( value_type(key) ) != 0;
- }
-
- template <typename T, typename Func>
- 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
projects / libcds.git / commitdiff