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/michael_deque.h>
  16 #include <cds/container/segmented_queue.h>
  17
  18 #include <cds/gc/hp.h>
  19 #include <cds/gc/hrc.h>
  20 #include <cds/gc/ptb.h>
  21
  22 #include "queue/std_queue.h"
  23 #include "lock/win32_lock.h"
  24 #include "michael_alloc.h"
  25 #include "print_deque_stat.h"
  26 #include "print_segmentedqueue_stat.h"
  27
  28 #include <boost/container/deque.hpp>
  29
  30 namespace queue {
  31
  32     namespace details {
  33         // MichaelDeque, push right/pop left
  34         template <typename GC, typename T, CDS_DECL_OPTIONS7>
  35         class MichaelDequeR: public cds::container::MichaelDeque< GC, T, CDS_OPTIONS7>
  36         {
  37             typedef cds::container::MichaelDeque< GC, T, CDS_OPTIONS7> base_class;
  38         public:
  39             MichaelDequeR( size_t nMaxItemCount )
  40                 : base_class( (unsigned int) nMaxItemCount, 4 )
  41             {}
  42             MichaelDequeR()
  43                 : base_class( 64 * 1024, 4 )
  44             {}
  45
  46             bool push( T const& v )
  47             {
  48                 return base_class::push_back( v );
  49             }
  50             bool enqueue( T const& v )
  51             {
  52                 return push( v );
  53             }
  54
  55             bool pop( T& v )
  56             {
  57                 return base_class::pop_front( v );
  58             }
  59             bool deque( T& v )
  60             {
  61                 return pop(v);
  62             }
  63         };
  64
  65         // MichaelDeque, push left/pop right
  66         template <typename GC, typename T, CDS_DECL_OPTIONS7>
  67         class MichaelDequeL: public cds::container::MichaelDeque< GC, T, CDS_OPTIONS7>
  68         {
  69             typedef cds::container::MichaelDeque< GC, T, CDS_OPTIONS7> base_class;
  70         public:
  71             MichaelDequeL( size_t nMaxItemCount )
  72                 : base_class( (unsigned int) nMaxItemCount, 4 )
  73             {}
  74             MichaelDequeL()
  75                 : base_class( 64 * 1024, 4 )
  76             {}
  77
  78             bool push( T const& v )
  79             {
  80                 return base_class::push_front( 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_back( v );
  90             }
  91             bool deque( T& v )
  92             {
  93                 return pop(v);
  94             }
  95         };
  96
  97         template <typename T, typename Traits=cds::container::fcdeque::type_traits, class Deque=std::deque<T> >
  98         class FCDequeL: public cds::container::FCDeque<T, Deque, Traits >
  99         {
 100             typedef cds::container::FCDeque<T, Deque, Traits > base_class;
 101         public:
 102             FCDequeL()
 103             {}
 104
 105             FCDequeL(
 106                 unsigned int nCompactFactor     ///< Flat combining: publication list compacting factor
 107                 ,unsigned int nCombinePassCount ///< Flat combining: number of combining passes for combiner thread
 108                 )
 109                 : base_class( nCompactFactor, nCombinePassCount )
 110             {}
 111
 112             bool push( T const& v )
 113             {
 114                 return base_class::push_front( v );
 115             }
 116             bool enqueue( T const& v )
 117             {
 118                 return push( v );
 119             }
 120
 121             bool pop( T& v )
 122             {
 123                 return base_class::pop_back( v );
 124             }
 125             bool deque( T& v )
 126             {
 127                 return pop(v);
 128             }
 129         };
 130
 131         template <typename T, typename Traits=cds::container::fcdeque::type_traits, class Deque = std::deque<T> >
 132         class FCDequeR: public cds::container::FCDeque<T, Deque, Traits >
 133         {
 134             typedef cds::container::FCDeque<T, Deque, Traits > base_class;
 135         public:
 136             FCDequeR()
 137             {}
 138
 139             FCDequeR(
 140                 unsigned int nCompactFactor     ///< Flat combining: publication list compacting factor
 141                 ,unsigned int nCombinePassCount ///< Flat combining: number of combining passes for combiner thread
 142                 )
 143                 : base_class( nCompactFactor, nCombinePassCount )
 144             {}
 145
 146             bool push( T const& v )
 147             {
 148                 return base_class::push_back( v );
 149             }
 150             bool enqueue( T const& v )
 151             {
 152                 return push( v );
 153             }
 154
 155             bool pop( T& v )
 156             {
 157                 return base_class::pop_front( v );
 158             }
 159             bool deque( T& v )
 160             {
 161                 return pop(v);
 162             }
 163         };
 164
 165     }
 166
 167     template <typename Value>
 168     struct Types {
 169
 170         // MSQueue
 171         typedef cds::container::MSQueue<
 172             cds::gc::HP , Value
 173         >   MSQueue_HP;
 174
 175         typedef cds::container::MSQueue<
 176             cds::gc::HP , Value
 177             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 178         >   MSQueue_HP_michaelAlloc;
 179
 180         typedef cds::container::MSQueue<
 181             cds::gc::HP, Value
 182             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 183         >   MSQueue_HP_seqcst;
 184
 185         typedef cds::container::MSQueue< cds::gc::HRC,
 186             Value
 187         >   MSQueue_HRC;
 188
 189         typedef cds::container::MSQueue< cds::gc::HRC,
 190             Value
 191             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 192         >   MSQueue_HRC_michaelAlloc;
 193
 194         typedef cds::container::MSQueue< cds::gc::HRC,
 195             Value
 196             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 197         >   MSQueue_HRC_seqcst;
 198
 199         typedef cds::container::MSQueue< cds::gc::PTB,
 200             Value
 201         >   MSQueue_PTB;
 202
 203         typedef cds::container::MSQueue< cds::gc::PTB,
 204             Value
 205             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 206         >   MSQueue_PTB_michaelAlloc;
 207
 208         typedef cds::container::MSQueue< cds::gc::PTB,
 209             Value
 210             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 211         >   MSQueue_PTB_seqcst;
 212
 213         // MSQueue + item counter
 214         typedef cds::container::MSQueue< cds::gc::HP,
 215             Value
 216             ,cds::opt::item_counter< cds::atomicity::item_counter >
 217         >   MSQueue_HP_ic;
 218
 219         typedef cds::container::MSQueue< cds::gc::HRC,
 220             Value
 221             ,cds::opt::item_counter< cds::atomicity::item_counter >
 222         >   MSQueue_HRC_ic;
 223
 224         typedef cds::container::MSQueue< cds::gc::PTB,
 225             Value
 226             ,cds::opt::item_counter< cds::atomicity::item_counter >
 227         >   MSQueue_PTB_ic;
 228
 229         // MSQueue + stat
 230         typedef cds::container::MSQueue< cds::gc::HP,
 231             Value
 232             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 233         >   MSQueue_HP_stat;
 234
 235         typedef cds::container::MSQueue< cds::gc::HRC,
 236             Value
 237             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 238         >   MSQueue_HRC_stat;
 239
 240         typedef cds::container::MSQueue< cds::gc::PTB,
 241             Value
 242             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 243         >   MSQueue_PTB_stat;
 244
 245
 246         // MoirQueue
 247         typedef cds::container::MoirQueue< cds::gc::HP,
 248             Value
 249         >   MoirQueue_HP;
 250
 251         typedef cds::container::MoirQueue< cds::gc::HP,
 252             Value
 253             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 254         >   MoirQueue_HP_michaelAlloc;
 255
 256         typedef cds::container::MoirQueue< cds::gc::HP,
 257             Value
 258             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 259         >   MoirQueue_HP_seqcst;
 260
 261         typedef cds::container::MoirQueue< cds::gc::HRC,
 262             Value
 263         >   MoirQueue_HRC;
 264
 265         typedef cds::container::MoirQueue< cds::gc::HRC,
 266             Value
 267             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 268         >   MoirQueue_HRC_michaelAlloc;
 269
 270         typedef cds::container::MoirQueue< cds::gc::HRC,
 271             Value
 272             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 273         >   MoirQueue_HRC_seqcst;
 274
 275         typedef cds::container::MoirQueue< cds::gc::PTB,
 276             Value
 277         >   MoirQueue_PTB;
 278
 279         typedef cds::container::MoirQueue< cds::gc::PTB,
 280             Value
 281             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 282         >   MoirQueue_PTB_michaelAlloc;
 283
 284         typedef cds::container::MoirQueue< cds::gc::PTB,
 285             Value
 286             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 287         >   MoirQueue_PTB_seqcst;
 288
 289         // MoirQueue + item counter
 290         typedef cds::container::MoirQueue< cds::gc::HP,
 291             Value
 292             ,cds::opt::item_counter< cds::atomicity::item_counter >
 293         >   MoirQueue_HP_ic;
 294
 295         typedef cds::container::MoirQueue< cds::gc::HRC,
 296             Value
 297             ,cds::opt::item_counter< cds::atomicity::item_counter >
 298         >   MoirQueue_HRC_ic;
 299
 300         typedef cds::container::MoirQueue< cds::gc::PTB,
 301             Value
 302             ,cds::opt::item_counter< cds::atomicity::item_counter >
 303         >   MoirQueue_PTB_ic;
 304
 305         // MoirQueue + stat
 306         typedef cds::container::MoirQueue< cds::gc::HP,
 307             Value
 308             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 309         >   MoirQueue_HP_stat;
 310
 311         typedef cds::container::MoirQueue< cds::gc::HRC,
 312             Value
 313             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 314         >   MoirQueue_HRC_stat;
 315
 316         typedef cds::container::MoirQueue< cds::gc::PTB,
 317             Value
 318             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 319         >   MoirQueue_PTB_stat;
 320
 321         // OptimisticQueue
 322         typedef cds::container::OptimisticQueue< cds::gc::HP,
 323             Value
 324         >   OptimisticQueue_HP;
 325
 326         typedef cds::container::OptimisticQueue< cds::gc::HP,
 327             Value
 328             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 329         >   OptimisticQueue_HP_michaelAlloc;
 330
 331         typedef cds::container::OptimisticQueue< cds::gc::HP,
 332             Value
 333             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 334         >   OptimisticQueue_HP_seqcst;
 335
 336         typedef cds::container::OptimisticQueue< cds::gc::PTB,
 337             Value
 338         >   OptimisticQueue_PTB;
 339
 340         typedef cds::container::OptimisticQueue< cds::gc::PTB,
 341             Value
 342             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 343         >   OptimisticQueue_PTB_michaelAlloc;
 344
 345         typedef cds::container::OptimisticQueue< cds::gc::PTB,
 346             Value
 347             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 348         >   OptimisticQueue_PTB_seqcst;
 349
 350
 351         // OptimisticQueue + item counter
 352         typedef cds::container::OptimisticQueue< cds::gc::HP,
 353             Value
 354             ,cds::opt::item_counter< cds::atomicity::item_counter >
 355         >   OptimisticQueue_HP_ic;
 356
 357         typedef cds::container::OptimisticQueue< cds::gc::PTB,
 358             Value
 359             ,cds::opt::item_counter< cds::atomicity::item_counter >
 360         >   OptimisticQueue_PTB_ic;
 361
 362         // OptimisticQueue + stat
 363         typedef cds::container::OptimisticQueue< cds::gc::HP,
 364             Value
 365             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 366         >   OptimisticQueue_HP_stat;
 367
 368         typedef cds::container::OptimisticQueue< cds::gc::PTB,
 369             Value
 370             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 371         >   OptimisticQueue_PTB_stat;
 372
 373         // TsigasCycleQueue
 374         class TsigasCycleQueue_dyn
 375             : public cds::container::TsigasCycleQueue<
 376                 Value
 377                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 378             >
 379         {
 380             typedef cds::container::TsigasCycleQueue<
 381                 Value
 382                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 383             > base_class;
 384         public:
 385             TsigasCycleQueue_dyn()
 386                 : base_class( 1024 * 64 )
 387             {}
 388
 389             TsigasCycleQueue_dyn( size_t nCapacity )
 390                 : base_class( nCapacity )
 391             {}
 392
 393             cds::opt::none statistics() const
 394             {
 395                 return cds::opt::none();
 396             }
 397         };
 398
 399         class TsigasCycleQueue_dyn_michaelAlloc
 400             : public cds::container::TsigasCycleQueue<
 401                 Value
 402                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 403                 ,cds::opt::allocator< memory::MichaelAllocator<int> >
 404             >
 405         {
 406             typedef cds::container::TsigasCycleQueue<
 407                 Value
 408                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 409                 ,cds::opt::allocator< memory::MichaelAllocator<int> >
 410             > base_class;
 411         public:
 412             TsigasCycleQueue_dyn_michaelAlloc()
 413                 : base_class( 1024 * 64 )
 414             {}
 415
 416             TsigasCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 417                 : base_class( nCapacity )
 418             {}
 419
 420             cds::opt::none statistics() const
 421             {
 422                 return cds::opt::none();
 423             }
 424         };
 425
 426         class TsigasCycleQueue_dyn_ic
 427             : public cds::container::TsigasCycleQueue<
 428                 Value
 429                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 430                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 431             >
 432         {
 433             typedef cds::container::TsigasCycleQueue<
 434                 Value
 435                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 436                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 437             > base_class;
 438         public:
 439             TsigasCycleQueue_dyn_ic()
 440                 : base_class( 1024 * 64 )
 441             {}
 442             TsigasCycleQueue_dyn_ic( size_t nCapacity )
 443                 : base_class( nCapacity )
 444             {}
 445
 446             cds::opt::none statistics() const
 447             {
 448                 return cds::opt::none();
 449             }
 450         };
 451
 452         // VyukovMPMCCycleQueue
 453         class VyukovMPMCCycleQueue_dyn
 454             : public cds::container::VyukovMPMCCycleQueue<
 455                 Value
 456                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 457             >
 458         {
 459             typedef cds::container::VyukovMPMCCycleQueue<
 460                 Value
 461                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 462             > base_class;
 463         public:
 464             VyukovMPMCCycleQueue_dyn()
 465                 : base_class( 1024 * 64 )
 466             {}
 467             VyukovMPMCCycleQueue_dyn( size_t nCapacity )
 468                 : base_class( nCapacity )
 469             {}
 470
 471             cds::opt::none statistics() const
 472             {
 473                 return cds::opt::none();
 474             }
 475         };
 476
 477         class VyukovMPMCCycleQueue_dyn_michaelAlloc
 478             : public cds::container::VyukovMPMCCycleQueue<
 479             Value
 480             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int, memory::MichaelAllocator<int> > >
 481             >
 482         {
 483             typedef cds::container::VyukovMPMCCycleQueue<
 484                 Value
 485                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int, memory::MichaelAllocator<int> > >
 486             > base_class;
 487         public:
 488             VyukovMPMCCycleQueue_dyn_michaelAlloc()
 489                 : base_class( 1024 * 64 )
 490             {}
 491             VyukovMPMCCycleQueue_dyn_michaelAlloc( size_t nCapacity )
 492                 : base_class( nCapacity )
 493             {}
 494
 495             cds::opt::none statistics() const
 496             {
 497                 return cds::opt::none();
 498             }
 499         };
 500
 501         class VyukovMPMCCycleQueue_dyn_ic
 502             : public cds::container::VyukovMPMCCycleQueue<
 503                 Value
 504                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 505                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 506             >
 507         {
 508             typedef cds::container::VyukovMPMCCycleQueue<
 509                 Value
 510                 ,cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 511                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 512             > base_class;
 513         public:
 514             VyukovMPMCCycleQueue_dyn_ic()
 515                 : base_class( 1024 * 64 )
 516             {}
 517             VyukovMPMCCycleQueue_dyn_ic( size_t nCapacity )
 518                 : base_class( nCapacity )
 519             {}
 520
 521             cds::opt::none statistics() const
 522             {
 523                 return cds::opt::none();
 524             }
 525         };
 526
 527
 528         // MichaelDeque
 529         typedef details::MichaelDequeR< cds::gc::HP, Value >    MichaelDequeR_HP;
 530         typedef details::MichaelDequeR< cds::gc::HP, Value
 531             ,cds::opt::item_counter< cds::atomicity::item_counter >
 532         >    MichaelDequeR_HP_ic;
 533         typedef details::MichaelDequeR< cds::gc::HP, Value
 534             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 535         >    MichaelDequeR_HP_michaelAlloc;
 536         typedef details::MichaelDequeR< cds::gc::HP, Value
 537             ,cds::opt::stat< cds::intrusive::michael_deque::stat<> >
 538         >    MichaelDequeR_HP_stat;
 539
 540         typedef details::MichaelDequeR< cds::gc::PTB, Value >    MichaelDequeR_PTB;
 541         typedef details::MichaelDequeR< cds::gc::PTB, Value
 542             ,cds::opt::item_counter< cds::atomicity::item_counter >
 543         >    MichaelDequeR_PTB_ic;
 544         typedef details::MichaelDequeR< cds::gc::PTB, Value
 545             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 546         >    MichaelDequeR_PTB_michaelAlloc;
 547         typedef details::MichaelDequeR< cds::gc::PTB, Value
 548             ,cds::opt::stat< cds::intrusive::michael_deque::stat<> >
 549         >    MichaelDequeR_PTB_stat;
 550
 551         typedef details::MichaelDequeL< cds::gc::HP, Value >    MichaelDequeL_HP;
 552         typedef details::MichaelDequeL< cds::gc::HP, Value
 553             ,cds::opt::item_counter< cds::atomicity::item_counter >
 554         >    MichaelDequeL_HP_ic;
 555         typedef details::MichaelDequeL< cds::gc::HP, Value
 556             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 557         >    MichaelDequeL_HP_michaelAlloc;
 558         typedef details::MichaelDequeL< cds::gc::HP, Value
 559             ,cds::opt::stat< cds::intrusive::michael_deque::stat<> >
 560         >    MichaelDequeL_HP_stat;
 561
 562
 563         typedef details::MichaelDequeL< cds::gc::PTB, Value >    MichaelDequeL_PTB;
 564         typedef details::MichaelDequeL< cds::gc::PTB, Value
 565             ,cds::opt::item_counter< cds::atomicity::item_counter >
 566         >    MichaelDequeL_PTB_ic;
 567         typedef details::MichaelDequeL< cds::gc::PTB, Value
 568             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 569         >    MichaelDequeL_PTB_michaelAlloc;
 570         typedef details::MichaelDequeL< cds::gc::PTB, Value
 571             ,cds::opt::stat< cds::intrusive::michael_deque::stat<> >
 572         >    MichaelDequeL_PTB_stat;
 573
 574         // BasketQueue
 575         typedef cds::container::BasketQueue<
 576             cds::gc::HP , Value
 577         >   BasketQueue_HP;
 578
 579         typedef cds::container::BasketQueue<
 580             cds::gc::HP , Value
 581             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 582         >   BasketQueue_HP_michaelAlloc;
 583
 584         typedef cds::container::BasketQueue<
 585             cds::gc::HP, Value
 586             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 587         >   BasketQueue_HP_seqcst;
 588
 589         typedef cds::container::BasketQueue< cds::gc::HRC,
 590             Value
 591         >   BasketQueue_HRC;
 592
 593         typedef cds::container::BasketQueue< cds::gc::HRC,
 594             Value
 595             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 596         >   BasketQueue_HRC_michaelAlloc;
 597
 598         typedef cds::container::BasketQueue< cds::gc::HRC,
 599             Value
 600             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 601         >   BasketQueue_HRC_seqcst;
 602
 603         typedef cds::container::BasketQueue< cds::gc::PTB,
 604             Value
 605         >   BasketQueue_PTB;
 606
 607         typedef cds::container::BasketQueue< cds::gc::PTB,
 608             Value
 609             ,cds::opt::allocator< memory::MichaelAllocator<int> >
 610         >   BasketQueue_PTB_michaelAlloc;
 611
 612         typedef cds::container::BasketQueue< cds::gc::PTB,
 613             Value
 614             ,cds::opt::memory_model< cds::opt::v::sequential_consistent >
 615         >   BasketQueue_PTB_seqcst;
 616
 617         // BasketQueue + item counter
 618         typedef cds::container::BasketQueue< cds::gc::HP,
 619             Value
 620             ,cds::opt::item_counter< cds::atomicity::item_counter >
 621         >   BasketQueue_HP_ic;
 622
 623         typedef cds::container::BasketQueue< cds::gc::HRC,
 624             Value
 625             ,cds::opt::item_counter< cds::atomicity::item_counter >
 626         >   BasketQueue_HRC_ic;
 627
 628         typedef cds::container::BasketQueue< cds::gc::PTB,
 629             Value
 630             ,cds::opt::item_counter< cds::atomicity::item_counter >
 631         >   BasketQueue_PTB_ic;
 632
 633         // BasketQueue + stat
 634         typedef cds::container::BasketQueue< cds::gc::HP,
 635             Value
 636             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 637         >   BasketQueue_HP_stat;
 638
 639         typedef cds::container::BasketQueue< cds::gc::HRC,
 640             Value
 641             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 642         >   BasketQueue_HRC_stat;
 643
 644         typedef cds::container::BasketQueue< cds::gc::PTB,
 645             Value
 646             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 647         >   BasketQueue_PTB_stat;
 648
 649
 650         // RWQueue
 651         typedef cds::container::RWQueue<
 652             Value
 653         > RWQueue_Spin;
 654
 655         typedef cds::container::RWQueue<
 656             Value
 657             ,cds::opt::item_counter< cds::atomicity::item_counter >
 658         > RWQueue_Spin_ic;
 659
 660         typedef cds::container::RWQueue<
 661             Value
 662             ,cds::opt::stat< cds::intrusive::queue_stat<> >
 663         > RWQueue_Spin_stat;
 664
 665         // FCQueue
 666         class traits_FCQueue_elimination:
 667             public cds::container::fcqueue::make_traits<
 668                 cds::opt::enable_elimination< true >
 669             >::type
 670         {};
 671         class traits_FCQueue_elimination_stat:
 672             public cds::container::fcqueue::make_traits<
 673                 cds::opt::enable_elimination< true >
 674                 ,cds::opt::stat< cds::container::fcqueue::stat<> >
 675             >::type
 676         {};
 677
 678         typedef cds::container::FCQueue< Value > FCQueue_deque;
 679         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination > FCQueue_deque_elimination;
 680         typedef cds::container::FCQueue< Value, std::queue<Value>, traits_FCQueue_elimination_stat > FCQueue_deque_elimination_stat;
 681
 682         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> > > FCQueue_list;
 683         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination > FCQueue_list_elimination;
 684         typedef cds::container::FCQueue< Value, std::queue<Value, std::list<Value> >, traits_FCQueue_elimination_stat > FCQueue_list_elimination_stat;
 685
 686
 687    // FCDeque
 688         struct traits_FCDeque_stat:
 689             public cds::container::fcdeque::make_traits<
 690                 cds::opt::stat< cds::container::fcdeque::stat<> >
 691             >::type
 692         {};
 693         struct traits_FCDeque_elimination:
 694             public cds::container::fcdeque::make_traits<
 695                 cds::opt::enable_elimination< true >
 696             >::type
 697         {};
 698         struct traits_FCDeque_elimination_stat:
 699             public cds::container::fcdeque::make_traits<
 700                 cds::opt::stat< cds::container::fcdeque::stat<> >,
 701                 cds::opt::enable_elimination< true >
 702             >::type
 703         {};
 704         struct traits_FCDeque_mutex:
 705             public cds::container::fcdeque::make_traits<
 706                 cds::opt::lock_type< cds_std::mutex >
 707             >::type
 708         {};
 709
 710         typedef details::FCDequeL< Value > FCDequeL_default;
 711         typedef details::FCDequeL< Value, traits_FCDeque_mutex > FCDequeL_mutex;
 712         typedef details::FCDequeL< Value, traits_FCDeque_stat > FCDequeL_stat;
 713         typedef details::FCDequeL< Value, traits_FCDeque_elimination > FCDequeL_elimination;
 714         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat > FCDequeL_elimination_stat;
 715
 716         typedef details::FCDequeL< Value, cds::container::fcdeque::type_traits, boost::container::deque<Value> > FCDequeL_boost;
 717         typedef details::FCDequeL< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeL_boost_stat;
 718         typedef details::FCDequeL< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeL_boost_elimination;
 719         typedef details::FCDequeL< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeL_boost_elimination_stat;
 720
 721         typedef details::FCDequeR< Value > FCDequeR_default;
 722         typedef details::FCDequeR< Value, traits_FCDeque_mutex > FCDequeR_mutex;
 723         typedef details::FCDequeR< Value, traits_FCDeque_stat > FCDequeR_stat;
 724         typedef details::FCDequeR< Value, traits_FCDeque_elimination > FCDequeR_elimination;
 725         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat > FCDequeR_elimination_stat;
 726
 727         typedef details::FCDequeR< Value, cds::container::fcdeque::type_traits, boost::container::deque<Value> > FCDequeR_boost;
 728         typedef details::FCDequeR< Value, traits_FCDeque_stat, boost::container::deque<Value> > FCDequeR_boost_stat;
 729         typedef details::FCDequeR< Value, traits_FCDeque_elimination, boost::container::deque<Value> > FCDequeR_boost_elimination;
 730         typedef details::FCDequeR< Value, traits_FCDeque_elimination_stat, boost::container::deque<Value> > FCDequeR_boost_elimination_stat;
 731
 732         typedef StdQueue_deque<Value>               StdQueue_deque_Spinlock;
 733         typedef StdQueue_list<Value>                StdQueue_list_Spinlock;
 734         typedef StdQueue_deque<Value, cds_std::mutex> StdQueue_deque_BoostMutex;
 735         typedef StdQueue_list<Value, cds_std::mutex>  StdQueue_list_BoostMutex;
 736 #ifdef UNIT_LOCK_WIN_CS
 737         typedef StdQueue_deque<Value, lock::win::CS>    StdQueue_deque_WinCS;
 738         typedef StdQueue_list<Value, lock::win::CS>     StdQueue_list_WinCS;
 739         typedef StdQueue_deque<Value, lock::win::Mutex> StdQueue_deque_WinMutex;
 740         typedef StdQueue_list<Value, lock::win::Mutex>  StdQueue_list_WinMutex;
 741 #endif
 742
 743         // SegmentedQueue
 744         class traits_SegmentedQueue_spin_stat:
 745             public cds::container::segmented_queue::make_traits<
 746                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 747             >::type
 748         {};
 749         class traits_SegmentedQueue_mutex_stat:
 750             public cds::container::segmented_queue::make_traits<
 751                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 752                 ,cds::opt::lock_type< cds_std::mutex >
 753             >::type
 754         {};
 755         class traits_SegmentedQueue_mutex:
 756             public cds::container::segmented_queue::make_traits<
 757                 cds::opt::lock_type< cds_std::mutex >
 758             >::type
 759         {};
 760
 761         typedef cds::container::SegmentedQueue< cds::gc::HP, Value >  SegmentedQueue_HP_spin;
 762         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_HP_spin_stat;
 763         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_HP_mutex;
 764         typedef cds::container::SegmentedQueue< cds::gc::HP, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_HP_mutex_stat;
 765
 766         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value >  SegmentedQueue_PTB_spin;
 767         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_spin_stat >  SegmentedQueue_PTB_spin_stat;
 768         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_mutex >  SegmentedQueue_PTB_mutex;
 769         typedef cds::container::SegmentedQueue< cds::gc::PTB, Value, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_PTB_mutex_stat;
 770
 771
 772     };
 773 }
 774
 775
 776 // *********************************************
 777 // Queue statistics
 778 namespace std {
 779
 780     // cds::intrusive::queue_stat
 781     template <typename Counter>
 782     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::queue_stat<Counter> const& s )
 783     {
 784         return o
 785             << "\tStatistics:\n"
 786             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 787             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get()  << "\n"
 788             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 789             << "\t\t      Dequeue race: " << s.m_DequeueRace.get()  << "\n"
 790             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 791             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n"
 792 ;
 793     }
 794
 795     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::queue_dummy_stat const& s )
 796     {
 797         return o;
 798     }
 799
 800     static inline std::ostream& operator <<( std::ostream& o, cds::opt::none )
 801     {
 802         return o;
 803     }
 804
 805     // cds::intrusive::optimistic_queue::stat
 806     template <typename Counter>
 807     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::stat<Counter> const& s )
 808     {
 809         return o
 810             << static_cast<cds::intrusive::queue_stat<Counter> const&>( s )
 811             << "\t\t"
 812             << "\t\t    fix list call: " << s.m_FixListCount.get() << "\n";
 813     }
 814
 815     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::dummy_stat const& s )
 816     {
 817         return o;
 818     }
 819
 820     // cds::intrusive::basket_queue::stat
 821     template <typename Counter>
 822     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::basket_queue::stat<Counter> const& s )
 823     {
 824         return o
 825             << static_cast<cds::intrusive::queue_stat<Counter> const&>( s )
 826             << "\t\tTry Add basket count: " << s.m_TryAddBasket.get() << "\n"
 827             << "\t\t    Add basket count: " << s.m_AddBasketCount.get() << "\n";
 828     }
 829
 830     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::basket_queue::dummy_stat const& s )
 831     {
 832         return o;
 833     }
 834
 835     // cds::container::fcqueue::stat
 836     template <typename Counter>
 837     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::stat<Counter> const& s )
 838     {
 839             return o << "\tStatistics:\n"
 840                 << "\t                    Push: " << s.m_nEnqueue.get()           << "\n"
 841                 << "\t                PushMove: " << s.m_nEnqMove.get()           << "\n"
 842                 << "\t                     Pop: " << s.m_nDequeue.get()           << "\n"
 843                 << "\t               FailedPop: " << s.m_nFailedDeq.get()         << "\n"
 844                 << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 845                 << "\tFlat combining statistics:\n"
 846                 << "\t        Combining factor: " << s.combining_factor()         << "\n"
 847                 << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 848                 << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 849                 << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 850                 << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 851                 << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 852                 << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 853                 << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 854                 << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 855                 << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 856     }
 857
 858     static inline std::ostream& operator <<( std::ostream& o, cds::container::fcqueue::empty_stat const& s )
 859     {
 860         return o;
 861     }
 862
 863     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::empty_stat const& s )
 864     {
 865         return o;
 866     }
 867
 868     static inline ostream& operator <<( ostream& o, cds::container::fcdeque::stat<> const& s )
 869     {
 870         return o << "\tStatistics:\n"
 871             << "\t              Push front: " << s.m_nPushFront.get()         << "\n"
 872             << "\t         Push front move: " << s.m_nPushFrontMove.get()     << "\n"
 873             << "\t               Push back: " << s.m_nPushBack.get()          << "\n"
 874             << "\t          Push back move: " << s.m_nPushBackMove.get()      << "\n"
 875             << "\t               Pop front: " << s.m_nPopFront.get()          << "\n"
 876             << "\t        Failed pop front: " << s.m_nFailedPopFront.get()    << "\n"
 877             << "\t                Pop back: " << s.m_nPopBack.get()           << "\n"
 878             << "\t         Failed pop back: " << s.m_nFailedPopBack.get()     << "\n"
 879             << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 880             << "\tFlat combining statistics:\n"
 881             << "\t        Combining factor: " << s.combining_factor()         << "\n"
 882             << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 883             << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 884             << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 885             << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 886             << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 887             << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 888             << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 889             << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 890             << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 891     }
 892
 893 }
 894
 895 #endif // #ifndef __CDSUNIT_QUEUE_TYPES_H