tests/unit/queue/queue_type.h

   1 //$$CDS-header$$
   2
   3 #ifndef CDSUNIT_QUEUE_TYPES_H
   4 #define CDSUNIT_QUEUE_TYPES_H
   5
   6 #include <cds/container/msqueue.h>
   7 #include <cds/container/moir_queue.h>
   8 #include <cds/container/rwqueue.h>
   9 #include <cds/container/optimistic_queue.h>
  10 #include <cds/container/tsigas_cycle_queue.h>
  11 #include <cds/container/vyukov_mpmc_cycle_queue.h>
  12 #include <cds/container/basket_queue.h>
  13 #include <cds/container/fcqueue.h>
  14 #include <cds/container/fcdeque.h>
  15 #include <cds/container/segmented_queue.h>
  16
  17 #include <cds/gc/hp.h>
  18 #include <cds/gc/dhp.h>
  19
  20 #include "queue/std_queue.h"
  21 #include "lock/win32_lock.h"
  22 #include "michael_alloc.h"
  23 #include "print_segmentedqueue_stat.h"
  24
  25 #include <boost/container/deque.hpp>
  26
  27 namespace queue {
  28     namespace details {
  29         template <typename T, typename Traits=cds::container::fcdeque::traits, class Deque=std::deque<T> >
  30         class FCDequeL: public cds::container::FCDeque<T, Deque, Traits >
  31         {
  32             typedef cds::container::FCDeque<T, Deque, Traits > base_class;
  33         public:
  34             FCDequeL()
  35             {}
  36
  37             FCDequeL(
  38                 unsigned int nCompactFactor     ///< Flat combining: publication list compacting factor
  39                 ,unsigned int nCombinePassCount ///< Flat combining: number of combining passes for combiner thread
  40                 )
  41                 : base_class( nCompactFactor, nCombinePassCount )
  42             {}
  43
  44             bool push( T const& v )
  45             {
  46                 return base_class::push_front( v );
  47             }
  48             bool enqueue( T const& v )
  49             {
  50                 return push( v );
  51             }
  52
  53             bool pop( T& v )
  54             {
  55                 return base_class::pop_back( v );
  56             }
  57             bool deque( T& v )
  58             {
  59                 return pop(v);
  60             }
  61         };
  62
  63         template <typename T, typename Traits=cds::container::fcdeque::traits, class Deque = std::deque<T> >
  64         class FCDequeR: public cds::container::FCDeque<T, Deque, Traits >
  65         {
  66             typedef cds::container::FCDeque<T, Deque, Traits > base_class;
  67         public:
  68             FCDequeR()
  69             {}
  70
  71             FCDequeR(
  72                 unsigned int nCompactFactor     ///< Flat combining: publication list compacting factor
  73                 ,unsigned int nCombinePassCount ///< Flat combining: number of combining passes for combiner thread
  74                 )
  75                 : base_class( nCompactFactor, nCombinePassCount )
  76             {}
  77
  78             bool push( T const& v )
  79             {
  80                 return base_class::push_back( v );
  81             }
  82             bool enqueue( T const& v )
  83             {
  84                 return push( v );
  85             }
  86
  87             bool pop( T& v )
  88             {
  89                 return base_class::pop_front( v );
  90             }
  91             bool deque( T& v )
  92             {
  93                 return pop(v);
  94             }
  95         };
  96
  97     } // namespace details
  98
  99     template <typename Value>
 100     struct Types {
 101
 102         // MSQueue
 103         typedef cds::container::MSQueue<cds::gc::HP,  Value > MSQueue_HP;
 104         typedef cds::container::MSQueue<cds::gc::DHP, Value > MSQueue_DHP;
 105         typedef cds::container::MoirQueue<cds::gc::HP, Value > MoirQueue_HP;
 106         typedef cds::container::MoirQueue<cds::gc::DHP, Value > MoirQueue_DHP;
 107
 108         struct traits_MSQueue_michaelAlloc : public cds::container::msqueue::traits
 109         {
 110             typedef memory::MichaelAllocator<int>  allocator;
 111         };
 112         typedef cds::container::MSQueue<cds::gc::HP,  Value, traits_MSQueue_michaelAlloc > MSQueue_HP_michaelAlloc;
 113         typedef cds::container::MSQueue<cds::gc::DHP, Value, traits_MSQueue_michaelAlloc > MSQueue_DHP_michaelAlloc;
 114         typedef cds::container::MoirQueue<cds::gc::HP, Value, traits_MSQueue_michaelAlloc > MoirQueue_HP_michaelAlloc;
 115         typedef cds::container::MoirQueue<cds::gc::DHP, Value, traits_MSQueue_michaelAlloc > MoirQueue_DHP_michaelAlloc;
 116
 117         struct traits_MSQueue_seqcst : public
 118             cds::container::msqueue::make_traits <
 119                 cds::opt::memory_model < cds::opt::v::sequential_consistent >
 120             > ::type
 121         {};
 122         typedef cds::container::MSQueue< cds::gc::HP,  Value, traits_MSQueue_seqcst > MSQueue_HP_seqcst;
 123         typedef cds::container::MSQueue< cds::gc::DHP, Value, traits_MSQueue_seqcst > MSQueue_DHP_seqcst;
 124         typedef cds::container::MoirQueue< cds::gc::HP, Value, traits_MSQueue_seqcst > MoirQueue_HP_seqcst;
 125         typedef cds::container::MoirQueue< cds::gc::DHP, Value, traits_MSQueue_seqcst > MoirQueue_DHP_seqcst;
 126
 127         // MSQueue + item counter
 128         struct traits_MSQueue_ic : public
 129             cds::container::msqueue::make_traits <
 130                 cds::opt::item_counter < cds::atomicity::item_counter >
 131             >::type
 132         {};
 133         typedef cds::container::MSQueue< cds::gc::HP,  Value, traits_MSQueue_ic > MSQueue_HP_ic;
 134         typedef cds::container::MSQueue< cds::gc::DHP, Value, traits_MSQueue_ic > MSQueue_DHP_ic;
 135         typedef cds::container::MoirQueue< cds::gc::HP, Value, traits_MSQueue_ic > MoirQueue_HP_ic;
 136         typedef cds::container::MoirQueue< cds::gc::DHP, Value, traits_MSQueue_ic > MoirQueue_DHP_ic;
 137
 138         // MSQueue + stat
 139         struct traits_MSQueue_stat: public
 140             cds::container::msqueue::make_traits <
 141                 cds::opt::stat< cds::container::msqueue::stat<> >
 142             >::type
 143         {};
 144         typedef cds::container::MSQueue< cds::gc::HP,  Value, traits_MSQueue_stat > MSQueue_HP_stat;
 145         typedef cds::container::MSQueue< cds::gc::DHP, Value, traits_MSQueue_stat > MSQueue_DHP_stat;
 146         typedef cds::container::MoirQueue< cds::gc::HP, Value, traits_MSQueue_stat > MoirQueue_HP_stat;
 147         typedef cds::container::MoirQueue< cds::gc::DHP, Value, traits_MSQueue_stat > MoirQueue_DHP_stat;
 148
 149
 150         // OptimisticQueue
 151         typedef cds::container::OptimisticQueue< cds::gc::HP, Value > OptimisticQueue_HP;
 152         typedef cds::container::OptimisticQueue< cds::gc::DHP, Value > OptimisticQueue_DHP;
 153
 154         struct traits_OptimisticQueue_michaelAlloc : public cds::container::optimistic_queue::traits
 155         {
 156             typedef memory::MichaelAllocator<int> allocator;
 157         };
 158         typedef cds::container::OptimisticQueue< cds::gc::HP,  Value, traits_OptimisticQueue_michaelAlloc > OptimisticQueue_HP_michaelAlloc;
 159         typedef cds::container::OptimisticQueue< cds::gc::DHP, Value, traits_OptimisticQueue_michaelAlloc > OptimisticQueue_DHP_michaelAlloc;
 160
 161         struct traits_OptimisticQueue_seqcst : public cds::container::optimistic_queue::traits
 162         {
 163             typedef cds::opt::v::sequential_consistent memory_model;
 164         };
 165         typedef cds::container::OptimisticQueue< cds::gc::HP,  Value, traits_OptimisticQueue_seqcst > OptimisticQueue_HP_seqcst;
 166         typedef cds::container::OptimisticQueue< cds::gc::DHP, Value, traits_OptimisticQueue_seqcst > OptimisticQueue_DHP_seqcst;
 167
 168         struct traits_OptimisticQueue_ic : public cds::container::optimistic_queue::traits
 169         {
 170             typedef cds::atomicity::item_counter item_counter;
 171         };
 172         typedef cds::container::OptimisticQueue< cds::gc::HP,  Value, traits_OptimisticQueue_ic > OptimisticQueue_HP_ic;
 173         typedef cds::container::OptimisticQueue< cds::gc::DHP, Value, traits_OptimisticQueue_ic > OptimisticQueue_DHP_ic;
 174
 175         struct traits_OptimisticQueue_stat : public
 176             cds::container::optimistic_queue::make_traits <
 177                 cds::opt::stat < cds::intrusive::optimistic_queue::stat<> >
 178             > ::type
 179         {};
 180         typedef cds::container::OptimisticQueue< cds::gc::HP,  Value, traits_OptimisticQueue_stat > OptimisticQueue_HP_stat;
 181         typedef cds::container::OptimisticQueue< cds::gc::DHP, Value, traits_OptimisticQueue_stat > OptimisticQueue_DHP_stat;
 182
 183
 184         // TsigasCycleQueue
 185
 186         class TsigasCycleQueue_dyn
 187             : public cds::container::TsigasCycleQueue< Value,
 188                 typename cds::container::tsigas_queue::make_traits<
 189                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 190                 >::type
 191             >
 192         {
 193             typedef cds::container::TsigasCycleQueue< Value,
 194                 typename cds::container::tsigas_queue::make_traits<
 195                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 196                 >::type
 197             > base_class;
 198         public:
 199             TsigasCycleQueue_dyn()
 200                 : base_class( 1024 * 64 )
 201             {}
 202
 203             TsigasCycleQueue_dyn( size_t nCapacity )
 204                 : base_class( nCapacity )
 205             {}
 206
 207             cds::opt::none statistics() const
 208             {
 209                 return cds::opt::none();
 210             }
 211         };
 212
 213         class TsigasCycleQueue_dyn_michaelAlloc
 214             : public cds::container::TsigasCycleQueue< Value,
 215                 typename cds::container::tsigas_queue::make_traits<
 216                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 217                     ,cds::opt::allocator< memory::MichaelAllocator<int> >
 218                 >::type
 219             >
 220         {
 221             typedef cds::container::TsigasCycleQueue< Value,
 222                 typename cds::container::tsigas_queue::make_traits<
 223                    cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 224                     , cds::opt::allocator< memory::MichaelAllocator<int> >
 225                 >::type
 226             > base_class;
 227         public:
 228             TsigasCycleQueue_dyn_michaelAlloc()
 229                 : base_class( 1024 * 64 )
 230             {}
 231
 232             TsigasCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 233                 : base_class( nCapacity )
 234             {}
 235
 236             cds::opt::none statistics() const
 237             {
 238                 return cds::opt::none();
 239             }
 240         };
 241
 242         class TsigasCycleQueue_dyn_ic
 243             : public cds::container::TsigasCycleQueue< Value,
 244                 typename cds::container::tsigas_queue::make_traits<
 245                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 246                     ,cds::opt::item_counter< cds::atomicity::item_counter >
 247                 >::type
 248             >
 249         {
 250             typedef cds::container::TsigasCycleQueue< Value,
 251                 typename cds::container::tsigas_queue::make_traits<
 252                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 253                     ,cds::opt::item_counter< cds::atomicity::item_counter >
 254                 >::type
 255             > base_class;
 256         public:
 257             TsigasCycleQueue_dyn_ic()
 258                 : base_class( 1024 * 64 )
 259             {}
 260             TsigasCycleQueue_dyn_ic( size_t nCapacity )
 261                 : base_class( nCapacity )
 262             {}
 263
 264             cds::opt::none statistics() const
 265             {
 266                 return cds::opt::none();
 267             }
 268         };
 269
 270         // VyukovMPMCCycleQueue
 271         struct traits_VyukovMPMCCycleQueue_dyn : public cds::container::vyukov_queue::traits
 272         {
 273             typedef cds::opt::v::dynamic_buffer< int > buffer;
 274         };
 275         class VyukovMPMCCycleQueue_dyn
 276             : public cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn >
 277         {
 278             typedef cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn > base_class;
 279         public:
 280             VyukovMPMCCycleQueue_dyn()
 281                 : base_class( 1024 * 64 )
 282             {}
 283             VyukovMPMCCycleQueue_dyn( size_t nCapacity )
 284                 : base_class( nCapacity )
 285             {}
 286
 287             cds::opt::none statistics() const
 288             {
 289                 return cds::opt::none();
 290             }
 291         };
 292
 293         struct traits_VyukovMPMCCycleQueue_dyn_michaelAlloc : public cds::container::vyukov_queue::traits
 294         {
 295             typedef cds::opt::v::dynamic_buffer< int, memory::MichaelAllocator<int> > buffer;
 296         };
 297         class VyukovMPMCCycleQueue_dyn_michaelAlloc
 298             : public cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn_michaelAlloc >
 299         {
 300             typedef cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn_michaelAlloc > base_class;
 301         public:
 302             VyukovMPMCCycleQueue_dyn_michaelAlloc()
 303                 : base_class( 1024 * 64 )
 304             {}
 305             VyukovMPMCCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 306                 : base_class( nCapacity )
 307             {}
 308
 309             cds::opt::none statistics() const
 310             {
 311                 return cds::opt::none();
 312             }
 313         };
 314
 315         struct traits_VyukovMPMCCycleQueue_dyn_ic : public traits_VyukovMPMCCycleQueue_dyn
 316         {
 317             typedef cds::atomicity::item_counter item_counter;
 318         };
 319         class VyukovMPMCCycleQueue_dyn_ic
 320             : public cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn_ic >
 321         {
 322             typedef cds::container::VyukovMPMCCycleQueue< Value, traits_VyukovMPMCCycleQueue_dyn_ic > base_class;
 323         public:
 324             VyukovMPMCCycleQueue_dyn_ic()
 325                 : base_class( 1024 * 64 )
 326             {}
 327             VyukovMPMCCycleQueue_dyn_ic( size_t nCapacity )
 328                 : base_class( nCapacity )
 329             {}
 330
 331             cds::opt::none statistics() const
 332             {
 333                 return cds::opt::none();
 334             }
 335         };
 336
 337
 338         // BasketQueue
 339
 340         typedef cds::container::BasketQueue< cds::gc::HP , Value > BasketQueue_HP;
 341         typedef cds::container::BasketQueue< cds::gc::DHP, Value > BasketQueue_DHP;
 342
 343         struct traits_BasketQueue_michaelAlloc : public cds::container::basket_queue::traits
 344         {
 345             typedef memory::MichaelAllocator<int> allocator;
 346         };
 347         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_michaelAlloc > BasketQueue_HP_michaelAlloc;
 348         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_michaelAlloc > BasketQueue_DHP_michaelAlloc;
 349
 350         struct traits_BasketQueue_seqcst : public cds::container::basket_queue::traits
 351         {
 352             typedef cds::opt::v::sequential_consistent mamory_model;
 353         };
 354         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_seqcst > BasketQueue_HP_seqcst;
 355         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_seqcst > BasketQueue_DHP_seqcst;
 356
 357         struct traits_BasketQueue_ic : public cds::container::basket_queue::traits
 358         {
 359             typedef cds::atomicity::item_counter item_counter;
 360         };
 361         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_ic >BasketQueue_HP_ic;
 362         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_ic >BasketQueue_DHP_ic;
 363
 364         struct traits_BasketQueue_stat : public cds::container::basket_queue::traits
 365         {
 366             typedef cds::container::basket_queue::stat<> stat;
 367         };
 368         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_stat > BasketQueue_HP_stat;
 369         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_stat > BasketQueue_DHP_stat;
 370
 371
 372         // RWQueue
 373         typedef cds::container::RWQueue< Value > RWQueue_Spin;
 374
 375         struct traits_RWQueue_Spin_ic : public cds::container::rwqueue::traits
 376         {
 377             typedef cds::atomicity::item_counter item_counter;
 378         };
 379         typedef cds::container::RWQueue< Value, traits_RWQueue_Spin_ic > RWQueue_Spin_ic;
 380
 381         struct traits_RWQueue_mutex : public
 382             cds::container::rwqueue::make_traits<
 383                 cds::opt::lock_type< std::mutex >
 384             >::type
 385         {};
 386         typedef cds::container::RWQueue< Value, traits_RWQueue_mutex > RWQueue_mutex;
 387
 388         // FCQueue
 389         class traits_FCQueue_elimination:
 390             public cds::container::fcqueue::make_traits<
 391                 cds::opt::enable_elimination< true >
 392             >::type
 393         {};
 394         class traits_FCQueue_elimination_stat:
 395             public cds::container::fcqueue::make_traits<
 396                 cds::opt::enable_elimination< true >
 397                 ,cds::opt::stat< cds::container::fcqueue::stat<> >
 398             >::type
 399         {};
 400
 401         typedef cds::container::FCQueue< Value > FCQueue_deque;
 402         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination > FCQueue_deque_elimination;
 403         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination_stat > FCQueue_deque_elimination_stat;
 404
 405         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> > > FCQueue_list;
 406         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination > FCQueue_list_elimination;
 407         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination_stat > FCQueue_list_elimination_stat;
 408
 409
 410    // FCDeque
 411         struct traits_FCDeque_stat:
 412             public cds::container::fcdeque::make_traits<
 413                 cds::opt::stat< cds::container::fcdeque::stat<> >
 414             >::type
 415         {};
 416         struct traits_FCDeque_elimination:
 417             public cds::container::fcdeque::make_traits<
 418                 cds::opt::enable_elimination< true >
 419             >::type
 420         {};
 421         struct traits_FCDeque_elimination_stat:
 422             public cds::container::fcdeque::make_traits<
 423                 cds::opt::stat< cds::container::fcdeque::stat<> >,
 424                 cds::opt::enable_elimination< true >
 425             >::type
 426         {};
 427         struct traits_FCDeque_mutex:
 428             public cds::container::fcdeque::make_traits<
 429                 cds::opt::lock_type< std::mutex >
 430             >::type
 431         {};
 432
 433         typedef details::FCDequeL< Value > FCDequeL_default;
 434         typedef details::FCDequeL< Value, traits_FCDeque_mutex > FCDequeL_mutex;
 435         typedef details::FCDequeL< Value, traits_FCDeque_stat > FCDequeL_stat;
 436         typedef details::FCDequeL< Value, traits_FCDeque_elimination > FCDequeL_elimination;
 437         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat > FCDequeL_elimination_stat;
 438
 439         typedef details::FCDequeL< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeL_boost;
 440         typedef details::FCDequeL< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_boost_stat;
 441         typedef details::FCDequeL< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_boost_elimination;
 442         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_boost_elimination_stat;
 443
 444         typedef details::FCDequeR< Value > FCDequeR_default;
 445         typedef details::FCDequeR< Value, traits_FCDeque_mutex > FCDequeR_mutex;
 446         typedef details::FCDequeR< Value, traits_FCDeque_stat > FCDequeR_stat;
 447         typedef details::FCDequeR< Value, traits_FCDeque_elimination > FCDequeR_elimination;
 448         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat > FCDequeR_elimination_stat;
 449
 450         typedef details::FCDequeR< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeR_boost;
 451         typedef details::FCDequeR< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_boost_stat;
 452         typedef details::FCDequeR< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_boost_elimination;
 453         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_boost_elimination_stat;
 454
 455         typedef StdQueue_deque<Value>               StdQueue_deque_Spinlock;
 456         typedef StdQueue_list<Value>                StdQueue_list_Spinlock;
 457         typedef StdQueue_deque<Value, std::mutex>   StdQueue_deque_BoostMutex;
 458         typedef StdQueue_list<Value, std::mutex>    StdQueue_list_BoostMutex;
 459 #ifdef UNIT_LOCK_WIN_CS
 460         typedef StdQueue_deque<Value, lock::win::CS>    StdQueue_deque_WinCS;
 461         typedef StdQueue_list<Value, lock::win::CS>     StdQueue_list_WinCS;
 462         typedef StdQueue_deque<Value, lock::win::Mutex> StdQueue_deque_WinMutex;
 463         typedef StdQueue_list<Value, lock::win::Mutex>  StdQueue_list_WinMutex;
 464 #endif
 465
 466         // SegmentedQueue
 467         class traits_SegmentedQueue_spin_stat:
 468             public cds::container::segmented_queue::make_traits<
 469                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 470             >::type
 471         {};
 472         class traits_SegmentedQueue_spin_padding:
 473             public cds::container::segmented_queue::make_traits<
 474                 cds::opt::padding< cds::opt::cache_line_padding >
 475             >::type
 476         {};
 477         class traits_SegmentedQueue_mutex_stat:
 478             public cds::container::segmented_queue::make_traits<
 479                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 480                 ,cds::opt::lock_type< std::mutex >
 481             >::type
 482         {};
 483         class traits_SegmentedQueue_mutex:
 484             public cds::container::segmented_queue::make_traits<
 485                 cds::opt::lock_type< std::mutex >
 486             >::type
 487         {};
 488         class traits_SegmentedQueue_mutex_padding:
 489             public cds::container::segmented_queue::make_traits<
 490                 cds::opt::lock_type< std::mutex >
 491                 , cds::opt::padding< cds::opt::cache_line_padding >
 492             >::type
 493         {};
 494
 495         typedef cds::container::SegmentedQueue< cds::gc::HP, Value >  SegmentedQueue_HP_spin;
 496         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_padding >  SegmentedQueue_HP_spin_padding;
 497         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_HP_spin_stat;
 498         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_HP_mutex;
 499         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_HP_mutex_padding;
 500         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_HP_mutex_stat;
 501
 502         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value >  SegmentedQueue_DHP_spin;
 503         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_spin_padding >  SegmentedQueue_DHP_spin_padding;
 504         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_DHP_spin_stat;
 505         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_DHP_mutex;
 506         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_DHP_mutex_padding;
 507         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_DHP_mutex_stat;
 508     };
 509 }
 510
 511
 512 // *********************************************
 513 // Queue statistics
 514 namespace std {
 515
 516     template <typename Counter>
 517     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::stat<Counter> const& s)
 518     {
 519         return o
 520             << "\tStatistics:\n"
 521             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 522             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 523             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 524             << "\t\t      Dequeue empty: " << s.m_EmptyDequeue.get() << "\n"
 525             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 526             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 527             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 528             << "\t\tAdd basket attempts: " << s.m_TryAddBasket.get() << "\n"
 529             << "\t\t Add basket success: " << s.m_AddBasketCount.get() << "\n";
 530     }
 531     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::empty_stat const& /*s*/)
 532     {
 533         return o;
 534     }
 535
 536     template <typename Counter>
 537     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::stat<Counter> const& s )
 538     {
 539         return o
 540             << "\tStatistics:\n"
 541             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 542             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get()  << "\n"
 543             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 544             << "\t\t     Dequeue empty: " << s.m_EmptyDequeue.get() << "\n"
 545             << "\t\t      Dequeue race: " << s.m_DequeueRace.get()  << "\n"
 546             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 547             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n";
 548     }
 549
 550     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::empty_stat const& /*s*/ )
 551     {
 552         return o;
 553     }
 554
 555     static inline std::ostream& operator <<( std::ostream& o, cds::opt::none )
 556     {
 557         return o;
 558     }
 559
 560     // cds::intrusive::optimistic_queue::stat
 561     template <typename Counter>
 562     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::stat<Counter> const& s )
 563     {
 564         return o
 565             << "\tStatistics:\n"
 566             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 567             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 568             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 569             << "\t\t      Dequeue empty: " << s.m_EmptyDequeue.get() << "\n"
 570             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 571             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 572             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 573             << "\t\t      fix list call: " << s.m_FixListCount.get() << "\n";
 574     }
 575
 576     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::empty_stat const& /*s*/ )
 577     {
 578         return o;
 579     }
 580
 581     // cds::container::fcqueue::stat
 582     template <typename Counter>
 583     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::stat<Counter> const& s )
 584     {
 585             return o << "\tStatistics:\n"
 586                 << "\t                    Push: " << s.m_nEnqueue.get()           << "\n"
 587                 << "\t                PushMove: " << s.m_nEnqMove.get()           << "\n"
 588                 << "\t                     Pop: " << s.m_nDequeue.get()           << "\n"
 589                 << "\t               FailedPop: " << s.m_nFailedDeq.get()         << "\n"
 590                 << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 591                 << "\tFlat combining statistics:\n"
 592                 << "\t        Combining factor: " << s.combining_factor()         << "\n"
 593                 << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 594                 << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 595                 << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 596                 << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 597                 << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 598                 << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 599                 << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 600                 << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 601                 << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 602     }
 603
 604     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::empty_stat const& /*s*/ )
 605     {
 606         return o;
 607     }
 608
 609     static inline std::ostream& operator <<( std::ostream& o, std::nullptr_t /*s*/ )
 610     {
 611         return o;
 612     }
 613
 614     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::empty_stat const& /*s*/ )
 615     {
 616         return o;
 617     }
 618
 619     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::stat<> const& s )
 620     {
 621         return o << "\tStatistics:\n"
 622             << "\t              Push front: " << s.m_nPushFront.get()         << "\n"
 623             << "\t         Push front move: " << s.m_nPushFrontMove.get()     << "\n"
 624             << "\t               Push back: " << s.m_nPushBack.get()          << "\n"
 625             << "\t          Push back move: " << s.m_nPushBackMove.get()      << "\n"
 626             << "\t               Pop front: " << s.m_nPopFront.get()          << "\n"
 627             << "\t        Failed pop front: " << s.m_nFailedPopFront.get()    << "\n"
 628             << "\t                Pop back: " << s.m_nPopBack.get()           << "\n"
 629             << "\t         Failed pop back: " << s.m_nFailedPopBack.get()     << "\n"
 630             << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 631             << "\tFlat combining statistics:\n"
 632             << "\t        Combining factor: " << s.combining_factor()         << "\n"
 633             << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 634             << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 635             << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 636             << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 637             << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 638             << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 639             << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 640             << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 641             << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 642     }
 643
 644 }
 645
 646 #endif // #ifndef CDSUNIT_QUEUE_TYPES_H