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         class TsigasCycleQueue_dyn
 186             : public cds::container::TsigasCycleQueue<
 187                 Value
 188                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 189             >
 190         {
 191             typedef cds::container::TsigasCycleQueue<
 192                 Value
 193                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 194             > base_class;
 195         public:
 196             TsigasCycleQueue_dyn()
 197                 : base_class( 1024 * 64 )
 198             {}
 199
 200             TsigasCycleQueue_dyn( size_t nCapacity )
 201                 : base_class( nCapacity )
 202             {}
 203
 204             cds::opt::none statistics() const
 205             {
 206                 return cds::opt::none();
 207             }
 208         };
 209
 210         class TsigasCycleQueue_dyn_michaelAlloc
 211             : public cds::container::TsigasCycleQueue<
 212                 Value
 213                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 214                 ,cds::opt::allocator< memory::MichaelAllocator<int> >
 215             >
 216         {
 217             typedef cds::container::TsigasCycleQueue<
 218                 Value
 219                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 220                 ,cds::opt::allocator< memory::MichaelAllocator<int> >
 221             > base_class;
 222         public:
 223             TsigasCycleQueue_dyn_michaelAlloc()
 224                 : base_class( 1024 * 64 )
 225             {}
 226
 227             TsigasCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 228                 : base_class( nCapacity )
 229             {}
 230
 231             cds::opt::none statistics() const
 232             {
 233                 return cds::opt::none();
 234             }
 235         };
 236
 237         class TsigasCycleQueue_dyn_ic
 238             : public cds::container::TsigasCycleQueue<
 239                 Value
 240                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 241                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 242             >
 243         {
 244             typedef cds::container::TsigasCycleQueue<
 245                 Value
 246                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 247                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 248             > base_class;
 249         public:
 250             TsigasCycleQueue_dyn_ic()
 251                 : base_class( 1024 * 64 )
 252             {}
 253             TsigasCycleQueue_dyn_ic( size_t nCapacity )
 254                 : base_class( nCapacity )
 255             {}
 256
 257             cds::opt::none statistics() const
 258             {
 259                 return cds::opt::none();
 260             }
 261         };
 262
 263         // VyukovMPMCCycleQueue
 264         class VyukovMPMCCycleQueue_dyn
 265             : public cds::container::VyukovMPMCCycleQueue<
 266                 Value
 267                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 268             >
 269         {
 270             typedef cds::container::VyukovMPMCCycleQueue<
 271                 Value
 272                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 273             > base_class;
 274         public:
 275             VyukovMPMCCycleQueue_dyn()
 276                 : base_class( 1024 * 64 )
 277             {}
 278             VyukovMPMCCycleQueue_dyn( size_t nCapacity )
 279                 : base_class( nCapacity )
 280             {}
 281
 282             cds::opt::none statistics() const
 283             {
 284                 return cds::opt::none();
 285             }
 286         };
 287
 288         class VyukovMPMCCycleQueue_dyn_michaelAlloc
 289             : public cds::container::VyukovMPMCCycleQueue<
 290             Value
 291             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int, memory::MichaelAllocator<int> > >
 292             >
 293         {
 294             typedef cds::container::VyukovMPMCCycleQueue<
 295                 Value
 296                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int, memory::MichaelAllocator<int> > >
 297             > base_class;
 298         public:
 299             VyukovMPMCCycleQueue_dyn_michaelAlloc()
 300                 : base_class( 1024 * 64 )
 301             {}
 302             VyukovMPMCCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 303                 : base_class( nCapacity )
 304             {}
 305
 306             cds::opt::none statistics() const
 307             {
 308                 return cds::opt::none();
 309             }
 310         };
 311
 312         class VyukovMPMCCycleQueue_dyn_ic
 313             : public cds::container::VyukovMPMCCycleQueue<
 314                 Value
 315                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 316                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 317             >
 318         {
 319             typedef cds::container::VyukovMPMCCycleQueue<
 320                 Value
 321                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 322                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 323             > base_class;
 324         public:
 325             VyukovMPMCCycleQueue_dyn_ic()
 326                 : base_class( 1024 * 64 )
 327             {}
 328             VyukovMPMCCycleQueue_dyn_ic( size_t nCapacity )
 329                 : base_class( nCapacity )
 330             {}
 331
 332             cds::opt::none statistics() const
 333             {
 334                 return cds::opt::none();
 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_mutex_stat:
 473             public cds::container::segmented_queue::make_traits<
 474                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 475                 ,cds::opt::lock_type< std::mutex >
 476             >::type
 477         {};
 478         class traits_SegmentedQueue_mutex:
 479             public cds::container::segmented_queue::make_traits<
 480                 cds::opt::lock_type< std::mutex >
 481             >::type
 482         {};
 483
 484         typedef cds::container::SegmentedQueue< cds::gc::HP, Value >  SegmentedQueue_HP_spin;
 485         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_HP_spin_stat;
 486         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_HP_mutex;
 487         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_HP_mutex_stat;
 488
 489         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value >  SegmentedQueue_PTB_spin;
 490         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_PTB_spin_stat;
 491         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_PTB_mutex;
 492         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_PTB_mutex_stat;
 493
 494
 495     };
 496 }
 497
 498
 499 // *********************************************
 500 // Queue statistics
 501 namespace std {
 502     /*
 503     template <typename Counter>
 504     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_stat<Counter> const& s)
 505     {
 506         return o
 507             << "\tStatistics:\n"
 508             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 509             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 510             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 511             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 512             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 513             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n";
 514     }
 515     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_dummy_stat const& s)
 516     {
 517         return o;
 518     }
 519     */
 520
 521     template <typename Counter>
 522     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::stat<Counter> const& s)
 523     {
 524         return o
 525             << "\tStatistics:\n"
 526             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 527             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 528             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 529             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 530             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 531             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 532             << "\t\tAdd basket attempts: " << s.m_TryAddBasket.get() << "\n"
 533             << "\t\t Add basket success: " << s.m_AddBasketCount.get() << "\n";
 534     }
 535     static inline std::ostream& operator <<(std::ostream& o, cds::container::basket_queue::empty_stat const& s)
 536     {
 537         return o;
 538     }
 539
 540     template <typename Counter>
 541     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::stat<Counter> const& s )
 542     {
 543         return o
 544             << "\tStatistics:\n"
 545             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 546             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get()  << "\n"
 547             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 548             << "\t\t      Dequeue race: " << s.m_DequeueRace.get()  << "\n"
 549             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 550             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n";
 551     }
 552
 553     static inline std::ostream& operator <<( std::ostream& o, cds::container::msqueue::empty_stat const& s )
 554     {
 555         return o;
 556     }
 557
 558     static inline std::ostream& operator <<( std::ostream& o, cds::opt::none )
 559     {
 560         return o;
 561     }
 562
 563     // cds::intrusive::optimistic_queue::stat
 564     template <typename Counter>
 565     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::stat<Counter> const& s )
 566     {
 567         return o
 568             << "\tStatistics:\n"
 569             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 570             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 571             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 572             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 573             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 574             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 575             << "\t\t      fix list call: " << s.m_FixListCount.get() << "\n";
 576     }
 577
 578     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::empty_stat const& s )
 579     {
 580         return o;
 581     }
 582
 583     // cds::container::fcqueue::stat
 584     template <typename Counter>
 585     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::stat<Counter> const& s )
 586     {
 587             return o << "\tStatistics:\n"
 588                 << "\t                    Push: " << s.m_nEnqueue.get()           << "\n"
 589                 << "\t                PushMove: " << s.m_nEnqMove.get()           << "\n"
 590                 << "\t                     Pop: " << s.m_nDequeue.get()           << "\n"
 591                 << "\t               FailedPop: " << s.m_nFailedDeq.get()         << "\n"
 592                 << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 593                 << "\tFlat combining statistics:\n"
 594                 << "\t        Combining factor: " << s.combining_factor()         << "\n"
 595                 << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 596                 << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 597                 << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 598                 << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 599                 << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 600                 << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 601                 << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 602                 << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 603                 << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 604     }
 605
 606     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::empty_stat const& s )
 607     {
 608         return o;
 609     }
 610
 611     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::empty_stat const& s )
 612     {
 613         return o;
 614     }
 615
 616     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::stat<> const& s )
 617     {
 618         return o << "\tStatistics:\n"
 619             << "\t              Push front: " << s.m_nPushFront.get()         << "\n"
 620             << "\t         Push front move: " << s.m_nPushFrontMove.get()     << "\n"
 621             << "\t               Push back: " << s.m_nPushBack.get()          << "\n"
 622             << "\t          Push back move: " << s.m_nPushBackMove.get()      << "\n"
 623             << "\t               Pop front: " << s.m_nPopFront.get()          << "\n"
 624             << "\t        Failed pop front: " << s.m_nFailedPopFront.get()    << "\n"
 625             << "\t                Pop back: " << s.m_nPopBack.get()           << "\n"
 626             << "\t         Failed pop back: " << s.m_nFailedPopBack.get()     << "\n"
 627             << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 628             << "\tFlat combining statistics:\n"
 629             << "\t        Combining factor: " << s.combining_factor()         << "\n"
 630             << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 631             << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 632             << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 633             << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 634             << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 635             << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 636             << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 637             << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 638             << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 639     }
 640
 641 }
 642
 643 #endif // #ifndef __CDSUNIT_QUEUE_TYPES_H