From: khizmax Date: Mon, 8 Feb 2016 12:26:43 +0000 (+0300) Subject: Moved LazyList unit test to gtest framework X-Git-Tag: v2.2.0~404 X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=03b26298d15749cb2120239dbbd52815ea873d8f;p=libcds.git Moved LazyList unit test to gtest framework --- diff --git a/cds/intrusive/impl/lazy_list.h b/cds/intrusive/impl/lazy_list.h index 3904251c..a49fa0f7 100644 --- a/cds/intrusive/impl/lazy_list.h +++ b/cds/intrusive/impl/lazy_list.h @@ -207,6 +207,8 @@ namespace cds { namespace intrusive { typedef typename gc::template guarded_ptr< value_type > guarded_ptr; ///< Guarded pointer + static CDS_CONSTEXPR const size_t c_nHazardPtrCount = 4; ///< Count of hazard pointer required for the algorithm + //@cond // Rebind traits (split-list support) template diff --git a/projects/Win/vc14/gtest-list.vcxproj b/projects/Win/vc14/gtest-list.vcxproj index 19817ab5..f9d0d92a 100644 --- a/projects/Win/vc14/gtest-list.vcxproj +++ b/projects/Win/vc14/gtest-list.vcxproj @@ -31,6 +31,8 @@ + + diff --git a/projects/Win/vc14/gtest-list.vcxproj.filters b/projects/Win/vc14/gtest-list.vcxproj.filters index 1d995ef2..1315a85a 100644 --- a/projects/Win/vc14/gtest-list.vcxproj.filters +++ b/projects/Win/vc14/gtest-list.vcxproj.filters @@ -32,5 +32,11 @@ Source Files + + Source Files + + + Source Files + \ No newline at end of file diff --git a/test/unit/list/CMakeLists.txt b/test/unit/list/CMakeLists.txt index e3d3324e..da92610d 100644 --- a/test/unit/list/CMakeLists.txt +++ b/test/unit/list/CMakeLists.txt @@ -2,6 +2,8 @@ set(PACKAGE_NAME unit-list) set(CDSGTEST_LIST_SOURCES ../main.cpp + intrusive_lazy_hp.cpp + intrusive_lazy_dhp.cpp intrusive_michael_hp.cpp intrusive_michael_dhp.cpp ) diff --git a/test/unit/list/intrusive_lazy_dhp.cpp b/test/unit/list/intrusive_lazy_dhp.cpp new file mode 100644 index 00000000..2822cff2 --- /dev/null +++ b/test/unit/list/intrusive_lazy_dhp.cpp @@ -0,0 +1,272 @@ +/* + 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_intrusive_list_hp.h" +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::DHP gc_type; + + class IntrusiveLazyList_DHP : public cds_test::intrusive_list_hp + { + public: + typedef cds_test::intrusive_list_hp::base_item< ci::lazy_list::node< gc_type>> base_item; + typedef cds_test::intrusive_list_hp::member_item< ci::lazy_list::node< gc_type>> member_item; + + typedef cds_test::intrusive_list_hp::base_item< ci::lazy_list::node< gc_type, std::mutex>> base_mutex_item; + typedef cds_test::intrusive_list_hp::member_item< ci::lazy_list::node< gc_type, std::mutex>> member_mutex_item; + + protected: + void SetUp() + { + struct traits: public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + cds::gc::dhp::GarbageCollector::Construct( 16, list_type::c_nHazardPtrCount ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct(); + } + }; + + TEST_F( IntrusiveLazyList_DHP, base_hook ) + { + typedef ci::LazyList< gc_type, base_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::less< less< base_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, base_hook_cmp ) + { + typedef ci::LazyList< gc_type, base_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< cds::opt::gc< gc_type >>> + , ci::opt::disposer< mock_disposer > + , cds::opt::compare< cmp< base_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, base_hook_item_counting ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, base_hook_mutex ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >, cds::opt::lock_type< std::mutex>> hook; + typedef mock_disposer disposer; + typedef cmp< base_mutex_item > compare; + typedef intrusive_list_common::less< base_mutex_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, base_mutex_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, base_hook_backoff ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::pause back_off; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, base_hook_seqcst ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook ) + { + typedef ci::LazyList< gc_type, member_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::less< less< member_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook_cmp ) + { + typedef ci::LazyList< gc_type, member_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::compare< cmp< member_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook_item_counting ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook_seqcst ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook_mutex ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item, hMember ), cds::opt::gc< gc_type >, cds::opt::lock_type< std::mutex >> hook; + typedef mock_disposer disposer; + typedef cmp< member_mutex_item > compare; + typedef intrusive_list_common::less< member_mutex_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, member_mutex_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_DHP, member_hook_back_off ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + +} // namespace diff --git a/test/unit/list/intrusive_lazy_hp.cpp b/test/unit/list/intrusive_lazy_hp.cpp new file mode 100644 index 00000000..9b09536a --- /dev/null +++ b/test/unit/list/intrusive_lazy_hp.cpp @@ -0,0 +1,273 @@ +/* + 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_intrusive_list_hp.h" +#include + +namespace { + namespace ci = cds::intrusive; + typedef cds::gc::HP gc_type; + + class IntrusiveLazyList_HP : public cds_test::intrusive_list_hp + { + public: + typedef cds_test::intrusive_list_hp::base_item< ci::lazy_list::node< gc_type>> base_item; + typedef cds_test::intrusive_list_hp::member_item< ci::lazy_list::node< gc_type>> member_item; + + typedef cds_test::intrusive_list_hp::base_item< ci::lazy_list::node< gc_type, std::mutex>> base_mutex_item; + typedef cds_test::intrusive_list_hp::member_item< ci::lazy_list::node< gc_type, std::mutex>> member_mutex_item; + + protected: + void SetUp() + { + struct traits: public ci::lazy_list::traits + { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + // +1 - for guarded_ptr + cds::gc::hp::GarbageCollector::Construct( list_type::c_nHazardPtrCount + 1, 1, 16 ); + cds::threading::Manager::attachThread(); + } + + void TearDown() + { + cds::threading::Manager::detachThread(); + cds::gc::hp::GarbageCollector::Destruct( true ); + } + }; + + TEST_F( IntrusiveLazyList_HP, base_hook ) + { + typedef ci::LazyList< gc_type, base_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::less< less< base_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, base_hook_cmp ) + { + typedef ci::LazyList< gc_type, base_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::base_hook< cds::opt::gc< gc_type >>> + , ci::opt::disposer< mock_disposer > + , cds::opt::compare< cmp< base_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, base_hook_item_counting ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, base_hook_mutex ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >, cds::opt::lock_type< std::mutex>> hook; + typedef mock_disposer disposer; + typedef cmp< base_mutex_item > compare; + typedef intrusive_list_common::less< base_mutex_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, base_mutex_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, base_hook_backoff ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::pause back_off; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, base_hook_seqcst ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::base_hook< cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< base_item > compare; + typedef intrusive_list_common::less< base_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, base_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook ) + { + typedef ci::LazyList< gc_type, member_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::less< less< member_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook_cmp ) + { + typedef ci::LazyList< gc_type, member_item, + typename ci::lazy_list::make_traits< + ci::opt::hook< ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>> + ,ci::opt::disposer< mock_disposer > + ,cds::opt::compare< cmp< member_item >> + >::type + > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook_item_counting ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook_seqcst ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook_mutex ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_mutex_item, hMember ), cds::opt::gc< gc_type >, cds::opt::lock_type< std::mutex >> hook; + typedef mock_disposer disposer; + typedef cmp< member_mutex_item > compare; + typedef intrusive_list_common::less< member_mutex_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::opt::v::sequential_consistent memory_model; + }; + typedef ci::LazyList< gc_type, member_mutex_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + + TEST_F( IntrusiveLazyList_HP, member_hook_back_off ) + { + struct traits : public ci::lazy_list::traits { + typedef ci::lazy_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook; + typedef mock_disposer disposer; + typedef cmp< member_item > compare; + typedef intrusive_list_common::less< member_item > less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::backoff::empty back_off; + }; + typedef ci::LazyList< gc_type, member_item, traits > list_type; + + list_type l; + test_common( l ); + test_sorted_iterator( l ); + test_hp( l ); + } + +} // namespace