From 4cfc2b411754b8a33010c95776bf97e70ee89b95 Mon Sep 17 00:00:00 2001 From: khizmax Date: Tue, 26 Jul 2016 22:34:10 +0300 Subject: [PATCH] Added internal statistics for LazyList --- cds/container/details/lazy_list_base.h | 4 +-- cds/container/impl/lazy_kvlist.h | 16 ++++++++++- cds/container/impl/lazy_list.h | 16 ++++++++++- cds/container/lazy_kvlist_nogc.h | 16 ++++++++++- cds/container/lazy_kvlist_rcu.h | 16 ++++++++++- cds/container/lazy_list_nogc.h | 27 ++++++++++++++----- cds/container/lazy_list_rcu.h | 26 +++++++++++++----- test/unit/list/kv_lazy_dhp.cpp | 33 +++++++++++++++++++++++ test/unit/list/kv_lazy_hp.cpp | 35 +++++++++++++++++++++++- test/unit/list/kv_lazy_nogc.cpp | 33 ++++++++++++++++++++++- test/unit/list/lazy_dhp.cpp | 34 +++++++++++++++++++++++ test/unit/list/lazy_hp.cpp | 35 +++++++++++++++++++++++- test/unit/list/lazy_nogc.cpp | 33 ++++++++++++++++++++++- test/unit/list/test_kv_lazy_rcu.h | 37 ++++++++++++++++++++++++-- test/unit/list/test_lazy_rcu.h | 37 ++++++++++++++++++++++++-- 15 files changed, 372 insertions(+), 26 deletions(-) diff --git a/cds/container/details/lazy_list_base.h b/cds/container/details/lazy_list_base.h index 021fc1de..f21b4594 100644 --- a/cds/container/details/lazy_list_base.h +++ b/cds/container/details/lazy_list_base.h @@ -149,7 +149,7 @@ namespace cds { namespace container { To enable it use \p lazy_list::stat - \p opt::allocator - the allocator used for creating and freeing list's item. Default is \ref CDS_DEFAULT_ALLOCATOR macro. - \p opt::memory_model - C++ memory ordering model. Can be \p opt::v::relaxed_ordering (relaxed memory model, the default) - or \p opt::v::sequential_consistent (sequentially consisnent memory model). + or \p opt::v::sequential_consistent (sequentially consistent memory model). */ template struct make_traits { @@ -175,7 +175,7 @@ namespace cds { namespace container { // Tag for selecting lazy list implementation /** - This struct is empty and it is used only as a tag for selecting LazyList + This empty struct is used only as a tag for selecting \p LazyList as ordered list implementation in declaration of some classes. See \p split_list::traits::ordered_list as an example. diff --git a/cds/container/impl/lazy_kvlist.h b/cds/container/impl/lazy_kvlist.h index 5e449387..59947bb9 100644 --- a/cds/container/impl/lazy_kvlist.h +++ b/cds/container/impl/lazy_kvlist.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_IMPL_LAZY_KVLIST_H @@ -133,6 +133,7 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counter type typedef typename maker::key_comparator key_comparator; ///< key comparing functor typedef typename base_class::memory_model memory_model; ///< Memory ordering. See \p cds::opt::memory_model + typedef typename base_class::stat stat; ///< Internal statistics static CDS_CONSTEXPR const size_t c_nHazardPtrCount = base_class::c_nHazardPtrCount; ///< Count of hazard pointer required for the algorithm @@ -371,6 +372,13 @@ namespace cds { namespace container { LazyKVList() {} + //@cond + template >::value >> + explicit LazyKVList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Destructor clears the list ~LazyKVList() { @@ -753,6 +761,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { diff --git a/cds/container/impl/lazy_list.h b/cds/container/impl/lazy_list.h index f0d4bbf1..6b7efb57 100644 --- a/cds/container/impl/lazy_list.h +++ b/cds/container/impl/lazy_list.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_IMPL_LAZY_LIST_H @@ -140,6 +140,7 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counting policy used typedef typename maker::key_comparator key_comparator; ///< key comparison functor typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics static CDS_CONSTEXPR const size_t c_nHazardPtrCount = base_class::c_nHazardPtrCount; ///< Count of hazard pointer required for the algorithm @@ -356,6 +357,13 @@ namespace cds { namespace container { LazyList() {} + //@cond + template >::value >> + explicit LazyList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Destructor clears the list ~LazyList() { @@ -746,6 +754,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { diff --git a/cds/container/lazy_kvlist_nogc.h b/cds/container/lazy_kvlist_nogc.h index 3f0e9319..c2150836 100644 --- a/cds/container/lazy_kvlist_nogc.h +++ b/cds/container/lazy_kvlist_nogc.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_LAZY_KVLIST_NOGC_H @@ -85,6 +85,7 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counting policy used typedef typename maker::key_comparator key_comparator; ///< key comparison functor typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics static CDS_CONSTEXPR bool const c_bSort = base_class::c_bSort; ///< List type: ordered (\p true) or unordered (\p false) protected: @@ -330,6 +331,13 @@ namespace cds { namespace container { LazyKVList() {} + //@cond + template >::value >> + explicit LazyKVList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Desctructor clears the list ~LazyKVList() { @@ -522,6 +530,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list /** Post-condition: the list is empty diff --git a/cds/container/lazy_kvlist_rcu.h b/cds/container/lazy_kvlist_rcu.h index 1a3f60ec..155237c4 100644 --- a/cds/container/lazy_kvlist_rcu.h +++ b/cds/container/lazy_kvlist_rcu.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_LAZY_KVLIST_RCU_H @@ -132,6 +132,7 @@ namespace cds { namespace container { typedef typename base_class::item_counter item_counter; ///< Item counting policy used typedef typename maker::key_comparator key_comparator; ///< key comparison functor typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics typedef typename base_class::rcu_check_deadlock rcu_check_deadlock ; ///< RCU deadlock checking policy typedef typename gc::scoped_lock rcu_lock ; ///< RCU scoped lock @@ -357,6 +358,13 @@ namespace cds { namespace container { LazyKVList() {} + //@cond + template >::value >> + explicit LazyKVList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Destructor clears the list ~LazyKVList() { @@ -764,6 +772,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { diff --git a/cds/container/lazy_list_nogc.h b/cds/container/lazy_list_nogc.h index 469159d6..4227d8b3 100644 --- a/cds/container/lazy_list_nogc.h +++ b/cds/container/lazy_list_nogc.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_LAZY_LIST_NOGC_H @@ -77,11 +77,13 @@ namespace cds { namespace container { typedef T value_type; ///< Type of value stored in the list typedef Traits traits; ///< List traits - typedef typename base_class::back_off back_off; ///< Back-off strategy used - typedef typename maker::allocator_type allocator_type; ///< Allocator type used for allocate/deallocate the nodes - typedef typename base_class::item_counter item_counter; ///< Item counting policy used - typedef typename maker::key_comparator key_comparator; ///< key comparing functor - typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::back_off back_off; ///< Back-off strategy used + typedef typename maker::allocator_type allocator_type; ///< Allocator type used for allocate/deallocate the nodes + typedef typename base_class::item_counter item_counter; ///< Item counting policy used + typedef typename maker::key_comparator key_comparator; ///< key comparing functor + typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics + static CDS_CONSTEXPR bool const c_bSort = base_class::c_bSort; ///< List type: ordered (\p true) or unordered (\p false) protected: @@ -303,6 +305,13 @@ namespace cds { namespace container { LazyList() {} + //@cond + template >::value >> + explicit LazyList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Desctructor clears the list ~LazyList() { @@ -438,6 +447,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { diff --git a/cds/container/lazy_list_rcu.h b/cds/container/lazy_list_rcu.h index 49bbaaad..0c5ed541 100644 --- a/cds/container/lazy_list_rcu.h +++ b/cds/container/lazy_list_rcu.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSLIB_CONTAINER_LAZY_LIST_RCU_H @@ -136,11 +136,12 @@ namespace cds { namespace container { typedef T value_type; ///< Type of value stored in the list typedef Traits traits; ///< List traits - typedef typename base_class::back_off back_off; ///< Back-off strategy - typedef typename maker::allocator_type allocator_type; ///< Allocator type used for allocate/deallocate the nodes - typedef typename base_class::item_counter item_counter; ///< Item counting policy used - typedef typename maker::key_comparator key_comparator; ///< key compare functor - typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::back_off back_off; ///< Back-off strategy + typedef typename maker::allocator_type allocator_type; ///< Allocator type used for allocate/deallocate the nodes + typedef typename base_class::item_counter item_counter; ///< Item counting policy used + typedef typename maker::key_comparator key_comparator; ///< key compare functor + typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option + typedef typename base_class::stat stat; ///< Internal statistics typedef typename base_class::rcu_check_deadlock rcu_check_deadlock; ///< Deadlock checking policy typedef typename gc::scoped_lock rcu_lock ; ///< RCU scoped lock @@ -351,6 +352,13 @@ namespace cds { namespace container { LazyList() {} + //@cond + template >::value >> + explicit LazyList( Stat& st ) + : base_class( st ) + {} + //@endcond + /// Desctructor clears the list ~LazyList() { @@ -762,6 +770,12 @@ namespace cds { namespace container { return base_class::size(); } + /// Returns const reference to internal statistics + stat const& statistics() const + { + return base_class::statistics(); + } + /// Clears the list void clear() { diff --git a/test/unit/list/kv_lazy_dhp.cpp b/test/unit/list/kv_lazy_dhp.cpp index 38f72275..61564f41 100644 --- a/test/unit/list/kv_lazy_dhp.cpp +++ b/test/unit/list/kv_lazy_dhp.cpp @@ -159,4 +159,37 @@ namespace { test_hp( l ); } + TEST_F( LazyKVList_DHP, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyKVList list_type; + + list_type l; + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + + TEST_F( LazyKVList_DHP, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyKVList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + } // namespace diff --git a/test/unit/list/kv_lazy_hp.cpp b/test/unit/list/kv_lazy_hp.cpp index fd5f0c85..9bbd838a 100644 --- a/test/unit/list/kv_lazy_hp.cpp +++ b/test/unit/list/kv_lazy_hp.cpp @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test_kv_list_hp.h" @@ -160,4 +160,37 @@ namespace { test_hp( l ); } + TEST_F( LazyKVList_HP, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyKVList list_type; + + list_type l; + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + + TEST_F( LazyKVList_HP, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyKVList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + } // namespace diff --git a/test/unit/list/kv_lazy_nogc.cpp b/test/unit/list/kv_lazy_nogc.cpp index db732cbb..32c32558 100644 --- a/test/unit/list/kv_lazy_nogc.cpp +++ b/test/unit/list/kv_lazy_nogc.cpp @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test_kv_list_nogc.h" @@ -137,4 +137,35 @@ namespace { test_ordered_iterator( l ); } + TEST_F( LazyKVList_NOGC, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyKVList list_type; + + list_type l; + test( l ); + test_ordered_iterator( l ); + } + + TEST_F( LazyKVList_NOGC, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyKVList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test( l ); + test_ordered_iterator( l ); + } + } // namespace diff --git a/test/unit/list/lazy_dhp.cpp b/test/unit/list/lazy_dhp.cpp index 7e381c3a..3ebdcfcd 100644 --- a/test/unit/list/lazy_dhp.cpp +++ b/test/unit/list/lazy_dhp.cpp @@ -159,4 +159,38 @@ namespace { test_hp( l ); } + TEST_F( LazyList_DHP, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyList list_type; + + list_type l; + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + + TEST_F( LazyList_DHP, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + + } // namespace diff --git a/test/unit/list/lazy_hp.cpp b/test/unit/list/lazy_hp.cpp index 9189906f..a0cbbb95 100644 --- a/test/unit/list/lazy_hp.cpp +++ b/test/unit/list/lazy_hp.cpp @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test_list_hp.h" @@ -160,4 +160,37 @@ namespace { test_hp( l ); } + TEST_F( LazyList_HP, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyList list_type; + + list_type l; + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + + TEST_F( LazyList_HP, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + } // namespace diff --git a/test/unit/list/lazy_nogc.cpp b/test/unit/list/lazy_nogc.cpp index c1507445..5ec0b15d 100644 --- a/test/unit/list/lazy_nogc.cpp +++ b/test/unit/list/lazy_nogc.cpp @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test_list_nogc.h" @@ -137,4 +137,35 @@ namespace { test_ordered_iterator( l ); } + TEST_F( LazyList_NOGC, stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyList list_type; + + list_type l; + test( l ); + test_ordered_iterator( l ); + } + + TEST_F( LazyList_NOGC, wrapped_stat ) + { + struct traits: public cc::lazy_list::traits + { + typedef lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + test( l ); + test_ordered_iterator( l ); + } + } // namespace diff --git a/test/unit/list/test_kv_lazy_rcu.h b/test/unit/list/test_kv_lazy_rcu.h index 2571f3e3..fb303459 100644 --- a/test/unit/list/test_kv_lazy_rcu.h +++ b/test/unit/list/test_kv_lazy_rcu.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSUNIT_LIST_TEST_KV_LAZY_LIST_RCU_H @@ -165,10 +165,43 @@ TYPED_TEST_P( LazyKVList, mutex ) this->test_rcu( l ); } +TYPED_TEST_P( LazyKVList, stat ) +{ + struct traits: public cc::lazy_list::traits + { + typedef typename TestFixture::lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyKVList list_type; + + list_type l; + this->test_common( l ); + this->test_ordered_iterator( l ); + this->test_rcu( l ); +} + +TYPED_TEST_P( LazyKVList, wrapped_stat ) +{ + struct traits: public cc::lazy_list::traits + { + typedef typename TestFixture::lt less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyKVList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + this->test_common( l ); + this->test_ordered_iterator( l ); + this->test_rcu( l ); +} + // 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( LazyKVList, - less_ordered, compare_ordered, mix_ordered, item_counting, backoff, seq_cst, mutex + less_ordered, compare_ordered, mix_ordered, item_counting, backoff, seq_cst, mutex, stat, wrapped_stat ); #endif // CDSUNIT_LIST_TEST_KV_LAZY_LIST_RCU_H diff --git a/test/unit/list/test_lazy_rcu.h b/test/unit/list/test_lazy_rcu.h index f506d7b9..434d78f7 100644 --- a/test/unit/list/test_lazy_rcu.h +++ b/test/unit/list/test_lazy_rcu.h @@ -25,7 +25,7 @@ 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. + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CDSUNIT_LIST_TEST_LAZY_LIST_RCU_H @@ -149,6 +149,39 @@ TYPED_TEST_P( LazyList, seq_cst ) this->test_rcu( l ); } +TYPED_TEST_P( LazyList, stat ) +{ + struct traits: public cc::lazy_list::traits + { + typedef typename TestFixture::template lt< typename TestFixture::item> less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::stat<> stat; + }; + typedef cc::LazyList list_type; + + list_type l; + this->test_common( l ); + this->test_ordered_iterator( l ); + this->test_rcu( l ); +} + +TYPED_TEST_P( LazyList, wrapped_stat ) +{ + struct traits: public cc::lazy_list::traits + { + typedef typename TestFixture::template lt< typename TestFixture::item> less; + typedef cds::atomicity::item_counter item_counter; + typedef cds::container::lazy_list::wrapped_stat<> stat; + }; + typedef cc::LazyList list_type; + + cds::container::lazy_list::stat<> st; + list_type l( st ); + this->test_common( l ); + this->test_ordered_iterator( l ); + this->test_rcu( l ); +} + TYPED_TEST_P( LazyList, mutex ) { struct traits : public cc::lazy_list::traits @@ -168,7 +201,7 @@ TYPED_TEST_P( LazyList, mutex ) // 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( LazyList, - less_ordered, compare_ordered, mix_ordered, item_counting, backoff, seq_cst, mutex + less_ordered, compare_ordered, mix_ordered, item_counting, backoff, seq_cst, mutex, stat, wrapped_stat ); #endif // CDSUNIT_LIST_TEST_LAZY_LIST_RCU_H -- 2.34.1