Integrated MichaelSet<HP> + IterableList into stress tests
authorkhizmax <libcds.dev@gmail.com>
Fri, 5 Aug 2016 16:57:13 +0000 (19:57 +0300)
committerkhizmax <libcds.dev@gmail.com>
Fri, 5 Aug 2016 16:57:13 +0000 (19:57 +0300)
12 files changed:
projects/Win/vc14/cds.sln
test/include/cds_test/stat_iterable_list_out.h [new file with mode: 0644]
test/include/cds_test/stat_lazy_list_out.h [new file with mode: 0644]
test/include/cds_test/stat_michael_list_out.h [new file with mode: 0644]
test/stress/set/delodd/set_delodd_michael.cpp
test/stress/set/insdel_find/set_insdelfind_michael.cpp
test/stress/set/insdel_func/set_insdel_func_michael.cpp
test/stress/set/insdel_string/set_insdel_string_michael.cpp
test/stress/set/set_type_iterable_list.h [new file with mode: 0644]
test/stress/set/set_type_lazy_list.h
test/stress/set/set_type_michael.h
test/stress/set/set_type_michael_list.h

index 4864a99..727f5cf 100644 (file)
@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00\r
 # Visual Studio 14\r
-VisualStudioVersion = 14.0.25123.0\r
+VisualStudioVersion = 14.0.25420.1\r
 MinimumVisualStudioVersion = 10.0.40219.1\r
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cds", "cds.vcxproj", "{408FE9BC-44F0-4E6A-89FA-D6F952584239}"\r
 EndProject\r
@@ -24,6 +24,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "cds_test", "cds_test", "{3A
                ..\..\..\test\include\cds_test\stat_ellenbintree_out.h = ..\..\..\test\include\cds_test\stat_ellenbintree_out.h\r
                ..\..\..\test\include\cds_test\stat_feldman_hashset_out.h = ..\..\..\test\include\cds_test\stat_feldman_hashset_out.h\r
                ..\..\..\test\include\cds_test\stat_flat_combining_out.h = ..\..\..\test\include\cds_test\stat_flat_combining_out.h\r
+               ..\..\..\test\include\cds_test\stat_iterable_list_out.h = ..\..\..\test\include\cds_test\stat_iterable_list_out.h\r
+               ..\..\..\test\include\cds_test\stat_lazy_list_out.h = ..\..\..\test\include\cds_test\stat_lazy_list_out.h\r
+               ..\..\..\test\include\cds_test\stat_michael_list_out.h = ..\..\..\test\include\cds_test\stat_michael_list_out.h\r
                ..\..\..\test\include\cds_test\stat_skiplist_out.h = ..\..\..\test\include\cds_test\stat_skiplist_out.h\r
                ..\..\..\test\include\cds_test\stat_splitlist_out.h = ..\..\..\test\include\cds_test\stat_splitlist_out.h\r
                ..\..\..\test\include\cds_test\stat_sync_monitor_out.h = ..\..\..\test\include\cds_test\stat_sync_monitor_out.h\r
@@ -122,6 +125,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Header Files", "Header File
                ..\..\..\test\stress\set\set_type_cuckoo.h = ..\..\..\test\stress\set\set_type_cuckoo.h\r
                ..\..\..\test\stress\set\set_type_ellen_bintree.h = ..\..\..\test\stress\set\set_type_ellen_bintree.h\r
                ..\..\..\test\stress\set\set_type_feldman_hashset.h = ..\..\..\test\stress\set\set_type_feldman_hashset.h\r
+               ..\..\..\test\stress\set\set_type_iterable_list.h = ..\..\..\test\stress\set\set_type_iterable_list.h\r
                ..\..\..\test\stress\set\set_type_lazy_list.h = ..\..\..\test\stress\set\set_type_lazy_list.h\r
                ..\..\..\test\stress\set\set_type_michael.h = ..\..\..\test\stress\set\set_type_michael.h\r
                ..\..\..\test\stress\set\set_type_michael_list.h = ..\..\..\test\stress\set\set_type_michael_list.h\r
