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         // BasketQueue
 338
 339         typedef cds::container::BasketQueue< cds::gc::HP , Value > BasketQueue_HP;
 340         typedef cds::container::BasketQueue< cds::gc::DHP, Value > BasketQueue_DHP;
 341
 342         struct traits_BasketQueue_michaelAlloc : public cds::container::basket_queue::traits
 343         {
 344             typedef memory::MichaelAllocator<int> allocator;
 345         };
 346         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_michaelAlloc > BasketQueue_HP_michaelAlloc;
 347         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_michaelAlloc > BasketQueue_DHP_michaelAlloc;
 348
 349         struct traits_BasketQueue_seqcst : public cds::container::basket_queue::traits
 350         {
 351             typedef cds::opt::v::sequential_consistent mamory_model;
 352         };
 353         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_seqcst > BasketQueue_HP_seqcst;
 354         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_seqcst > BasketQueue_DHP_seqcst;
 355
 356         struct traits_BasketQueue_ic : public cds::container::basket_queue::traits
 357         {
 358             typedef cds::atomicity::item_counter item_counter;
 359         };
 360         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_ic >BasketQueue_HP_ic;
 361         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_ic >BasketQueue_DHP_ic;
 362
 363         struct traits_BasketQueue_stat : public cds::container::basket_queue::traits
 364         {
 365             typedef cds::container::basket_queue::stat<> stat;
 366         };
 367         typedef cds::container::BasketQueue< cds::gc::HP,  Value, traits_BasketQueue_stat > BasketQueue_HP_stat;
 368         typedef cds::container::BasketQueue< cds::gc::DHP, Value, traits_BasketQueue_stat > BasketQueue_DHP_stat;
 369
 370
 371         // RWQueue
 372         typedef cds::container::RWQueue< Value > RWQueue_Spin;
 373
 374         struct traits_RWQueue_Spin_ic : public cds::container::rwqueue::traits
 375         {
 376             typedef cds::atomicity::item_counter item_counter;
 377         };
 378         typedef cds::container::RWQueue< Value, traits_RWQueue_Spin_ic > RWQueue_Spin_ic;
 379
 380         struct traits_RWQueue_mutex : public
 381             cds::container::rwqueue::make_traits<
 382                 cds::opt::lock_type< std::mutex >
 383             >::type
 384         {};
 385         typedef cds::container::RWQueue< Value, traits_RWQueue_mutex > RWQueue_mutex;
 386
 387         // FCQueue
 388         class traits_FCQueue_elimination:
 389             public cds::container::fcqueue::make_traits<
 390                 cds::opt::enable_elimination< true >
 391             >::type
 392         {};
 393         class traits_FCQueue_elimination_stat:
 394             public cds::container::fcqueue::make_traits<
 395                 cds::opt::enable_elimination< true >
 396                 ,cds::opt::stat< cds::container::fcqueue::stat<> >
 397             >::type
 398         {};
 399
 400         typedef cds::container::FCQueue< Value > FCQueue_deque;
 401         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination > FCQueue_deque_elimination;
 402         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination_stat > FCQueue_deque_elimination_stat;
 403
 404         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> > > FCQueue_list;
 405         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination > FCQueue_list_elimination;
 406         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination_stat > FCQueue_list_elimination_stat;
 407
 408
 409    // FCDeque
 410         struct traits_FCDeque_stat:
 411             public cds::container::fcdeque::make_traits<
 412                 cds::opt::stat< cds::container::fcdeque::stat<> >
 413             >::type
 414         {};
 415         struct traits_FCDeque_elimination:
 416             public cds::container::fcdeque::make_traits<
 417                 cds::opt::enable_elimination< true >
 418             >::type
 419         {};
 420         struct traits_FCDeque_elimination_stat:
 421             public cds::container::fcdeque::make_traits<
 422                 cds::opt::stat< cds::container::fcdeque::stat<> >,
 423                 cds::opt::enable_elimination< true >
 424             >::type
 425         {};
 426         struct traits_FCDeque_mutex:
 427             public cds::container::fcdeque::make_traits<
 428                 cds::opt::lock_type< std::mutex >
 429             >::type
 430         {};
 431
 432         typedef details::FCDequeL< Value > FCDequeL_default;
 433         typedef details::FCDequeL< Value, traits_FCDeque_mutex > FCDequeL_mutex;
 434         typedef details::FCDequeL< Value, traits_FCDeque_stat > FCDequeL_stat;
 435         typedef details::FCDequeL< Value, traits_FCDeque_elimination > FCDequeL_elimination;
 436         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat > FCDequeL_elimination_stat;
 437
 438         typedef details::FCDequeL< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeL_boost;
 439         typedef details::FCDequeL< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_boost_stat;
 440         typedef details::FCDequeL< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_boost_elimination;
 441         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_boost_elimination_stat;
 442
 443         typedef details::FCDequeR< Value > FCDequeR_default;
 444         typedef details::FCDequeR< Value, traits_FCDeque_mutex > FCDequeR_mutex;
 445         typedef details::FCDequeR< Value, traits_FCDeque_stat > FCDequeR_stat;
 446         typedef details::FCDequeR< Value, traits_FCDeque_elimination > FCDequeR_elimination;
 447         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat > FCDequeR_elimination_stat;
 448
 449         typedef details::FCDequeR< Value, cds::container::fcdeque::traits, boost::container::deque<Value> > FCDequeR_boost;
 450         typedef details::FCDequeR< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_boost_stat;
 451         typedef details::FCDequeR< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_boost_elimination;
 452         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_boost_elimination_stat;
 453
 454         typedef StdQueue_deque<Value>               StdQueue_deque_Spinlock;
 455         typedef StdQueue_list<Value>                StdQueue_list_Spinlock;
 456         typedef StdQueue_deque<Value, std::mutex>   StdQueue_deque_BoostMutex;
 457         typedef StdQueue_list<Value, std::mutex>    StdQueue_list_BoostMutex;
 458 #ifdef UNIT_LOCK_WIN_CS
 459         typedef StdQueue_deque<Value, lock::win::CS>    StdQueue_deque_WinCS;
 460         typedef StdQueue_list<Value, lock::win::CS>     StdQueue_list_WinCS;
 461         typedef StdQueue_deque<Value, lock::win::Mutex> StdQueue_deque_WinMutex;
 462         typedef StdQueue_list<Value, lock::win::Mutex>  StdQueue_list_WinMutex;
 463 #endif
 464
 465         // SegmentedQueue
 466         class traits_SegmentedQueue_spin_stat:
 467             public cds::container::segmented_queue::make_traits<
 468                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 469             >::type
 470         {};
 471         class traits_SegmentedQueue_spin_padding:
 472             public cds::container::segmented_queue::make_traits<
 473                 cds::opt::padding< cds::opt::cache_line_padding >
 474             >::type
 475         {};
 476         class traits_SegmentedQueue_mutex_stat:
 477             public cds::container::segmented_queue::make_traits<
 478                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 479                 ,cds::opt::lock_type< std::mutex >
 480             >::type
 481         {};
 482         class traits_SegmentedQueue_mutex:
 483             public cds::container::segmented_queue::make_traits<
 484                 cds::opt::lock_type< std::mutex >
 485             >::type
 486         {};
 487         class traits_SegmentedQueue_mutex_padding:
 488             public cds::container::segmented_queue::make_traits<
 489                 cds::opt::lock_type< std::mutex >
 490                 , cds::opt::padding< cds::opt::cache_line_padding >
 491             >::type
 492         {};
 493
 494         typedef cds::container::SegmentedQueue< cds::gc::HP, Value >  SegmentedQueue_HP_spin;
 495         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_padding >  SegmentedQueue_HP_spin_padding;
 496         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_HP_spin_stat;
 497         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_HP_mutex;
 498         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_HP_mutex_padding;
 499         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_HP_mutex_stat;
 500
 501         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value >  SegmentedQueue_DHP_spin;
 502         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_spin_padding >  SegmentedQueue_DHP_spin_padding;
 503         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_DHP_spin_stat;
 504         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_DHP_mutex;
 505         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_DHP_mutex_padding;
 506         typedef cds::container::SegmentedQueue< cds::gc::DHP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_DHP_mutex_stat;
 507     };
 508 }
 509
 510
 511 // *********************************************
 512 // Queue statistics
 513 namespace std {
 514     /*
 515     template <typename Counter>
 516     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_stat<Counter> const& s)
 517     {
 518         return o
 519             << "\tStatistics:\n"
 520             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 521             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 522             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 523             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 524             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 525             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n";
 526     }
 527     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_dummy_stat const& s)
 528     {
 529         return o;
 530     }
 531     */
 532
 533     template <typename Counter>
 534     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::stat<Counter> const& s)
 535     {
 536         return o
 537             << "\tStatistics:\n"
 538             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 539             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 540             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 541             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 542             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 543             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 544             << "\t\tAdd basket attempts: " << s.m_TryAddBasket.get() << "\n"
 545             << "\t\t Add basket success: " << s.m_AddBasketCount.get() << "\n";
 546     }
 547     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::empty_stat const& /*s*/)
 548     {
 549         return o;
 550     }
 551
 552     template <typename Counter>
 553     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::stat<Counter> const& s )
 554     {
 555         return o
 556             << "\tStatistics:\n"
 557             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 558             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get()  << "\n"
 559             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 560             << "\t\t      Dequeue race: " << s.m_DequeueRace.get()  << "\n"
 561             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 562             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n";
 563     }
 564
 565     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::empty_stat const& /*s*/ )
 566     {
 567         return o;
 568     }
 569
 570     static inline std::ostream& operator <<( std::ostream& o, cds::opt::none )
 571     {
 572         return o;
 573     }
 574
 575     // cds::intrusive::optimistic_queue::stat
 576     template <typename Counter>
 577     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::stat<Counter> const& s )
 578     {
 579         return o
 580             << "\tStatistics:\n"
 581             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 582             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 583             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 584             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 585             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 586             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 587             << "\t\t      fix list call: " << s.m_FixListCount.get() << "\n";
 588     }
 589
 590     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::empty_stat const& /*s*/ )
 591     {
 592         return o;
 593     }
 594
 595     // cds::container::fcqueue::stat
 596     template <typename Counter>
 597     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::stat<Counter> const& s )
 598     {
 599             return o << "\tStatistics:\n"
 600                 << "\t                    Push: " << s.m_nEnqueue.get()           << "\n"
 601                 << "\t                PushMove: " << s.m_nEnqMove.get()           << "\n"
 602                 << "\t                     Pop: " << s.m_nDequeue.get()           << "\n"
 603                 << "\t               FailedPop: " << s.m_nFailedDeq.get()         << "\n"
 604                 << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 605                 << "\tFlat combining statistics:\n"
 606                 << "\t        Combining factor: " << s.combining_factor()         << "\n"
 607                 << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 608                 << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 609                 << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 610                 << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 611                 << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 612                 << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 613                 << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 614                 << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 615                 << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 616     }
 617
 618     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::empty_stat const& /*s*/ )
 619     {
 620         return o;
 621     }
 622
 623     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::empty_stat const& /*s*/ )
 624     {
 625         return o;
 626     }
 627
 628     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::stat<> const& s )
 629     {
 630         return o << "\tStatistics:\n"
 631             << "\t              Push front: " << s.m_nPushFront.get()         << "\n"
 632             << "\t         Push front move: " << s.m_nPushFrontMove.get()     << "\n"
 633             << "\t               Push back: " << s.m_nPushBack.get()          << "\n"
 634             << "\t          Push back move: " << s.m_nPushBackMove.get()      << "\n"
 635             << "\t               Pop front: " << s.m_nPopFront.get()          << "\n"
 636             << "\t        Failed pop front: " << s.m_nFailedPopFront.get()    << "\n"
 637             << "\t                Pop back: " << s.m_nPopBack.get()           << "\n"
 638             << "\t         Failed pop back: " << s.m_nFailedPopBack.get()     << "\n"
 639             << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 640             << "\tFlat combining statistics:\n"
 641             << "\t        Combining factor: " << s.combining_factor()         << "\n"
 642             << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 643             << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 644             << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 645             << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 646             << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 647             << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 648             << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 649             << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 650             << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 651     }
 652
 653 }
 654
 655 #endif // #ifndef __CDSUNIT_QUEUE_TYPES_H