Merge branch 'flat_combinig_add_stress_and_unint_tests' of https://github.com/mgalimu...

diff --git a/.gitignore b/.gitignore
index 93cba7860eb30e684bc00d1b16c93a2fd837d755..757121b55bdd1273350ff6450b2ebb9777e7260a 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,5 @@
 /build/Makefile
 /build/build.sh
 /build/sample
+/.cproject
+/.settings/

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 40cd904ec7e07700054a0e9ccaa8bbe964d955c0..dd8778d1b5e8da663f942a01d2cb8a1db6f445b9 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -55,7 +55,7 @@ if(WITH_TESTS_COVERAGE)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
     message(STATUS "Test coverage analysis: activated")
   else()
-       message(WARNING "Compiler is not GNU gcc! Test coverage couldn't be analyzed")
+    message(WARNING "Compiler is not GNU gcc! Test coverage couldn't be analyzed")
   endif()  
 endif(WITH_TESTS_COVERAGE)
 

diff --git a/test/include/cds_test/fc_hevy_value.h b/test/include/cds_test/fc_hevy_value.h
new file mode 100644 (file)
index 0000000..ba3fc26
--- /dev/null
+++ b/test/include/cds_test/fc_hevy_value.h
@@ -0,0 +1,70 @@
+/*
+ * fc_hevy_value.h
+ *
+ *  Created on: 31 авг. 2016 г.
+ *      Author: marsel
+ */
+
+#ifndef SOURCE_DIRECTORY__TEST_INCLUDE_CDS_TEST_FC_HEAVY_VALUE_H_
+#define SOURCE_DIRECTORY__TEST_INCLUDE_CDS_TEST_FC_HEAVY_VALUE_H_
+
+#include <math.h>
+#include <vector>
+
+namespace fc_test {
+
+    // SFINAE test
+    template <typename T>
+    class has_set_array_size {
+        typedef char small;
+        class big{char dummy[2];};
+
+        template <typename C, void (C::*) (size_t)> class SFINAE {};
+
+        template <typename C> static small test( SFINAE<C, &C::set_array> * ) ;
+        template <typename C> static big   test(...);
+
+    public:
+        static constexpr bool value = sizeof(test<T>(0)) == sizeof(char) ;
+    };
+
+    template<int DefaultSize = 10>
+    struct heavy_value {
+
+        int value;
+
+        size_t nNo;
+        size_t nWriterNo;
+
+        static std::vector<int> pop_buff;
+        static size_t buffer_size;
+
+        explicit heavy_value(int new_value = 0)
+        : value(new_value),
+          nNo(0),
+          nWriterNo(0)
+        {
+        };
+        heavy_value(const heavy_value &other)
+            : value(other.value),
+              nNo(other.nNo),
+              nWriterNo(other.nWriterNo)
+        {
+            for(size_t i = 0; i < buffer_size; ++i)
+                pop_buff[i] =  static_cast<int>(std::sqrt(other.pop_buff[i]*rand()));
+        }
+        void set_array(size_t new_size) {
+            set_array_size(new_size);
+        }
+        static void set_array_size(size_t new_size){
+            if (buffer_size == new_size) return;
+            buffer_size = new_size;
+            pop_buff.resize(buffer_size, rand());
+        }
+    };
+    template<int DefaultSize>
+    std::vector<int> heavy_value< DefaultSize >::pop_buff(DefaultSize, rand());
+    template<int DefaultSize>
+    std::vector<int>::size_type heavy_value< DefaultSize >::buffer_size = DefaultSize;
+}
+#endif /* SOURCE_DIRECTORY__TEST_INCLUDE_CDS_TEST_FC_HEVY_VALUE_H_ */

diff --git a/test/stress/data/test-debug.conf b/test/stress/data/test-debug.conf
index c9f9a9392212bf77c56290bb050cec0d2140852e..d1b19626fbe7a48f671fe95a5c71310d946433ed 100644 (file)
--- a/test/stress/data/test-debug.conf
+++ b/test/stress/data/test-debug.conf
@@ -62,6 +62,8 @@ SegmentedQueue_SegmentSize=64
 ProducerCount=3\r
 ConsumerCount=3\r
 QueueSize=100000\r