diff --git a/test/include/cds_test/stat_iterable_list_out.h b/test/include/cds_test/stat_iterable_list_out.h
new file mode 100644 (file)
index 0000000..a61449c
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+    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 CDSTEST_STAT_ITERABLE_LIST_OUT_H
+#define CDSTEST_STAT_ITERABLE_LIST_OUT_H
+
+#include <cds/intrusive/details/iterable_list_base.h>
+
+namespace cds_test {
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::iterable_list::empty_stat const& /*s*/ )
+    {
+        return o;
+    }
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::iterable_list::stat<> const& s )
+    {
+        return o
+            << CDSSTRESS_STAT_OUT( s, m_nInsertSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateNew )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateExisting )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nFindSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nFindFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nNodeCreated )
+            << CDSSTRESS_STAT_OUT( s, m_nNodeRemoved );
+    }
+
+    template <typename Stat>
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::iterable_list::wrapped_stat<Stat> const& s )
+    {
+        return o << s.m_stat;
+    }
+
+} // namespace cds_test
+
+#endif // #ifndef CDSTEST_STAT_ITERABLE_LIST_OUT_H
diff --git a/test/include/cds_test/stat_lazy_list_out.h b/test/include/cds_test/stat_lazy_list_out.h
new file mode 100644 (file)
index 0000000..55fcb8e
--- /dev/null
@@ -0,0 +1,71 @@
+/*
+    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 CDSTEST_STAT_LAZY_LIST_OUT_H
+#define CDSTEST_STAT_LAZY_LIST_OUT_H
+
+#include <cds/intrusive/details/lazy_list_base.h>
+
+namespace cds_test {
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::lazy_list::empty_stat const& /*s*/ )
+    {
+        return o;
+    }
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::lazy_list::stat<> const& s )
+    {
+        return o
+            << CDSSTRESS_STAT_OUT( s, m_nInsertSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateNew )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateExisting )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateMarked )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nFindSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nFindFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nValidationSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nValidationFailed );
+    }
+
+    template <typename Stat>
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::lazy_list::wrapped_stat<Stat> const& s )
+    {
+        return o << s.m_stat;
+    }
+
+} // namespace cds_test
+
+#endif // #ifndef CDSTEST_STAT_LAZY_LIST_OUT_H
diff --git a/test/include/cds_test/stat_michael_list_out.h b/test/include/cds_test/stat_michael_list_out.h
new file mode 100644 (file)
index 0000000..9830923
--- /dev/null
@@ -0,0 +1,71 @@
+/*
+    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 CDSTEST_STAT_MICHAEL_LIST_OUT_H
+#define CDSTEST_STAT_MICHAEL_LIST_OUT_H
+
+#include <cds/intrusive/details/michael_list_base.h>
+
+namespace cds_test {
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::michael_list::empty_stat const& /*s*/ )
+    {
+        return o;
+    }
+
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::michael_list::stat<> const& s )
+    {
+        return o
+            << CDSSTRESS_STAT_OUT( s, m_nInsertSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nInsertRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateNew )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateExisting )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nUpdateMarked )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nEraseRetry )
+            << CDSSTRESS_STAT_OUT( s, m_nFindSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nFindFailed )
+            << CDSSTRESS_STAT_OUT( s, m_nHelpingSuccess )
+            << CDSSTRESS_STAT_OUT( s, m_nHelpingFailed );
+    }
+
+    template <typename Stat>
+    static inline property_stream& operator <<( property_stream& o, cds::intrusive::michael_list::wrapped_stat<Stat> const& s )
+    {
+        return o << s.m_stat;
+    }
+
+} // namespace cds_test
+
+#endif // #ifndef CDSTEST_STAT_MICHAEL_LIST_OUT_H
index 1e2ea55..1f99c64 100644 (file)
@@ -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 "set_delodd.h"
@@ -34,5 +34,6 @@
 namespace set {
 
     CDSSTRESS_MichaelSet( Set_DelOdd_LF, run_test_extract, key_thread, size_t )
+    CDSSTRESS_MichaelIterableSet( Set_DelOdd_LF, run_test_extract, key_thread, size_t )
 
 } // namespace set
index 4be7e10..23169b5 100644 (file)
@@ -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 "set_insdelfind.h"
@@ -34,5 +34,6 @@
 namespace set {
 
     CDSSTRESS_MichaelSet( Set_InsDelFind_LF, run_test, size_t, size_t )
+    CDSSTRESS_MichaelIterableSet( Set_InsDelFind_LF, run_test, size_t, size_t )
 
 } // namespace set
