From 6b558f76275935ec154d73998fa348e0e626832a Mon Sep 17 00:00:00 2001 From: khizmax Date: Thu, 31 Mar 2016 00:14:31 +0300 Subject: [PATCH] Migrated MichaelList-based SplitListMap unit tests to gtest --- projects/Win/vc14/gtest-map.vcxproj | 24 +++ projects/Win/vc14/gtest-map.vcxproj.filters | 12 ++ test/unit/map/CMakeLists.txt | 3 + test/unit/map/split_michael_dhp.cpp | 213 ++++++++++++++++++++ test/unit/map/split_michael_hp.cpp | 213 ++++++++++++++++++++ test/unit/map/split_michael_nogc.cpp | 197 ++++++++++++++++++ test/unit/map/test_map.h | 4 + 7 files changed, 666 insertions(+) create mode 100644 test/unit/map/split_michael_dhp.cpp create mode 100644 test/unit/map/split_michael_hp.cpp create mode 100644 test/unit/map/split_michael_nogc.cpp diff --git a/projects/Win/vc14/gtest-map.vcxproj b/projects/Win/vc14/gtest-map.vcxproj index fda6e709..04ee4b66 100644 --- a/projects/Win/vc14/gtest-map.vcxproj +++ b/projects/Win/vc14/gtest-map.vcxproj @@ -65,6 +65,30 @@ + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + diff --git a/projects/Win/vc14/gtest-map.vcxproj.filters b/projects/Win/vc14/gtest-map.vcxproj.filters index da7ccb04..a33c56be 100644 --- a/projects/Win/vc14/gtest-map.vcxproj.filters +++ b/projects/Win/vc14/gtest-map.vcxproj.filters @@ -16,6 +16,9 @@ {12baf500-5c1c-44a7-9bac-e0554eb93b1a} + + {3f37c15c-de68-4230-9c59-bc3a2e059950} + @@ -69,6 +72,15 @@ Source Files\MichaelMap + + Source Files\SplitListMap + + + Source Files\SplitListMap + + + Source Files\SplitListMap + diff --git a/test/unit/map/CMakeLists.txt b/test/unit/map/CMakeLists.txt index da77abd5..bfda3c16 100644 --- a/test/unit/map/CMakeLists.txt +++ b/test/unit/map/CMakeLists.txt @@ -18,6 +18,9 @@ set(CDSGTEST_MAP_SOURCES michael_michael_rcu_gpt.cpp michael_michael_rcu_shb.cpp michael_michael_rcu_sht.cpp + split_michael_hp.cpp + split_michael_dhp.cpp + split_michael_nogc.cpp ) include_directories( diff --git a/test/unit/map/split_michael_dhp.cpp b/test/unit/map/split_michael_dhp.cpp new file mode 100644 index 00000000..7627d2c5 --- /dev/null +++ b/test/unit/map/split_michael_dhp.cpp @@ -0,0 +1,213 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_map_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::DHP gc_type; + + class SplitListMichaelMap_DHP : public cds_test::container_map_hp + { + protected: + typedef cds_test::container_map_hp base_class; + + void SetUp() + { + struct map_traits: public cc::split_list::traits { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + // +1 - for guarded_ptr + cds::gc::dhp::GarbageCollector::Construct( 16, map_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + TEST_F( SplitListMichaelMap_DHP, compare ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_DHP, less ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_DHP, cmpmix ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + , cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_DHP, item_counting ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef base_class::less less; + typedef cds::backoff::empty back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_DHP, stat ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cc::split_list::stat<> stat; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::opt::v::sequential_consistent memory_model; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_DHP, back_off ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::yield back_off; + typedef cds::opt::v::sequential_consistent memory_model; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 3 ); + test( m ); + } + + struct set_static_traits: public cc::split_list::traits + { + static bool const dynamic_bucket_table = false; + }; + + TEST_F( SplitListMichaelMap_DHP, static_bucket_table ) + { + struct map_traits: public set_static_traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + +} // namespace diff --git a/test/unit/map/split_michael_hp.cpp b/test/unit/map/split_michael_hp.cpp new file mode 100644 index 00000000..16adc938 --- /dev/null +++ b/test/unit/map/split_michael_hp.cpp @@ -0,0 +1,213 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_map_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::HP gc_type; + + class SplitListMichaelMap_HP : public cds_test::container_map_hp + { + protected: + typedef cds_test::container_map_hp base_class; + + void SetUp() + { + struct map_traits: public cc::split_list::traits { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( map_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + TEST_F( SplitListMichaelMap_HP, compare ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_HP, less ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_HP, cmpmix ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + , cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_HP, item_counting ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef base_class::less less; + typedef cds::backoff::empty back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_HP, stat ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cc::split_list::stat<> stat; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::opt::v::sequential_consistent memory_model; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_HP, back_off ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::yield back_off; + typedef cds::opt::v::sequential_consistent memory_model; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 3 ); + test( m ); + } + + struct set_static_traits: public cc::split_list::traits + { + static bool const dynamic_bucket_table = false; + }; + + TEST_F( SplitListMichaelMap_HP, static_bucket_table ) + { + struct map_traits: public set_static_traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + +} // namespace diff --git a/test/unit/map/split_michael_nogc.cpp b/test/unit/map/split_michael_nogc.cpp new file mode 100644 index 00000000..dfe9fc97 --- /dev/null +++ b/test/unit/map/split_michael_nogc.cpp @@ -0,0 +1,197 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "test_map_nogc.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::nogc gc_type; + + class SplitListMichaelMap_NoGC : public cds_test::container_map_nogc + { + protected: + typedef cds_test::container_map_nogc base_class; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + TEST_F( SplitListMichaelMap_NoGC, compare ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_NoGC, less ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + >::type + > + >::type + > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_NoGC, cmpmix ) + { + typedef cc::SplitListMap< gc_type, key_type, value_type, + typename cc::split_list::make_traits< + cc::split_list::ordered_list< cc::michael_list_tag > + , cds::opt::hash< hash1 > + , cc::split_list::ordered_list_traits< + typename cc::michael_list::make_traits< + cds::opt::less< less > + , cds::opt::compare< cmp > + >::type + > + >::type + > map_type; + + map_type m( kSize, 3 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_NoGC, item_counting ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef base_class::less less; + typedef cds::backoff::empty back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_NoGC, stat ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cc::split_list::stat<> stat; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef base_class::less less; + typedef cds::opt::v::sequential_consistent memory_model; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 5 ); + test( m ); + } + + TEST_F( SplitListMichaelMap_NoGC, back_off ) + { + struct map_traits: public cc::split_list::traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::yield back_off; + typedef cds::opt::v::sequential_consistent memory_model; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 2 ); + test( m ); + } + + struct set_static_traits: public cc::split_list::traits + { + static bool const dynamic_bucket_table = false; + }; + + TEST_F( SplitListMichaelMap_NoGC, static_bucket_table ) + { + struct map_traits: public set_static_traits + { + typedef cc::michael_list_tag ordered_list; + typedef hash1 hash; + typedef cds::atomicity::item_counter item_counter; + + struct ordered_list_traits: public cc::michael_list::traits + { + typedef cmp compare; + typedef cds::backoff::pause back_off; + }; + }; + typedef cc::SplitListMap< gc_type, key_type, value_type, map_traits > map_type; + + map_type m( kSize, 4 ); + test( m ); + } + + +} // namespace diff --git a/test/unit/map/test_map.h b/test/unit/map/test_map.h index 43bd2bdf..8caa8fb1 100644 --- a/test/unit/map/test_map.h +++ b/test/unit/map/test_map.h @@ -56,6 +56,10 @@ namespace cds_test { explicit key_type( std::string const& str ) : nKey( std::stoi( str )) {} + + key_type( key_type const& s ) + : nKey( s.nKey ) + {} }; struct value_type { -- 2.34.1