+# HeavyValueSize - size of value for flat cobining containers, default 100\r
+# HeavyValueSize=100\r
 # SegmentedQueue parameters:\r
 # SegmentedQueue_Iterate: \r
 #    1 - run test iteratively for segment size from 4 up to SegmentedQueue_SegmentSize\r

diff --git a/test/stress/data/test.conf b/test/stress/data/test.conf
index db48a8352634dd0df9527dccc30c3cab8e32acdd..35449f8e4de0963524baf8f28055234f9ba67594 100644 (file)
--- a/test/stress/data/test.conf
+++ b/test/stress/data/test.conf
@@ -62,6 +62,8 @@ SegmentedQueue_SegmentSize=256
 ConsumerCount=4\r
 ProducerCount=4\r
 QueueSize=5000000\r
+# HeavyValueSize - size of value for flat cobining containers, default 100\r
+# HeavyValueSize=100\r
 # SegmentedQueue parameters:\r
 # SegmentedQueue_Iterate: \r
 #    1 - run test iteratively for segment size from 4 up to SegmentedQueue_SegmentSize\r

diff --git a/test/stress/queue/push_pop.cpp b/test/stress/queue/push_pop.cpp
index cdae1168a1d000e805351162b5249ade2512afdb..7c754c3624a31c901abf3f8e4952f47eb0bb7717 100644 (file)
--- a/test/stress/queue/push_pop.cpp
+++ b/test/stress/queue/push_pop.cpp
@@ -32,6 +32,7 @@
 
 #include <vector>
 #include <algorithm>
