From 76ae4860f0267ecb4358ad14cf0427bf89caba10 Mon Sep 17 00:00:00 2001 From: khizmax Date: Thu, 17 Mar 2016 22:49:52 +0300 Subject: [PATCH] Migrated MichaelHashSet unit test to gtest framework --- projects/Win/vc14/gtest-set.vcxproj | 17 ++ projects/Win/vc14/gtest-set.vcxproj.filters | 30 +++ test/unit/set/CMakeLists.txt | 8 + test/unit/set/michael_lazy_dhp.cpp | 197 +++++++++++++++++ test/unit/set/michael_lazy_hp.cpp | 198 +++++++++++++++++ test/unit/set/michael_lazy_nogc.cpp | 188 ++++++++++++++++ test/unit/set/michael_lazy_rcu_gpb.cpp | 41 ++++ test/unit/set/michael_lazy_rcu_gpi.cpp | 41 ++++ test/unit/set/michael_lazy_rcu_gpt.cpp | 41 ++++ test/unit/set/michael_lazy_rcu_shb.cpp | 45 ++++ test/unit/set/michael_lazy_rcu_sht.cpp | 45 ++++ test/unit/set/michael_michael_dhp.cpp | 1 - test/unit/set/test_michael_lazy_rcu.h | 228 ++++++++++++++++++++ test/unit/set/test_set_rcu.h | 67 +++--- 14 files changed, 1116 insertions(+), 31 deletions(-) create mode 100644 test/unit/set/michael_lazy_dhp.cpp create mode 100644 test/unit/set/michael_lazy_hp.cpp create mode 100644 test/unit/set/michael_lazy_nogc.cpp create mode 100644 test/unit/set/michael_lazy_rcu_gpb.cpp create mode 100644 test/unit/set/michael_lazy_rcu_gpi.cpp create mode 100644 test/unit/set/michael_lazy_rcu_gpt.cpp create mode 100644 test/unit/set/michael_lazy_rcu_shb.cpp create mode 100644 test/unit/set/michael_lazy_rcu_sht.cpp create mode 100644 test/unit/set/test_michael_lazy_rcu.h diff --git a/projects/Win/vc14/gtest-set.vcxproj b/projects/Win/vc14/gtest-set.vcxproj index b4a380e8..6c27a5a8 100644 --- a/projects/Win/vc14/gtest-set.vcxproj +++ b/projects/Win/vc14/gtest-set.vcxproj @@ -28,6 +28,21 @@ + + + + + + + 4503 + 4503 + 4503 + 4503 + 4503 + 4503 + + + @@ -52,6 +67,8 @@ + + diff --git a/projects/Win/vc14/gtest-set.vcxproj.filters b/projects/Win/vc14/gtest-set.vcxproj.filters index df7f8752..b279b0a6 100644 --- a/projects/Win/vc14/gtest-set.vcxproj.filters +++ b/projects/Win/vc14/gtest-set.vcxproj.filters @@ -45,6 +45,30 @@ Source Files\MichaelSet + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + + + Source Files\MichaelSet + @@ -59,5 +83,11 @@ Header Files + + Header Files + + + Header Files + \ No newline at end of file diff --git a/test/unit/set/CMakeLists.txt b/test/unit/set/CMakeLists.txt index 8691e718..9dc0776a 100644 --- a/test/unit/set/CMakeLists.txt +++ b/test/unit/set/CMakeLists.txt @@ -2,6 +2,14 @@ set(PACKAGE_NAME unit-set) set(CDSGTEST_SET_SOURCES ../main.cpp + michael_lazy_hp.cpp + michael_lazy_dhp.cpp + michael_lazy_nogc.cpp + michael_lazy_rcu_gpb.cpp + michael_lazy_rcu_gpi.cpp + michael_lazy_rcu_gpt.cpp + michael_lazy_rcu_shb.cpp + michael_lazy_rcu_sht.cpp michael_michael_hp.cpp michael_michael_dhp.cpp michael_michael_nogc.cpp diff --git a/test/unit/set/michael_lazy_dhp.cpp b/test/unit/set/michael_lazy_dhp.cpp new file mode 100644 index 00000000..1ec2a93d --- /dev/null +++ b/test/unit/set/michael_lazy_dhp.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_set_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::DHP gc_type; + + class MichaelLazySet_DHP : public cds_test::container_set_hp + { + protected: + typedef cds_test::container_set_hp base_class; + + void SetUp() + { + typedef cc::LazyList< gc_type, int_item > list_type; + typedef cc::MichaelHashSet< gc_type, list_type > set_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::dhp::GarbageCollector::Destruct(); + } + }; + + TEST_F( MichaelLazySet_DHP, compare ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, less ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, cmpmix ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, item_counting ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, backoff ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, seq_cst ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_DHP, mutex ) + { + struct list_traits: public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef std::mutex lock_type; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/set/michael_lazy_hp.cpp b/test/unit/set/michael_lazy_hp.cpp new file mode 100644 index 00000000..af163397 --- /dev/null +++ b/test/unit/set/michael_lazy_hp.cpp @@ -0,0 +1,198 @@ +/* + 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_set_hp.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::HP gc_type; + + class MichaelLazySet_HP : public cds_test::container_set_hp + { + protected: + typedef cds_test::container_set_hp base_class; + + void SetUp() + { + typedef cc::LazyList< gc_type, int_item > list_type; + typedef cc::MichaelHashSet< gc_type, list_type > set_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( set_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + TEST_F( MichaelLazySet_HP, compare ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, less ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, cmpmix ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, item_counting ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, backoff ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, seq_cst ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_HP, mutex ) + { + struct list_traits: public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef std::mutex lock_type; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/set/michael_lazy_nogc.cpp b/test/unit/set/michael_lazy_nogc.cpp new file mode 100644 index 00000000..0a7751ce --- /dev/null +++ b/test/unit/set/michael_lazy_nogc.cpp @@ -0,0 +1,188 @@ +/* + 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_set_nogc.h" + +#include +#include + +namespace { + namespace cc = cds::container; + typedef cds::gc::nogc gc_type; + + class MichaelLazySet_NoGC : public cds_test::container_set_nogc + { + protected: + typedef cds_test::container_set_nogc base_class; + + //void SetUp() + //{} + + //void TearDown() + //{} + }; + + TEST_F( MichaelLazySet_NoGC, compare ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::compare< cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, less ) + { + typedef cc::LazyList< gc_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::less< base_class::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, cmpmix ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< gc_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< hash_int > + >::type + > set_type; + + set_type s( kSize, 2 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, item_counting ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef hash_int hash; + typedef simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 3 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, backoff ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, seq_cst ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + + TEST_F( MichaelLazySet_NoGC, mutex ) + { + struct list_traits : public cc::lazy_list::traits + { + typedef base_class::less less; + typedef cds::backoff::pause back_off; + typedef std::mutex lock_type; + }; + typedef cc::LazyList< gc_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< gc_type, list_type, set_traits >set_type; + + set_type s( kSize, 4 ); + test( s ); + } + +} // namespace diff --git a/test/unit/set/michael_lazy_rcu_gpb.cpp b/test/unit/set/michael_lazy_rcu_gpb.cpp new file mode 100644 index 00000000..6cdf4f0a --- /dev/null +++ b/test/unit/set/michael_lazy_rcu_gpb.cpp @@ -0,0 +1,41 @@ +/* + 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 + +#include "test_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPB, MichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/michael_lazy_rcu_gpi.cpp b/test/unit/set/michael_lazy_rcu_gpi.cpp new file mode 100644 index 00000000..f81152c7 --- /dev/null +++ b/test/unit/set/michael_lazy_rcu_gpi.cpp @@ -0,0 +1,41 @@ +/* + 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 + +#include "test_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_instant<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPI, MichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/michael_lazy_rcu_gpt.cpp b/test/unit/set/michael_lazy_rcu_gpt.cpp new file mode 100644 index 00000000..3e7e917b --- /dev/null +++ b/test/unit/set/michael_lazy_rcu_gpt.cpp @@ -0,0 +1,41 @@ +/* + 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 + +#include "test_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::general_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_GPT, MichaelLazySet, rcu_implementation ); diff --git a/test/unit/set/michael_lazy_rcu_shb.cpp b/test/unit/set/michael_lazy_rcu_shb.cpp new file mode 100644 index 00000000..0f65501e --- /dev/null +++ b/test/unit/set/michael_lazy_rcu_shb.cpp @@ -0,0 +1,45 @@ +/* + 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 + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_buffered<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHB, MichaelLazySet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/michael_lazy_rcu_sht.cpp b/test/unit/set/michael_lazy_rcu_sht.cpp new file mode 100644 index 00000000..db2bbb56 --- /dev/null +++ b/test/unit/set/michael_lazy_rcu_sht.cpp @@ -0,0 +1,45 @@ +/* + 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 + +#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED + +#include "test_michael_lazy_rcu.h" + +namespace { + + typedef cds::urcu::signal_threaded<> rcu_implementation; + +} // namespace + +INSTANTIATE_TYPED_TEST_CASE_P( RCU_SHT, MichaelLazySet, rcu_implementation ); + +#endif // CDS_URCU_SIGNAL_HANDLING_ENABLED diff --git a/test/unit/set/michael_michael_dhp.cpp b/test/unit/set/michael_michael_dhp.cpp index fa386635..73f8b1f6 100644 --- a/test/unit/set/michael_michael_dhp.cpp +++ b/test/unit/set/michael_michael_dhp.cpp @@ -47,7 +47,6 @@ namespace { typedef cc::MichaelList< gc_type, int_item > list_type; typedef cc::MichaelHashSet< gc_type, list_type > set_type; - // +1 - for guarded_ptr cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount ); cds::threading::Manager::attachThread(); } diff --git a/test/unit/set/test_michael_lazy_rcu.h b/test/unit/set/test_michael_lazy_rcu.h new file mode 100644 index 00000000..832fcaf3 --- /dev/null +++ b/test/unit/set/test_michael_lazy_rcu.h @@ -0,0 +1,228 @@ +/* + 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. +*/ +#ifndef CDSUNIT_SET_TEST_MICHAEL_LAZY_RCU_H +#define CDSUNIT_SET_TEST_MICHAEL_LAZY_RCU_H + +#include "test_set_rcu.h" +#include +#include + +namespace cc = cds::container; + +template +class MichaelLazySet: public cds_test::container_set_rcu +{ + typedef cds_test::container_set_rcu base_class; +public: + typedef cds::urcu::gc rcu_type; + +protected: + void SetUp() + { + RCU::Construct(); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + RCU::Destruct(); + } +}; + +TYPED_TEST_CASE_P( MichaelLazySet ); + +TYPED_TEST_P( MichaelLazySet, compare ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + typedef cc::LazyList< rcu_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::compare< typename TestFixture::cmp > + >::type + > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, less ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + typedef cc::LazyList< rcu_type, int_item, + typename cc::lazy_list::make_traits< + cds::opt::less< typename TestFixture::less > + >::type + > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, cmpmix ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::lazy_list::traits + { + typedef typename TestFixture::less less; + typedef typename TestFixture::cmp compare; + }; + typedef cc::LazyList< rcu_type, int_item, list_traits > list_type; + + typedef cc::MichaelHashSet< rcu_type, list_type, + typename cc::michael_set::make_traits< + cds::opt::hash< typename TestFixture::hash_int > + >::type + > set_type; + + set_type s( TestFixture::kSize, 2 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, item_counting ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::lazy_list::traits + { + typedef typename TestFixture::cmp compare; + }; + typedef cc::LazyList< rcu_type, int_item, list_traits > list_type; + + struct set_traits: public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef typename TestFixture::simple_item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 3 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, backoff ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::lazy_list::traits + { + typedef typename TestFixture::cmp compare; + typedef cds::backoff::exponential back_off; + }; + typedef cc::LazyList< rcu_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 4 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, seq_cst ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::lazy_list::traits + { + typedef typename TestFixture::less less; + typedef cds::backoff::pause back_off; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef cc::LazyList< rcu_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 4 ); + this->test( s ); +} + +TYPED_TEST_P( MichaelLazySet, mutex ) +{ + typedef typename TestFixture::rcu_type rcu_type; + typedef typename TestFixture::int_item int_item; + + struct list_traits : public cc::lazy_list::traits + { + typedef typename TestFixture::less less; + typedef cds::backoff::pause back_off; + typedef std::mutex lock_type; + }; + typedef cc::LazyList< rcu_type, int_item, list_traits > list_type; + + struct set_traits : public cc::michael_set::traits + { + typedef typename TestFixture::hash_int hash; + typedef cds::atomicity::item_counter item_counter; + }; + typedef cc::MichaelHashSet< rcu_type, list_type, set_traits >set_type; + + set_type s( TestFixture::kSize, 4 ); + this->test( s ); +} + + +// GCC 5: All test names should be written on single line, otherwise a runtime error will be encountered like as +// "No test named can be found in this test case" +REGISTER_TYPED_TEST_CASE_P( MichaelLazySet, + compare, less, cmpmix, item_counting, backoff, seq_cst, mutex +); + + +#endif // CDSUNIT_SET_TEST_INTRUSIVE_MICHAEL_LAZY_RCU_H + \ No newline at end of file diff --git a/test/unit/set/test_set_rcu.h b/test/unit/set/test_set_rcu.h index d819278a..9f720d90 100644 --- a/test/unit/set/test_set_rcu.h +++ b/test/unit/set/test_set_rcu.h @@ -89,7 +89,7 @@ namespace cds_test { { rcu_lock l; - raw_ptr rp; + raw_ptr rp{}; ASSERT_TRUE( !rp ); switch ( idx % 3 ) { case 0: @@ -117,37 +117,44 @@ namespace cds_test { ASSERT_TRUE( !xp ); if ( Set::c_bExtractLockExternal ) { - rcu_lock l; - - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - ASSERT_FALSE( !xp ); - break; - case 1: - xp = s.extract( i ); - ASSERT_FALSE( !xp ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - ASSERT_FALSE( !xp ); - break; + { + rcu_lock l; + + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + ASSERT_FALSE( !xp ); + break; + case 1: + xp = s.extract( i ); + ASSERT_FALSE( !xp ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + ASSERT_FALSE( !xp ); + break; + } + EXPECT_EQ( xp->key(), i.key() ); + EXPECT_EQ( xp->nFindCount, i.key() * 6 ); } - EXPECT_EQ( xp->key(), i.key() ); - EXPECT_EQ( xp->nFindCount, i.key() * 6 ); - - switch ( idx % 3 ) { - case 0: - xp = s.extract( i.key() ); - break; - case 1: - xp = s.extract( i ); - break; - case 2: - xp = s.extract_with( other_item( i.key() ), other_less() ); - break; + xp.release(); + + { + rcu_lock l; + + switch ( idx % 3 ) { + case 0: + xp = s.extract( i.key() ); + break; + case 1: + xp = s.extract( i ); + break; + case 2: + xp = s.extract_with( other_item( i.key() ), other_less() ); + break; + } + ASSERT_TRUE( !xp ); } - ASSERT_TRUE( !xp ); } else { switch ( idx % 3 ) { -- 2.34.1