From 54345bf169738e1aa79974d44d5212c0375b24c8 Mon Sep 17 00:00:00 2001 From: Mike Krinkin Date: Sun, 26 Apr 2015 10:27:25 +0300 Subject: [PATCH] Add tests for rational load factor resizing policy This patch adds tests for striped and refinable sets with rational load factor resizing policy. Set adapters expect denominator of rational load factor, so test output (LoadFactor=i) can be a bit misleading, for all tests with the 'rational' in the name it means LoadFactor=1/i. --- tests/unit/set2/set_defs.h | 102 ++++++++++--- tests/unit/set2/set_type_striped.h | 234 +++++++++++++++++++++++++++++ 2 files changed, 318 insertions(+), 18 deletions(-) diff --git a/tests/unit/set2/set_defs.h b/tests/unit/set2/set_defs.h index 030eaa9e..969ebc82 100644 --- a/tests/unit/set2/set_defs.h +++ b/tests/unit/set2/set_defs.h @@ -664,21 +664,36 @@ CDSUNIT_DECLARE_TEST(StripedSet_vector) \ CDSUNIT_DECLARE_TEST(StripedSet_set) \ CDSUNIT_DECLARE_TEST(StripedSet_hashset) \ - CDSUNIT_DECLARE_TEST(StripedSet_boost_unordered_set) + CDSUNIT_DECLARE_TEST(StripedSet_boost_unordered_set) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_list) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_set) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_hashset) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_unordered_set) #define CDSUNIT_DEFINE_StripedSet_common( IMPL, C ) \ TEST_SET(IMPL, C, StripedSet_list) \ TEST_SET(IMPL, C, StripedSet_vector) \ TEST_SET(IMPL, C, StripedSet_set) \ TEST_SET(IMPL, C, StripedSet_hashset) \ - TEST_SET(IMPL, C, StripedSet_boost_unordered_set) + TEST_SET(IMPL, C, StripedSet_boost_unordered_set) \ + TEST_SET(IMPL, C, StripedSet_rational_list) \ + TEST_SET(IMPL, C, StripedSet_rational_vector) \ + TEST_SET(IMPL, C, StripedSet_rational_set) \ + TEST_SET(IMPL, C, StripedSet_rational_hashset) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_unordered_set) #define CDSUNIT_TEST_StripedSet_common \ CPPUNIT_TEST(StripedSet_list) \ CPPUNIT_TEST(StripedSet_vector) \ CPPUNIT_TEST(StripedSet_set) \ CPPUNIT_TEST(StripedSet_hashset) \ - CPPUNIT_TEST(StripedSet_boost_unordered_set) + CPPUNIT_TEST(StripedSet_boost_unordered_set) \ + CPPUNIT_TEST(StripedSet_rational_list) \ + CPPUNIT_TEST(StripedSet_rational_vector) \ + CPPUNIT_TEST(StripedSet_rational_set) \ + CPPUNIT_TEST(StripedSet_rational_hashset) \ + CPPUNIT_TEST(StripedSet_rational_boost_unordered_set) #if BOOST_VERSION >= 104800 # define CDSUNIT_DECLARE_StripedSet_boost_container \ @@ -686,21 +701,36 @@ 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) + CDSUNIT_DECLARE_TEST(StripedSet_boost_set) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_list) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_slist) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_stable_vector) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_set) # define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) \ TEST_SET(IMPL, C, StripedSet_boost_list) \ TEST_SET(IMPL, C, StripedSet_boost_slist) \ TEST_SET(IMPL, C, StripedSet_boost_vector) \ TEST_SET(IMPL, C, StripedSet_boost_stable_vector) \ - TEST_SET(IMPL, C, StripedSet_boost_set) + TEST_SET(IMPL, C, StripedSet_boost_set) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_list) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_slist) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_vector) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_stable_vector) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_set) # define CDSUNIT_TEST_StripedSet_boost_container \ CPPUNIT_TEST(StripedSet_boost_list) \ CPPUNIT_TEST(StripedSet_boost_slist) \ CPPUNIT_TEST(StripedSet_boost_vector) \ CPPUNIT_TEST(StripedSet_boost_stable_vector) \ - CPPUNIT_TEST(StripedSet_boost_set) + CPPUNIT_TEST(StripedSet_boost_set) \ + CPPUNIT_TEST(StripedSet_rational_boost_list) \ + CPPUNIT_TEST(StripedSet_rational_boost_slist) \ + CPPUNIT_TEST(StripedSet_rational_boost_vector) \ + CPPUNIT_TEST(StripedSet_rational_boost_stable_vector) \ + CPPUNIT_TEST(StripedSet_rational_boost_set) #else # define CDSUNIT_DECLARE_StripedSet_boost_container # define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) @@ -709,11 +739,14 @@ #if BOOST_VERSION >= 104800 && defined(CDS_UNIT_SET_TYPES_ENABLE_BOOST_FLAT_CONTAINERS) # define CDSUNIT_DECLARE_StripedSet_boost_flat_container \ - CDSUNIT_DECLARE_TEST(StripedSet_boost_flat_set) + CDSUNIT_DECLARE_TEST(StripedSet_boost_flat_set) \ + CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_flat_set) # define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) \ - TEST_SET(IMPL, C, StripedSet_boost_flat_set) + TEST_SET(IMPL, C, StripedSet_boost_flat_set) \ + TEST_SET(IMPL, C, StripedSet_rational_boost_flat_set) # define CDSUNIT_TEST_StripedSet_boost_flat_container \ - CPPUNIT_TEST(StripedSet_boost_flat_set) + CPPUNIT_TEST(StripedSet_boost_flat_set) \ + CPPUNIT_TEST(StripedSet_rational_boost_flat_set) #else # define CDSUNIT_DECLARE_StripedSet_boost_flat_container # define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) @@ -739,19 +772,34 @@ CDSUNIT_DECLARE_TEST(RefinableSet_vector) \ CDSUNIT_DECLARE_TEST(RefinableSet_set) \ CDSUNIT_DECLARE_TEST(RefinableSet_hashset) \ - CDSUNIT_DECLARE_TEST(RefinableSet_boost_unordered_set) + CDSUNIT_DECLARE_TEST(RefinableSet_boost_unordered_set) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_list) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_set) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_hashset) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_unordered_set) #define CDSUNIT_DEFINE_RefinableSet_common(IMPL, C) \ TEST_SET(IMPL, C, RefinableSet_list) \ TEST_SET(IMPL, C, RefinableSet_vector) \ TEST_SET(IMPL, C, RefinableSet_set) \ TEST_SET(IMPL, C, RefinableSet_hashset) \ - TEST_SET(IMPL, C, RefinableSet_boost_unordered_set) + TEST_SET(IMPL, C, RefinableSet_boost_unordered_set) \ + TEST_SET(IMPL, C, RefinableSet_rational_list) \ + TEST_SET(IMPL, C, RefinableSet_rational_vector) \ + TEST_SET(IMPL, C, RefinableSet_rational_set) \ + TEST_SET(IMPL, C, RefinableSet_rational_hashset) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_unordered_set) #define CDSUNIT_TEST_RefinableSet_common \ CPPUNIT_TEST(RefinableSet_list) \ CPPUNIT_TEST(RefinableSet_vector) \ CPPUNIT_TEST(RefinableSet_set) \ CPPUNIT_TEST(RefinableSet_hashset) \ - CPPUNIT_TEST(RefinableSet_boost_unordered_set) + CPPUNIT_TEST(RefinableSet_boost_unordered_set) \ + CPPUNIT_TEST(RefinableSet_rational_list) \ + CPPUNIT_TEST(RefinableSet_rational_vector) \ + CPPUNIT_TEST(RefinableSet_rational_set) \ + CPPUNIT_TEST(RefinableSet_rational_hashset) \ + CPPUNIT_TEST(RefinableSet_rational_boost_unordered_set) #if BOOST_VERSION >= 104800 # define CDSUNIT_DECLARE_RefinableSet_boost_container \ @@ -759,19 +807,34 @@ 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) + CDSUNIT_DECLARE_TEST(RefinableSet_boost_set) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_list) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_slist) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_stable_vector) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_set) # define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ TEST_SET(IMPL, C, RefinableSet_boost_list) \ TEST_SET(IMPL, C, RefinableSet_boost_slist) \ TEST_SET(IMPL, C, RefinableSet_boost_vector) \ TEST_SET(IMPL, C, RefinableSet_boost_stable_vector) \ - TEST_SET(IMPL, C, RefinableSet_boost_set) + TEST_SET(IMPL, C, RefinableSet_boost_set) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_list) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_slist) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_vector) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_stable_vector) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_set) # define CDSUNIT_TEST_RefinableSet_boost_container \ CPPUNIT_TEST(RefinableSet_boost_list) \ CPPUNIT_TEST(RefinableSet_boost_slist) \ CPPUNIT_TEST(RefinableSet_boost_vector) \ CPPUNIT_TEST(RefinableSet_boost_stable_vector) \ - CPPUNIT_TEST(RefinableSet_boost_set) + CPPUNIT_TEST(RefinableSet_boost_set) \ + CPPUNIT_TEST(RefinableSet_rational_boost_list) \ + CPPUNIT_TEST(RefinableSet_rational_boost_slist) \ + CPPUNIT_TEST(RefinableSet_rational_boost_vector) \ + CPPUNIT_TEST(RefinableSet_rational_boost_stable_vector) \ + CPPUNIT_TEST(RefinableSet_rational_boost_set) #else # define CDSUNIT_DECLARE_RefinableSet_boost_container # define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \ @@ -780,11 +843,14 @@ #if BOOST_VERSION >= 104800 && defined(CDS_UNIT_SET_TYPES_ENABLE_BOOST_FLAT_CONTAINERS) # define CDSUNIT_DECLARE_RefinableSet_boost_flat_container \ - CDSUNIT_DECLARE_TEST(RefinableSet_boost_flat_set) + CDSUNIT_DECLARE_TEST(RefinableSet_boost_flat_set) \ + CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_flat_set) # define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) \ - TEST_SET(IMPL, C, RefinableSet_boost_flat_set) + TEST_SET(IMPL, C, RefinableSet_boost_flat_set) \ + TEST_SET(IMPL, C, RefinableSet_rational_boost_flat_set) # define CDSUNIT_TEST_RefinableSet_boost_flat_container \ - CPPUNIT_TEST(RefinableSet_boost_flat_set) + CPPUNIT_TEST(RefinableSet_boost_flat_set) \ + CPPUNIT_TEST(RefinableSet_rational_boost_flat_set) #else # define CDSUNIT_DECLARE_RefinableSet_boost_flat_container # define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) diff --git a/tests/unit/set2/set_type_striped.h b/tests/unit/set2/set_type_striped.h index 1d3332b1..7bf31aee 100644 --- a/tests/unit/set2/set_type_striped.h +++ b/tests/unit/set2/set_type_striped.h @@ -68,6 +68,34 @@ namespace set2 { } }; + template + class StripedHashSet_seq_rational: + public cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::striping<> > + ,co::resizing_policy > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::striping<> > + ,co::resizing_policy > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + StripedHashSet_seq_rational( size_t nCapacity, size_t nDenominator ) // LoadFactor = 1 / nDenominator + : base_class( nCapacity * nDenominator / 16, *(new(&m_placeHolder) resizing_policy_t( 1, nDenominator )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + // for non-sequential ordered containers template class StripedHashSet_ord: @@ -97,18 +125,58 @@ namespace set2 { } }; + template + class StripedHashSet_ord_rational: + public cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::striping<> > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::striping<> > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + StripedHashSet_ord_rational( size_t /*nCapacity*/, size_t nDenominator ) // LoadFactor = 1 / nDenominator + : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( 1024, nDenominator )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + typedef StripedHashSet_seq< std::list< key_val > , co::hash< hash2 > , co::less< less > > StripedSet_list; + typedef StripedHashSet_seq_rational< + std::list< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_list; + typedef StripedHashSet_seq< std::vector< key_val > , co::hash< hash2 > , co::less< less > > StripedSet_vector; + typedef StripedHashSet_seq_rational< + std::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_vector; + #if BOOST_VERSION >= 104800 typedef StripedHashSet_seq< boost::container::slist< key_val > @@ -116,23 +184,47 @@ namespace set2 { , co::less< less > > StripedSet_boost_slist; + typedef StripedHashSet_seq_rational< + boost::container::slist< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_boost_slist; + typedef StripedHashSet_seq< boost::container::list< key_val > , co::hash< hash2 > , co::less< less > > StripedSet_boost_list; + typedef StripedHashSet_seq_rational< + boost::container::list< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_boost_list; + typedef StripedHashSet_seq< boost::container::vector< key_val > , co::hash< hash2 > , co::less< less > > StripedSet_boost_vector; + typedef StripedHashSet_seq_rational< + boost::container::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_boost_vector; + typedef StripedHashSet_seq< boost::container::stable_vector< key_val > , co::hash< hash2 > , co::less< less > > StripedSet_boost_stable_vector; + + typedef StripedHashSet_seq_rational< + boost::container::stable_vector< key_val > + , co::hash< hash2 > + , co::less< less > + > StripedSet_rational_boost_stable_vector; #endif typedef StripedHashSet_ord< @@ -140,21 +232,41 @@ namespace set2 { , co::hash< hash2 > > StripedSet_set; + typedef StripedHashSet_ord_rational< + std::set< key_val, less > + , co::hash< hash2 > + > StripedSet_rational_set; + typedef StripedHashSet_ord< std::unordered_set< key_val, hash, equal_to > , co::hash< hash2 > > StripedSet_hashset; + typedef StripedHashSet_ord_rational< + std::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > StripedSet_rational_hashset; + #if BOOST_VERSION >= 104800 typedef StripedHashSet_ord< boost::container::set< key_val, less > , co::hash< hash2 > > StripedSet_boost_set; + typedef StripedHashSet_ord_rational< + boost::container::set< key_val, less > + , co::hash< hash2 > + > StripedSet_rational_boost_set; + typedef StripedHashSet_ord< boost::container::flat_set< key_val, less > , co::hash< hash2 > > StripedSet_boost_flat_set; + + typedef StripedHashSet_ord_rational< + boost::container::flat_set< key_val, less > + , co::hash< hash2 > + > StripedSet_rational_boost_flat_set; #endif typedef StripedHashSet_ord< @@ -162,6 +274,11 @@ namespace set2 { , co::hash< hash2 > > StripedSet_boost_unordered_set; + typedef StripedHashSet_ord_rational< + boost::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > StripedSet_rational_boost_unordered_set; + // *************************************************************************** // RefinableSet @@ -195,6 +312,34 @@ namespace set2 { } }; + template + class RefinableHashSet_seq_rational: + public cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::refinable<> > + ,co::resizing_policy > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::mutex_policy< cc::striped_set::refinable<> > + ,co::resizing_policy > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + RefinableHashSet_seq_rational( size_t nCapacity, size_t nDenominator ) // LoadFactor = 1 / nDenominator + : base_class( nCapacity * nDenominator / 16, *(new(&m_placeHolder) resizing_policy_t( 1, nDenominator )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + // for non-sequential ordered containers template class RefinableHashSet_ord: @@ -224,18 +369,58 @@ namespace set2 { } }; + template + class RefinableHashSet_ord_rational: + public cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::refinable<> > + , Options... + > + { + typedef cc::StripedSet< BucketEntry, + co::resizing_policy > + ,co::mutex_policy< cc::striped_set::refinable<> > + , Options... + > base_class; + typedef typename base_class::resizing_policy resizing_policy_t; + + resizing_policy_t m_placeHolder; + public: + RefinableHashSet_ord_rational( size_t /*nCapacity*/, size_t nDenominator ) // LoadFactor = 1 / nDenominator + : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( 1024, nDenominator )) ) + {} + + template + bool erase_with( Q const& v, Less /*pred*/ ) + { + return base_class::erase( v ); + } + }; + typedef RefinableHashSet_seq< std::list< key_val > , co::hash< hash2 > , co::less< less > > RefinableSet_list; + typedef RefinableHashSet_seq_rational< + std::list< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_list; + typedef RefinableHashSet_seq< std::vector< key_val > , co::hash< hash2 > , co::less< less > > RefinableSet_vector; + typedef RefinableHashSet_seq_rational< + std::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_vector; + #if BOOST_VERSION >= 104800 typedef RefinableHashSet_seq< boost::container::slist< key_val > @@ -243,23 +428,47 @@ namespace set2 { , co::less< less > > RefinableSet_boost_slist; + typedef RefinableHashSet_seq_rational< + boost::container::slist< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_boost_slist; + typedef RefinableHashSet_seq< boost::container::list< key_val > , co::hash< hash2 > , co::less< less > > RefinableSet_boost_list; + typedef RefinableHashSet_seq_rational< + boost::container::list< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_boost_list; + typedef RefinableHashSet_seq< boost::container::vector< key_val > , co::hash< hash2 > , co::less< less > > RefinableSet_boost_vector; + typedef RefinableHashSet_seq_rational< + boost::container::vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_boost_vector; + typedef RefinableHashSet_seq< boost::container::stable_vector< key_val > , co::hash< hash2 > , co::less< less > > RefinableSet_boost_stable_vector; + + typedef RefinableHashSet_seq_rational< + boost::container::stable_vector< key_val > + , co::hash< hash2 > + , co::less< less > + > RefinableSet_rational_boost_stable_vector; #endif typedef RefinableHashSet_ord< @@ -267,27 +476,52 @@ namespace set2 { , co::hash< hash2 > > RefinableSet_set; + typedef RefinableHashSet_ord_rational< + std::set< key_val, less > + , co::hash< hash2 > + > RefinableSet_rational_set; + typedef RefinableHashSet_ord< std::unordered_set< key_val, hash, equal_to > , co::hash< hash2 > > RefinableSet_hashset; + typedef RefinableHashSet_ord_rational< + std::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > RefinableSet_rational_hashset; + #if BOOST_VERSION >= 104800 typedef RefinableHashSet_ord< boost::container::set< key_val, less > , co::hash< hash2 > > RefinableSet_boost_set; + typedef RefinableHashSet_ord_rational< + boost::container::set< key_val, less > + , co::hash< hash2 > + > RefinableSet_rational_boost_set; + typedef RefinableHashSet_ord< boost::container::flat_set< key_val, less > , co::hash< hash2 > > RefinableSet_boost_flat_set; + + typedef RefinableHashSet_ord_rational< + boost::container::flat_set< key_val, less > + , co::hash< hash2 > + > RefinableSet_rational_boost_flat_set; #endif typedef RefinableHashSet_ord< boost::unordered_set< key_val, hash, equal_to > , co::hash< hash2 > > RefinableSet_boost_unordered_set; + + typedef RefinableHashSet_ord_rational< + boost::unordered_set< key_val, hash, equal_to > + , co::hash< hash2 > + > RefinableSet_rational_boost_unordered_set; }; } // namespace set2 -- 2.34.1