+#include <type_traits>
 
 // Multi-threaded queue push/pop test
 namespace {
@@ -39,17 +40,21 @@ namespace {
     static size_t s_nConsumerThreadCount = 4;
     static size_t s_nProducerThreadCount = 4;
     static size_t s_nQueueSize = 4000000;
+    static size_t s_nHeavyValueSize = 100;
 
     static std::atomic<size_t> s_nProducerDone( 0 );
 
+    struct old_value
+    {
+        size_t nNo;
+        size_t nWriterNo;
+    };
+
+    template<class Value = old_value>
     class queue_push_pop: public cds_test::stress_fixture
     {
     protected:
-        struct value_type
-        {
-            size_t      nNo;
-            size_t      nWriterNo;
-        };
+       using value_type = Value;
 
         enum {
             producer_thread,
@@ -298,6 +303,20 @@ namespace {
             propout() << q.statistics();
         }
 
+    private:
+        static void set_array_size( size_t size ) {
+            const bool tmp = fc_test::has_set_array_size<value_type>::value;
+            set_array_size(size, std::integral_constant<bool, tmp>());
+        }
+
+        static void set_array_size(size_t size, std::true_type){
+            value_type::set_array_size(size);
+        }
+
+        static void set_array_size(size_t, std::false_type)
+        {
+        }
+
     public:
         static void SetUpTestCase()
         {
@@ -306,6 +325,7 @@ namespace {
             s_nConsumerThreadCount = cfg.get_size_t( "ConsumerCount", s_nConsumerThreadCount );
             s_nProducerThreadCount = cfg.get_size_t( "ProducerCount", s_nProducerThreadCount );
             s_nQueueSize = cfg.get_size_t( "QueueSize", s_nQueueSize );
+            s_nHeavyValueSize = cfg.get_size_t( "HeavyValueSize", s_nHeavyValueSize );
 
             if ( s_nConsumerThreadCount == 0u )
                 s_nConsumerThreadCount = 1;
@@ -313,19 +333,27 @@ namespace {
                 s_nProducerThreadCount = 1;
             if ( s_nQueueSize == 0u )
                 s_nQueueSize = 1000;
+            if ( s_nHeavyValueSize == 0 )
+                s_nHeavyValueSize = 1;
+
+            set_array_size( s_nHeavyValueSize );
         }
 
         //static void TearDownTestCase();
     };
 
-    CDSSTRESS_MSQueue( queue_push_pop )
-    CDSSTRESS_MoirQueue( queue_push_pop )
-    CDSSTRESS_BasketQueue( queue_push_pop )
-    CDSSTRESS_OptimsticQueue( queue_push_pop )
-    CDSSTRESS_FCQueue( queue_push_pop )
-    CDSSTRESS_FCDeque( queue_push_pop )
-    CDSSTRESS_RWQueue( queue_push_pop )
-    CDSSTRESS_StdQueue( queue_push_pop )
+    using fc_with_heavy_value = queue_push_pop< fc_test::heavy_value<36000> >;
+    using simple_queue_push_pop = queue_push_pop<>;
+
+    CDSSTRESS_MSQueue( simple_queue_push_pop )
+    CDSSTRESS_MoirQueue( simple_queue_push_pop )
+    CDSSTRESS_BasketQueue( simple_queue_push_pop )
+    CDSSTRESS_OptimsticQueue( simple_queue_push_pop )
+    CDSSTRESS_FCQueue( simple_queue_push_pop )
+    CDSSTRESS_FCDeque( simple_queue_push_pop )
+    CDSSTRESS_FCDeque_HeavyValue( fc_with_heavy_value )
+    CDSSTRESS_RWQueue( simple_queue_push_pop )
+    CDSSTRESS_StdQueue( simple_queue_push_pop )
 
 #undef CDSSTRESS_Queue_F
 #define CDSSTRESS_Queue_F( test_fixture, type_name, level ) \
@@ -337,7 +365,7 @@ namespace {
         test( queue ); \
     }
 
-    CDSSTRESS_VyukovQueue( queue_push_pop )
+    CDSSTRESS_VyukovQueue( simple_queue_push_pop )
 
 #undef CDSSTRESS_Queue_F
 
@@ -346,10 +374,10 @@ namespace {
     // SegmentedQueue test
 
     class segmented_queue_push_pop
-        : public queue_push_pop
+        : public queue_push_pop<>
         , public ::testing::WithParamInterface< size_t >
     {
-        typedef queue_push_pop base_class;
+        typedef queue_push_pop<> base_class;
 
     protected:
 
@@ -376,8 +404,7 @@ namespace {
             if ( bIterative && quasi_factor > 4 ) {
                 for ( size_t qf = 4; qf <= quasi_factor; qf *= 2 )
                     args.push_back( qf );
-            }
-            else {
+            } else {
                 if ( quasi_factor > 2 )
                     args.push_back( quasi_factor );
                 else

diff --git a/test/stress/queue/queue_type.h b/test/stress/queue/queue_type.h
index ad85e09e38488bc518d547b164bb3ca9e3a83d4e..3a8af179cd7f3428bf22dfeddfe630a5aff61647 100644 (file)
--- a/test/stress/queue/queue_type.h
+++ b/test/stress/queue/queue_type.h
@@ -51,6 +51,8 @@
 
 #include <cds_test/stress_test.h>
 #include <cds_test/stat_flat_combining_out.h>
+#include <cds_test/fc_hevy_value.h>
+
 #include "print_stat.h"
 
 namespace queue {
@@ -126,6 +128,56 @@ namespace queue {
 
     } // namespace details
 
+namespace fc_details{
+// FCDeque
+        struct traits_FCDeque_stat:
+            public cds::container::fcdeque::make_traits<
+                cds::opt::stat< cds::container::fcdeque::stat<> >
+            >::type
+        {};
+        struct traits_FCDeque_elimination:
+            public cds::container::fcdeque::make_traits<
+                cds::opt::enable_elimination< true >
+            >::type
+        {};
+        struct traits_FCDeque_elimination_stat:
+            public cds::container::fcdeque::make_traits<
+                cds::opt::stat< cds::container::fcdeque::stat<> >,
+                cds::opt::enable_elimination< true >
+            >::type
+        {};
+        struct traits_FCDeque_mutex:
+            public cds::container::fcdeque::make_traits<
+                cds::opt::lock_type< std::mutex >
+            >::type
+        {};
+
+        struct traits_FCDeque_wait_ss: cds::container::fcdeque::traits
+        {
+            typedef cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<> wait_strategy;
+        };
+        struct traits_FCDeque_wait_ss_stat: traits_FCDeque_wait_ss
+        {
+            typedef cds::container::fcdeque::stat<> stat;
+        };
+        struct traits_FCDeque_wait_sm: cds::container::fcdeque::traits
+        {
+            typedef cds::algo::flat_combining::wait_strategy::single_mutex_multi_condvar<> wait_strategy;
+        };
+        struct traits_FCDeque_wait_sm_stat: traits_FCDeque_wait_sm
+        {
+            typedef cds::container::fcdeque::stat<> stat;
+        };
+        struct traits_FCDeque_wait_mm: cds::container::fcdeque::traits
+        {
+            typedef cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<> wait_strategy;
+        };
+        struct traits_FCDeque_wait_mm_stat: traits_FCDeque_wait_mm
+        {
+            typedef cds::container::fcdeque::stat<> stat;
+        };
+
+}
     template <typename Value>
     struct Types {
 
@@ -354,87 +406,40 @@ namespace queue {
         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination_stat > FCQueue_list_elimination_stat;
 
 
-   // FCDeque
-        struct traits_FCDeque_stat:
-            public cds::container::fcdeque::make_traits<
-                cds::opt::stat< cds::container::fcdeque::stat<> >
-            >::type
-        {};
-        struct traits_FCDeque_elimination:
-            public cds::container::fcdeque::make_traits<
-                cds::opt::enable_elimination< true >
-            >::type
-        {};
-        struct traits_FCDeque_elimination_stat:
-            public cds::container::fcdeque::make_traits<
-                cds::opt::stat< cds::container::fcdeque::stat<> >,
-                cds::opt::enable_elimination< true >
-            >::type
-        {};
-        struct traits_FCDeque_mutex:
-            public cds::container::fcdeque::make_traits<
-                cds::opt::lock_type< std::mutex >
-            >::type
-        {};
-
-        struct traits_FCDeque_wait_ss: cds::container::fcdeque::traits
-        {
-            typedef cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<> wait_strategy;
-        };
-        struct traits_FCDeque_wait_ss_stat: traits_FCDeque_wait_ss
-        {
-            typedef cds::container::fcdeque::stat<> stat;
-        };
-        struct traits_FCDeque_wait_sm: cds::container::fcdeque::traits
-        {
-            typedef cds::algo::flat_combining::wait_strategy::single_mutex_multi_condvar<> wait_strategy;
-        };
-        struct traits_FCDeque_wait_sm_stat: traits_FCDeque_wait_sm
-        {
-            typedef cds::container::fcdeque::stat<> stat;
-        };
-        struct traits_FCDeque_wait_mm: cds::container::fcdeque::traits
-        {
-            typedef cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<> wait_strategy;
-        };
-        struct traits_FCDeque_wait_mm_stat: traits_FCDeque_wait_mm
-        {
-            typedef cds::container::fcdeque::stat<> stat;
-        };
 
         typedef details::FCDequeL< Value > FCDequeL_default;
-        typedef details::FCDequeL< Value, traits_FCDeque_mutex > FCDequeL_mutex;
-        typedef details::FCDequeL< Value, traits_FCDeque_stat > FCDequeL_stat;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_ss > FCDequeL_wait_ss;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_ss_stat > FCDequeL_wait_ss_stat;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_sm > FCDequeL_wait_sm;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_sm_stat > FCDequeL_wait_sm_stat;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_mm > FCDequeL_wait_mm;
-        typedef details::FCDequeL< Value, traits_FCDeque_wait_mm_stat > FCDequeL_wait_mm_stat;
-        typedef details::FCDequeL< Value, traits_FCDeque_elimination > FCDequeL_elimination;
-        typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat > FCDequeL_elimination_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_mutex > FCDequeL_mutex;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_stat > FCDequeL_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_ss > FCDequeL_wait_ss;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_ss_stat > FCDequeL_wait_ss_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_sm > FCDequeL_wait_sm;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_sm_stat > FCDequeL_wait_sm_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_mm > FCDequeL_wait_mm;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_mm_stat > FCDequeL_wait_mm_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination > FCDequeL_elimination;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination_stat > FCDequeL_elimination_stat;
 
         typedef details::FCDequeL< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeL_boost;
-        typedef details::FCDequeL< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_boost_stat;
-        typedef details::FCDequeL< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_boost_elimination;
-        typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_boost_elimination_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_boost_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_boost_elimination;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_boost_elimination_stat;
 
         typedef details::FCDequeR< Value > FCDequeR_default;
-        typedef details::FCDequeR< Value, traits_FCDeque_mutex > FCDequeR_mutex;
-        typedef details::FCDequeR< Value, traits_FCDeque_stat > FCDequeR_stat;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_ss > FCDequeR_wait_ss;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_ss_stat > FCDequeR_wait_ss_stat;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_sm > FCDequeR_wait_sm;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_sm_stat > FCDequeR_wait_sm_stat;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_mm > FCDequeR_wait_mm;
-        typedef details::FCDequeR< Value, traits_FCDeque_wait_mm_stat > FCDequeR_wait_mm_stat;
-        typedef details::FCDequeR< Value, traits_FCDeque_elimination > FCDequeR_elimination;
-        typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat > FCDequeR_elimination_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_mutex > FCDequeR_mutex;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_stat > FCDequeR_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_ss > FCDequeR_wait_ss;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_ss_stat > FCDequeR_wait_ss_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_sm > FCDequeR_wait_sm;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_sm_stat > FCDequeR_wait_sm_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_mm > FCDequeR_wait_mm;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_mm_stat > FCDequeR_wait_mm_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination > FCDequeR_elimination;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination_stat > FCDequeR_elimination_stat;
 
         typedef details::FCDequeR< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeR_boost;
-        typedef details::FCDequeR< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_boost_stat;
-        typedef details::FCDequeR< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_boost_elimination;
-        typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_boost_elimination_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_boost_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_boost_elimination;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_boost_elimination_stat;
 
         // STL
         typedef StdQueue_deque<Value>               StdQueue_deque_Spinlock;
@@ -491,6 +496,43 @@ namespace queue {
         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_DHP_mutex_padding;
         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_DHP_mutex_stat;
     };
+
+    template <typename Value>
+    struct TypesFCHeavyValue {
+        typedef details::FCDequeL< Value > FCDequeL_HeavyValue_default;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_mutex > FCDequeL_HeavyValue_mutex;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_stat > FCDequeL_HeavyValue_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_ss > FCDequeL_HeavyValue_wait_ss;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_ss_stat > FCDequeL_HeavyValue_wait_ss_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_sm > FCDequeL_HeavyValue_wait_sm;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_sm_stat > FCDequeL_HeavyValue_wait_sm_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_mm > FCDequeL_HeavyValue_wait_mm;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_wait_mm_stat > FCDequeL_HeavyValue_wait_mm_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination > FCDequeL_HeavyValue_elimination;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination_stat > FCDequeL_HeavyValue_elimination_stat;
+
+        typedef details::FCDequeL< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeL_HeavyValue_boost;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_HeavyValue_boost_stat;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_HeavyValue_boost_elimination;
+        typedef details::FCDequeL< Value, fc_details::traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_HeavyValue_boost_elimination_stat;
+
+        typedef details::FCDequeR< Value > FCDequeR_HeavyValue_default;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_mutex > FCDequeR_HeavyValue_mutex;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_stat > FCDequeR_HeavyValue_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_ss > FCDequeR_HeavyValue_wait_ss;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_ss_stat > FCDequeR_HeavyValue_wait_ss_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_sm > FCDequeR_HeavyValue_wait_sm;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_sm_stat > FCDequeR_HeavyValue_wait_sm_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_mm > FCDequeR_HeavyValue_wait_mm;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_wait_mm_stat > FCDequeR_HeavyValue_wait_mm_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination > FCDequeR_HeavyValue_elimination;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination_stat > FCDequeR_HeavyValue_elimination_stat;
+
+        typedef details::FCDequeR< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeR_HeavyValue_boost;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_HeavyValue_boost_stat;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_HeavyValue_boost_elimination;
+        typedef details::FCDequeR< Value, fc_details::traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_HeavyValue_boost_elimination_stat;
+    };
 }
 
 
@@ -546,6 +588,15 @@ namespace cds_test {
         test( queue ); \
     }
 
+#define CDSSTRESS_FCQueue_F( test_fixture, type_name, level ) \
+    TEST_F( test_fixture, type_name ) \
+    { \
+        if ( !check_detail_level( level )) return; \
+        typedef queue::TypesFCHeavyValue< value_type >::type_name queue_type; \
+        queue_type queue; \
+        test( queue ); \
+    }
+
 #define CDSSTRESS_MSQueue( test_fixture ) \
     CDSSTRESS_Queue_F( test_fixture, MSQueue_HP,                0 ) \
     CDSSTRESS_Queue_F( test_fixture, MSQueue_HP_seqcst,         2 ) \
@@ -608,11 +659,12 @@ namespace cds_test {
     CDSSTRESS_Queue_F( test_fixture, FCQueue_list_elimination,      1 ) \
     CDSSTRESS_Queue_F( test_fixture, FCQueue_list_elimination_stat, 0 )
 
+
 #define CDSSTRESS_FCDeque( test_fixture ) \
     CDSSTRESS_Queue_F( test_fixture, FCDequeL_default,              0 ) \
-    CDSSTRESS_Queue_F( test_fixture, FCDequeL_mutex,                0 ) \
-    CDSSTRESS_Queue_F( test_fixture, FCDequeL_stat,                 0 ) \
-    CDSSTRESS_Queue_F( test_fixture, FCDequeL_wait_ss,              1 ) \
+    CDSSTRESS_Queue_F( test_fixture, FCDequeL_mutex,                1 ) \
+    CDSSTRESS_Queue_F( test_fixture, FCDequeL_stat,                 1 ) \
+    CDSSTRESS_Queue_F( test_fixture, FCDequeL_wait_ss,              1 )\
     CDSSTRESS_Queue_F( test_fixture, FCDequeL_wait_ss_stat,         0 ) \
     CDSSTRESS_Queue_F( test_fixture, FCDequeL_wait_sm,              1 ) \
     CDSSTRESS_Queue_F( test_fixture, FCDequeL_wait_sm_stat,         0 ) \
@@ -640,6 +692,38 @@ namespace cds_test {
     CDSSTRESS_Queue_F( test_fixture, FCDequeR_boost_elimination,    1 ) \
     CDSSTRESS_Queue_F( test_fixture, FCDequeR_boost_elimination_stat, 1 )
 
+#define CDSSTRESS_FCDeque_HeavyValue( test_fixture ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_default,              0 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_mutex,                0 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_stat,                 0 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_ss,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_ss_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_sm,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_sm_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_mm,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_wait_mm_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_elimination,          1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_elimination_stat,     1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_boost,                1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_boost_stat,           1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_boost_elimination,    1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeL_HeavyValue_boost_elimination_stat, 1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_default,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_mutex,                1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_stat,                 1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_ss,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_ss_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_sm,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_sm_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_mm,              1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_wait_mm_stat,         1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_elimination,          1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_elimination_stat,     1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_boost,                1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_boost_stat,           1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_boost_elimination,    1 ) \
+    CDSSTRESS_FCQueue_F( test_fixture, FCDequeR_HeavyValue_boost_elimination_stat, 1 )
+
 #define CDSSTRESS_RWQueue( test_fixture ) \
     CDSSTRESS_Queue_F( test_fixture, RWQueue_Spin,      0 ) \
     CDSSTRESS_Queue_F( test_fixture, RWQueue_Spin_ic,   1 ) \

diff --git a/test/unit/queue/fcqueue.cpp b/test/unit/queue/fcqueue.cpp
index 5403046cf9c7715544a80db5b1c263c2aeadd739..3a553ab2a96c76fd8b65faeb3a1b003b01e514ab 100644 (file)
--- a/test/unit/queue/fcqueue.cpp
+++ b/test/unit/queue/fcqueue.cpp
@@ -30,6 +30,7 @@
 
 #include <gtest/gtest.h>
 #include <cds/container/fcqueue.h>
+#include <test/include/cds_test/fc_hevy_value.h>
 
 #include <list>
 
@@ -166,6 +167,67 @@ namespace {
         test( q );
     }
 
+    TEST_F( FCQueue, std_deque_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType> queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_empty_wait_strategy_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::empty >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_single_mutex_single_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_single_mutex_multi_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_multi_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_multi_mutex_multi_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
     TEST_F( FCQueue, std_single_mutex_single_condvar )
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,