index ead49b4..7c97e86 100644 (file)
@@ -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 "set_insdel_func.h"
@@ -34,5 +34,6 @@
 namespace set {
 
     CDSSTRESS_MichaelSet( Set_InsDel_func_LF, run_test, size_t, value )
+    CDSSTRESS_MichaelIterableSet( Set_InsDel_func_LF, run_test, size_t, value )
 
 } // namespace set
index 26561cc..4a209aa 100644 (file)
@@ -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 "set_insdel_string.h"
@@ -34,5 +34,6 @@
 namespace set {
 
     CDSSTRESS_MichaelSet( Set_InsDel_string_LF, run_test_extract, std::string, size_t )
+    CDSSTRESS_MichaelIterableSet( Set_InsDel_string_LF, run_test_extract, std::string, size_t )
 
 } // namespace set
diff --git a/test/stress/set/set_type_iterable_list.h b/test/stress/set/set_type_iterable_list.h
new file mode 100644 (file)
index 0000000..3462e29
--- /dev/null
@@ -0,0 +1,141 @@
+/*
+    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_TYPE_ITRERABLE_LIST_H
+#define CDSUNIT_SET_TYPE_ITRERABLE_LIST_H
+
+#include "set_type.h"
+
+#include <cds/container/iterable_list_hp.h>
+#include <cds/container/iterable_list_dhp.h>
+//#include <cds/container/michael_list_rcu.h>
+
+namespace set {
+
+    template <typename Key, typename Val>
+    struct iterable_list_type
+    {
+        typedef typename set_type_base< Key, Val >::key_val key_val;
+        typedef typename set_type_base< Key, Val >::compare compare;
+        typedef typename set_type_base< Key, Val >::less    less;
+
+        struct traits_IterableList_cmp_stdAlloc:
+            public cc::iterable_list::make_traits<
+                co::compare< compare >
+            >::type
+        {};
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_cmp_stdAlloc > IterableList_HP_cmp_stdAlloc;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_cmp_stdAlloc > IterableList_DHP_cmp_stdAlloc;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_cmp_stdAlloc > IterableList_RCU_GPI_cmp_stdAlloc;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_cmp_stdAlloc > IterableList_RCU_GPB_cmp_stdAlloc;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_cmp_stdAlloc > IterableList_RCU_GPT_cmp_stdAlloc;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_cmp_stdAlloc > IterableList_RCU_SHB_cmp_stdAlloc;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_cmp_stdAlloc > IterableList_RCU_SHT_cmp_stdAlloc;
+#endif
+
+        struct traits_IterableList_cmp_stdAlloc_stat: public traits_IterableList_cmp_stdAlloc
+        {
+            typedef cc::iterable_list::stat<> stat;
+        };
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_HP_cmp_stdAlloc_stat;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_DHP_cmp_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_RCU_GPI_cmp_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_RCU_GPB_cmp_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_RCU_SHB_cmp_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_cmp_stdAlloc_stat > IterableList_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
+        struct traits_IterableList_cmp_stdAlloc_seqcst : public traits_IterableList_cmp_stdAlloc
+        {
+            typedef co::v::sequential_consistent memory_model;
+        };
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_HP_cmp_stdAlloc_seqcst;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_DHP_cmp_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_RCU_GPI_cmp_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_RCU_GPB_cmp_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_RCU_GPT_cmp_stdAlloc_seqcst;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_RCU_SHB_cmp_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_cmp_stdAlloc_seqcst > IterableList_RCU_SHT_cmp_stdAlloc_seqcst;
+#endif
+
+        struct traits_IterableList_less_stdAlloc :
+            public cc::iterable_list::make_traits<
+                co::less< less >
+            >::type
+        {};
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_less_stdAlloc > IterableList_HP_less_stdAlloc;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_less_stdAlloc > IterableList_DHP_less_stdAlloc;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_less_stdAlloc > IterableList_RCU_GPI_less_stdAlloc;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_less_stdAlloc > IterableList_RCU_GPB_less_stdAlloc;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_less_stdAlloc > IterableList_RCU_GPT_less_stdAlloc;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_less_stdAlloc > IterableList_RCU_SHB_less_stdAlloc;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_less_stdAlloc > IterableList_RCU_SHT_less_stdAlloc;
+#endif
+
+        struct traits_IterableList_less_stdAlloc_stat : public traits_IterableList_less_stdAlloc
+        {
+            typedef cc::iterable_list::stat<> stat;
+        };
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_less_stdAlloc_stat > IterableList_HP_less_stdAlloc_stat;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_DHP_less_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_RCU_GPI_less_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_RCU_GPB_less_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_RCU_SHB_less_stdAlloc_stat;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_less_stdAlloc_stat > IterableList_RCU_SHT_less_stdAlloc_stat;
+#endif
+
+        struct traits_IterableList_less_stdAlloc_seqcst :
+            public cc::iterable_list::make_traits<
+                co::less< less >
+                ,co::memory_model< co::v::sequential_consistent >
+            >::type
+        {};
+        typedef cc::IterableList< cds::gc::HP,  key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_HP_less_stdAlloc_seqcst;
+        typedef cc::IterableList< cds::gc::DHP, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_DHP_less_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpi, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_RCU_GPI_less_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpb, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_RCU_GPB_less_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_gpt, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_RCU_GPT_less_stdAlloc_seqcst;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef cc::IterableList< rcu_shb, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_RCU_SHB_less_stdAlloc_seqcst;
+        //typedef cc::IterableList< rcu_sht, key_val, traits_IterableList_less_stdAlloc_seqcst > IterableList_RCU_SHT_less_stdAlloc_seqcst;
+#endif
+
+    };
+
+} // namespace set
+
+#endif // #ifndef CDSUNIT_SET_TYPE_ITRERABLE_LIST_H
index 05938c4..1919090 100644 (file)
@@ -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_SET_TYPE_LAZY_LIST_H
@@ -46,7 +46,7 @@ namespace set {
         typedef typename set_type_base< Key, Val >::compare compare;
         typedef typename set_type_base< Key, Val >::less    less;
 
-                struct traits_LazyList_cmp_stdAlloc :
+        struct traits_LazyList_cmp_stdAlloc :
             public cc::lazy_list::make_traits<
                 co::compare< compare >
             >::type
@@ -60,6 +60,21 @@ namespace set {
         typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHB_cmp_stdAlloc;
         typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc > LazyList_RCU_SHT_cmp_stdAlloc;
 #endif
+
+        struct traits_LazyList_cmp_stdAlloc_stat : public traits_LazyList_cmp_stdAlloc
+        {
+            typedef cc::lazy_list::stat<> stat;
+        };
+        typedef cc::LazyList< cds::gc::HP,  key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_HP_cmp_stdAlloc_stat;
+        typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_DHP_cmp_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_RCU_GPI_cmp_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_RCU_GPB_cmp_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_RCU_SHB_cmp_stdAlloc_stat;
+        typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_cmp_stdAlloc_stat > LazyList_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
         struct traits_LazyList_cmp_stdAlloc_seqcst :
             public cc::lazy_list::make_traits<
                 co::compare< compare >
@@ -106,6 +121,20 @@ namespace set {
         typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc > LazyList_RCU_SHT_less_stdAlloc;
 #endif
 
+        struct traits_LazyList_less_stdAlloc_stat: public traits_LazyList_less_stdAlloc
+        {
+            typedef cc::lazy_list::stat<> stat;
+        };
+        typedef cc::LazyList< cds::gc::HP, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_HP_less_stdAlloc_stat;
+        typedef cc::LazyList< cds::gc::DHP, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_DHP_less_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpi, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_RCU_GPI_less_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpb, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_RCU_GPB_less_stdAlloc_stat;
+        typedef cc::LazyList< rcu_gpt, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef cc::LazyList< rcu_shb, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_RCU_SHB_less_stdAlloc_stat;
+        typedef cc::LazyList< rcu_sht, key_val, traits_LazyList_less_stdAlloc_stat > LazyList_RCU_SHT_less_stdAlloc_stat;
+#endif
+
         struct traits_LazyList_less_stdAlloc_seqcst :
             public cc::lazy_list::make_traits<
                 co::less< less >
index d14367f..a321a69 100644 (file)
@@ -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_SET_TYPE_MICHAEL_H
 
 #include "set_type_michael_list.h"
 #include "set_type_lazy_list.h"
+#include "set_type_iterable_list.h"
 
 #include <cds/container/michael_set.h>
 #include <cds/container/michael_set_rcu.h>
 
+#include <cds_test/stat_michael_list_out.h>
+#include <cds_test/stat_lazy_list_out.h>
+#include <cds_test/stat_iterable_list_out.h>
+
 #include <framework/michael_alloc.h>
 
 namespace set {
@@ -88,6 +93,16 @@ namespace set {
         typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc;
 #endif
 
+        typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
         typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc;
         typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc;
         typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc;
@@ -98,6 +113,16 @@ namespace set {
         typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc;
 #endif
 
+        typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_stat;
+#endif
+
         typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst;
         typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst;
         typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst;
@@ -150,6 +175,16 @@ namespace set {
         typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc;
 #endif
 
+        typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
         typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc;
         typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc;
         typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc;
@@ -160,6 +195,16 @@ namespace set {
         typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc;
 #endif
 
+        typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_stat;
+        typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_stat;
+#endif
+
         typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst;
         typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst;
         typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst;
@@ -189,8 +234,71 @@ namespace set {
         typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc;
         typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc;
 #endif
+
+
+        // ***************************************************************************
+        // MichaelHashSet based on IterableList
+
+        typedef iterable_list_type< Key, Val > il;
+
+        typedef MichaelHashSet< cds::gc::HP, typename il::IterableList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_HP_cmp_stdAlloc;
+        typedef MichaelHashSet< cds::gc::DHP, typename il::IterableList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_DHP_cmp_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpi, typename il::IterableList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPI_cmp_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpb, typename il::IterableList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPB_cmp_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpt, typename il::IterableList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPT_cmp_stdAlloc;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef MichaelHashSet< rcu_shb, typename il::IterableList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHB_cmp_stdAlloc;
+        //typedef MichaelHashSet< rcu_sht, typename il::IterableList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHT_cmp_stdAlloc;
+#endif
+
+        typedef MichaelHashSet< cds::gc::HP, typename il::IterableList_HP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_HP_cmp_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename il::IterableList_DHP_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_DHP_cmp_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpi, typename il::IterableList_RCU_GPI_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPI_cmp_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpb, typename il::IterableList_RCU_GPB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPB_cmp_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpt, typename il::IterableList_RCU_GPT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef MichaelHashSet< rcu_shb, typename il::IterableList_RCU_SHB_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHB_cmp_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_sht, typename il::IterableList_RCU_SHT_cmp_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
+        typedef MichaelHashSet< cds::gc::HP, typename il::IterableList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_HP_less_stdAlloc;
+        typedef MichaelHashSet< cds::gc::DHP, typename il::IterableList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_DHP_less_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpi, typename il::IterableList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPI_less_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpb, typename il::IterableList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPB_less_stdAlloc;
+        //typedef MichaelHashSet< rcu_gpt, typename il::IterableList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPT_less_stdAlloc;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef MichaelHashSet< rcu_shb, typename il::IterableList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHB_less_stdAlloc;
+        //typedef MichaelHashSet< rcu_sht, typename il::IterableList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHT_less_stdAlloc;
+#endif
+
+        typedef MichaelHashSet< cds::gc::HP, typename il::IterableList_HP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_HP_less_stdAlloc_stat;
+        typedef MichaelHashSet< cds::gc::DHP, typename il::IterableList_DHP_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_DHP_less_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpi, typename il::IterableList_RCU_GPI_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPI_less_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpb, typename il::IterableList_RCU_GPB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPB_less_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_gpt, typename il::IterableList_RCU_GPT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef MichaelHashSet< rcu_shb, typename il::IterableList_RCU_SHB_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHB_less_stdAlloc_stat;
+        //typedef MichaelHashSet< rcu_sht, typename il::IterableList_RCU_SHT_less_stdAlloc_stat, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHT_less_stdAlloc_stat;
+#endif
+
+        typedef MichaelHashSet< cds::gc::HP, typename il::IterableList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_HP_less_stdAlloc_seqcst;
+        typedef MichaelHashSet< cds::gc::DHP, typename il::IterableList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_DHP_less_stdAlloc_seqcst;
+        //typedef MichaelHashSet< rcu_gpi, typename il::IterableList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPI_less_stdAlloc_seqcst;
+        //typedef MichaelHashSet< rcu_gpb, typename il::IterableList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPB_less_stdAlloc_seqcst;
+        //typedef MichaelHashSet< rcu_gpt, typename il::IterableList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_GPT_less_stdAlloc_seqcst;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        //typedef MichaelHashSet< rcu_shb, typename il::IterableList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHB_less_stdAlloc_seqcst;
+        //typedef MichaelHashSet< rcu_sht, typename il::IterableList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Iterable_RCU_SHT_less_stdAlloc_seqcst;
+#endif
+
     };
 
+    template <typename GC, typename T, typename Traits>
+    static inline void print_stat( cds_test::property_stream& o, MichaelHashSet<GC, T, Traits> const& s )
+    {
+        o << s.statistics();
+    }
+
 } // namespace set
 
 
@@ -206,22 +314,42 @@ namespace set {
 #   define CDSSTRESS_MichaelSet_SHRCU( fixture, test_case, key_type, value_type ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_cmp_stdAlloc,             key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_cmp_stdAlloc,             key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_cmp_stdAlloc_stat,        key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_cmp_stdAlloc_stat,        key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_less_stdAlloc,            key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_less_stdAlloc,            key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_less_stdAlloc_stat,       key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_less_stdAlloc_stat,       key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_cmp_michaelAlloc,         key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_cmp_michaelAlloc,         key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHB_less_michaelAlloc,        key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_SHT_less_michaelAlloc,        key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc,        key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc,        key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc_stat,   key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc_stat,   key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_less_stdAlloc,       key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_less_stdAlloc,       key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_less_stdAlloc_stat,  key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_less_stdAlloc_stat,  key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc,    key_type, value_type, 0 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc,    key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHB_less_michaelAlloc,   key_type, value_type, 1 ) \
         CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_SHT_less_michaelAlloc,   key_type, value_type, 0 )
+
+#   define CDSSTRESS_MichaelIterableSet_SHRCU( fixture, test_case, key_type, value_type ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHB_cmp_stdAlloc,        key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHT_cmp_stdAlloc,        key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHB_cmp_stdAlloc_stat,   key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHT_cmp_stdAlloc_stat,   key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHB_less_stdAlloc,       key_type, value_type, 1 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHT_less_stdAlloc,       key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHB_less_stdAlloc_stat,  key_type, value_type, 0 ) \
+        CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_SHT_less_stdAlloc_stat,  key_type, value_type, 1 ) \
+
 #else
 #   define CDSSTRESS_MichaelSet_SHRCU( fixture, test_case, key_type, value_type )
+#   define CDSSTRESS_MichaelIterableSet_SHRCU( fixture, test_case, key_type, value_type )
 #endif
 
 
@@ -231,11 +359,21 @@ namespace set {
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPI_cmp_stdAlloc,             key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPB_cmp_stdAlloc,             key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPT_cmp_stdAlloc,             key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_HP_cmp_stdAlloc_stat,             key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_DHP_cmp_stdAlloc_stat,            key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPI_cmp_stdAlloc_stat,        key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPB_cmp_stdAlloc_stat,        key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPT_cmp_stdAlloc_stat,        key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_HP_less_stdAlloc,                 key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_DHP_less_stdAlloc,                key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPI_less_stdAlloc,            key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPB_less_stdAlloc,            key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPT_less_stdAlloc,            key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_HP_less_stdAlloc_stat,            key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_DHP_less_stdAlloc_stat,           key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPI_less_stdAlloc_stat,       key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPB_less_stdAlloc_stat,       key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPT_less_stdAlloc_stat,       key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_HP_cmp_michaelAlloc,              key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_DHP_cmp_michaelAlloc,             key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_RCU_GPI_cmp_michaelAlloc,         key_type, value_type, 0 ) \
@@ -251,11 +389,21 @@ namespace set {
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc,        key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc,        key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc,        key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_HP_cmp_stdAlloc_stat,        key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_DHP_cmp_stdAlloc_stat,       key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc_stat,   key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc_stat,   key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc_stat,   key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_HP_less_stdAlloc,            key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_DHP_less_stdAlloc,           key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPI_less_stdAlloc,       key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPB_less_stdAlloc,       key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPT_less_stdAlloc,       key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_HP_less_stdAlloc_stat,       key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_DHP_less_stdAlloc_stat,      key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPI_less_stdAlloc_stat,  key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPB_less_stdAlloc_stat,  key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPT_less_stdAlloc_stat,  key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_HP_cmp_michaelAlloc,         key_type, value_type, 0 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_DHP_cmp_michaelAlloc,        key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc,    key_type, value_type, 0 ) \
@@ -268,4 +416,27 @@ namespace set {
     CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Lazy_RCU_GPT_less_michaelAlloc,   key_type, value_type, 1 ) \
     CDSSTRESS_MichaelSet_SHRCU( fixture, test_case, key_type, value_type )
 
+#define CDSSTRESS_MichaelIterableSet( fixture, test_case, key_type, value_type ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_HP_cmp_stdAlloc,             key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_DHP_cmp_stdAlloc,            key_type, value_type, 1 ) \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPI_cmp_stdAlloc,        key_type, value_type, 0 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPB_cmp_stdAlloc,        key_type, value_type, 1 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPT_cmp_stdAlloc,        key_type, value_type, 0 )*/ \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_HP_cmp_stdAlloc_stat,        key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_DHP_cmp_stdAlloc_stat,       key_type, value_type, 0 ) \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPI_cmp_stdAlloc_stat,   key_type, value_type, 1 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPB_cmp_stdAlloc_stat,   key_type, value_type, 0 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPT_cmp_stdAlloc_stat,   key_type, value_type, 1 )*/ \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_HP_less_stdAlloc,            key_type, value_type, 1 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_DHP_less_stdAlloc,           key_type, value_type, 0 ) \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPI_less_stdAlloc,       key_type, value_type, 1 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPB_less_stdAlloc,       key_type, value_type, 0 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPT_less_stdAlloc,       key_type, value_type, 1 )*/ \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_HP_less_stdAlloc_stat,       key_type, value_type, 0 ) \
+    CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_DHP_less_stdAlloc_stat,      key_type, value_type, 1 ) \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPI_less_stdAlloc_stat,  key_type, value_type, 0 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPB_less_stdAlloc_stat,  key_type, value_type, 1 )*/ \
+    /*CDSSTRESS_MichaelSet_case( fixture, test_case, MichaelSet_Iterable_RCU_GPT_less_stdAlloc_stat,  key_type, value_type, 0 )*/ \
+    /*CDSSTRESS_MichaelIterableSet_SHRCU( fixture, test_case, key_type, value_type )*/
+
 #endif // #ifndef CDSUNIT_SET_TYPE_MICHAEL_H
index 5ba2d55..ae480c9 100644 (file)
@@ -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_SET_TYPE_MICHAEL_LIST_H
@@ -61,6 +61,20 @@ namespace set {
         typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc > MichaelList_RCU_SHT_cmp_stdAlloc;
 #endif
 
+        struct traits_MichaelList_cmp_stdAlloc_stat: public traits_MichaelList_cmp_stdAlloc
+        {
+            typedef cc::michael_list::stat<> stat;
+        };
+        typedef cc::MichaelList< cds::gc::HP,  key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_HP_cmp_stdAlloc_stat;
+        typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_DHP_cmp_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_RCU_GPI_cmp_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_RCU_GPB_cmp_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_RCU_GPT_cmp_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_RCU_SHB_cmp_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_cmp_stdAlloc_stat > MichaelList_RCU_SHT_cmp_stdAlloc_stat;
+#endif
+
         struct traits_MichaelList_cmp_stdAlloc_seqcst : public traits_MichaelList_cmp_stdAlloc
         {
             typedef co::v::sequential_consistent memory_model;
@@ -90,6 +104,20 @@ namespace set {
         typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc > MichaelList_RCU_SHT_less_stdAlloc;
 #endif
 
+        struct traits_MichaelList_less_stdAlloc_stat : public traits_MichaelList_less_stdAlloc
+        {
+            typedef cc::michael_list::stat<> stat;
+        };
+        typedef cc::MichaelList< cds::gc::HP,  key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_HP_less_stdAlloc_stat;
+        typedef cc::MichaelList< cds::gc::DHP, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_DHP_less_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpi, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_RCU_GPI_less_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpb, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_RCU_GPB_less_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_gpt, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_RCU_GPT_less_stdAlloc_stat;
+#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
+        typedef cc::MichaelList< rcu_shb, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_RCU_SHB_less_stdAlloc_stat;
+        typedef cc::MichaelList< rcu_sht, key_val, traits_MichaelList_less_stdAlloc_stat > MichaelList_RCU_SHT_less_stdAlloc_stat;
+#endif
+
         struct traits_MichaelList_less_stdAlloc_seqcst :
             public cc::michael_list::make_traits<
                 co::less< less >