tests/unit/queue/intrusive_queue_type.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifndef CDSUNIT_INTRUSIVE_QUEUE_TYPES_H
  32 #define CDSUNIT_INTRUSIVE_QUEUE_TYPES_H
  33
  34 #include <cds/intrusive/msqueue.h>
  35 #include <cds/intrusive/moir_queue.h>
  36 #include <cds/intrusive/optimistic_queue.h>
  37 #include <cds/intrusive/tsigas_cycle_queue.h>
  38 #include <cds/intrusive/vyukov_mpmc_cycle_queue.h>
  39 #include <cds/intrusive/basket_queue.h>
  40 #include <cds/intrusive/fcqueue.h>
  41 #include <cds/intrusive/segmented_queue.h>
  42
  43 #include <cds/gc/hp.h>
  44 #include <cds/gc/dhp.h>
  45
  46 #include <boost/intrusive/slist.hpp>
  47
  48 #include "print_segmentedqueue_stat.h"
  49
  50 namespace queue {
  51
  52     namespace details {
  53         struct empty_stat {};
  54
  55         template <typename T, typename Lock=std::mutex>
  56         class BoostSList
  57         {
  58             typedef boost::intrusive::slist< T, boost::intrusive::cache_last<true> >    slist_type;
  59             typedef Lock lock_type;
  60             typedef std::lock_guard<lock_type> lock_guard;
  61
  62             slist_type  m_List;
  63             mutable lock_type m_Lock;
  64         public:
  65             typedef T value_type;
  66
  67         public:
  68             bool push( value_type& v )
  69             {
  70                 lock_guard l( m_Lock );
  71                 m_List.push_back( v );
  72                 return true;
  73             }
  74
  75             bool enqueue( value_type& v )
  76             {
  77                 return push( v );
  78             }
  79
  80             value_type * pop()
  81             {
  82                 lock_guard l( m_Lock );
  83                 if ( m_List.empty() )
  84                     return nullptr;
  85                 value_type& v = m_List.front();
  86                 m_List.pop_front();
  87                 return &v;
  88             }
  89             value_type * deque()
  90             {
  91                 return pop();
  92             }
  93
  94             bool empty() const
  95             {
  96                 lock_guard l( m_Lock );
  97                 return m_List.empty();
  98             }
  99
 100             size_t size() const
 101             {
 102                 lock_guard l( m_Lock );
 103                 return m_List.size();
 104             }
 105
 106             empty_stat statistics() const
 107             {
 108                 return empty_stat();
 109             }
 110         };
 111     }
 112
 113     template <typename T>
 114     struct Types {
 115
 116         // MSQueue, MoirQueue
 117         struct traits_MSQueue_HP : public cds::intrusive::msqueue::traits
 118         {
 119             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::HP > > hook;
 120         };
 121         typedef cds::intrusive::MSQueue< cds::gc::HP, T, traits_MSQueue_HP > MSQueue_HP;
 122         typedef cds::intrusive::MoirQueue< cds::gc::HP, T, traits_MSQueue_HP > MoirQueue_HP;
 123
 124         struct traits_MSQueue_HP_seqcst : public cds::intrusive::msqueue::traits
 125         {
 126             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::HP > > hook;
 127             typedef cds::opt::v::sequential_consistent memory_model;
 128         };
 129         typedef cds::intrusive::MSQueue< cds::gc::HP, T, traits_MSQueue_HP_seqcst > MSQueue_HP_seqcst;
 130         typedef cds::intrusive::MoirQueue< cds::gc::HP, T, traits_MSQueue_HP_seqcst > MoirQueue_HP_seqcst;
 131
 132         struct traits_MSQueue_DHP : public cds::intrusive::msqueue::traits
 133         {
 134             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::DHP > > hook;
 135         };
 136         typedef cds::intrusive::MSQueue< cds::gc::DHP, T, traits_MSQueue_DHP > MSQueue_DHP;
 137         typedef cds::intrusive::MoirQueue< cds::gc::DHP, T, traits_MSQueue_DHP > MoirQueue_DHP;
 138
 139         struct traits_MSQueue_DHP_seqcst : public cds::intrusive::msqueue::traits
 140         {
 141             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::DHP > > hook;
 142             typedef cds::opt::v::sequential_consistent memory_model;
 143         };
 144         typedef cds::intrusive::MSQueue< cds::gc::DHP, T, traits_MSQueue_DHP_seqcst > MSQueue_DHP_seqcst;
 145         typedef cds::intrusive::MoirQueue< cds::gc::DHP, T, traits_MSQueue_DHP_seqcst > MoirQueue_DHP_seqcst;
 146
 147         // MSQueue + item counter
 148         struct traits_MSQueue_HP_ic : public cds::intrusive::msqueue::traits
 149         {
 150             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::HP > > hook;
 151             typedef cds::atomicity::item_counter item_counter;
 152         };
 153         typedef cds::intrusive::MSQueue< cds::gc::HP, T, traits_MSQueue_HP_ic > MSQueue_HP_ic;
 154         typedef cds::intrusive::MoirQueue< cds::gc::HP, T, traits_MSQueue_HP_ic > MoirQueue_HP_ic;
 155
 156         struct traits_MSQueue_DHP_ic : public cds::intrusive::msqueue::traits
 157         {
 158             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::DHP > > hook;
 159             typedef cds::atomicity::item_counter item_counter;
 160         };
 161         typedef cds::intrusive::MSQueue< cds::gc::DHP, T, traits_MSQueue_DHP_ic > MSQueue_DHP_ic;
 162         typedef cds::intrusive::MoirQueue< cds::gc::DHP, T, traits_MSQueue_DHP_ic > MoirQueue_DHP_ic;
 163
 164         // MSQueue + stat
 165         struct traits_MSQueue_HP_stat : public cds::intrusive::msqueue::traits
 166         {
 167             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::HP > > hook;
 168             typedef cds::intrusive::msqueue::stat<> stat;
 169         };
 170         typedef cds::intrusive::MSQueue< cds::gc::HP, T, traits_MSQueue_HP_stat > MSQueue_HP_stat;
 171         typedef cds::intrusive::MoirQueue< cds::gc::HP, T, traits_MSQueue_HP_stat > MoirQueue_HP_stat;
 172
 173         struct traits_MSQueue_DHP_stat : public cds::intrusive::msqueue::traits
 174         {
 175             typedef cds::intrusive::msqueue::base_hook< cds::opt::gc< cds::gc::DHP > > hook;
 176             typedef cds::intrusive::msqueue::stat<> stat;
 177         };
 178         typedef cds::intrusive::MSQueue< cds::gc::DHP, T, traits_MSQueue_DHP_stat > MSQueue_DHP_stat;
 179         typedef cds::intrusive::MoirQueue< cds::gc::DHP, T, traits_MSQueue_DHP_stat > MoirQueue_DHP_stat;
 180
 181
 182         // OptimisticQueue
 183         struct traits_OptimisticQueue_HP : public cds::intrusive::optimistic_queue::traits
 184         {
 185             typedef cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > hook;
 186         };
 187         typedef cds::intrusive::OptimisticQueue< cds::gc::HP, T, traits_OptimisticQueue_HP > OptimisticQueue_HP;
 188
 189         struct traits_OptimisticQueue_HP_seqcst : public
 190             cds::intrusive::optimistic_queue::make_traits <
 191                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 192                 , cds::opt::memory_model< cds::opt::v::sequential_consistent >
 193             >::type
 194         {};
 195         typedef cds::intrusive::OptimisticQueue< cds::gc::HP, T, traits_OptimisticQueue_HP_seqcst > OptimisticQueue_HP_seqcst;
 196
 197         struct traits_OptimisticQueue_DHP : public cds::intrusive::optimistic_queue::traits
 198         {
 199             typedef cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::DHP > > hook;
 200         };
 201         typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP > OptimisticQueue_DHP;
 202
 203         struct traits_OptimisticQueue_DHP_seqcst: public
 204             cds::intrusive::optimistic_queue::make_traits <
 205                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 206                 , cds::opt::memory_model< cds::opt::v::sequential_consistent >
 207             >::type
 208         {};
 209         typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP_seqcst > OptimisticQueue_DHP_seqcst;
 210
 211         // OptimisticQueue + item counter
 212         struct traits_OptimisticQueue_HP_ic: public
 213             cds::intrusive::optimistic_queue::make_traits <
 214                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 215                 , cds::opt::item_counter< cds::atomicity::item_counter >
 216             >::type
 217         {};
 218         typedef cds::intrusive::OptimisticQueue< cds::gc::HP, T, traits_OptimisticQueue_HP_ic > OptimisticQueue_HP_ic;
 219
 220         struct traits_OptimisticQueue_DHP_ic: public
 221             cds::intrusive::optimistic_queue::make_traits <
 222                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 223                 , cds::opt::item_counter< cds::atomicity::item_counter >
 224             >::type
 225         {};
 226         typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP_ic > OptimisticQueue_DHP_ic;
 227
 228         // OptimisticQueue + stat
 229         struct traits_OptimisticQueue_HP_stat: public
 230             cds::intrusive::optimistic_queue::make_traits <
 231                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 232                 , cds::opt::stat< cds::intrusive::optimistic_queue::stat<> >
 233             >::type
 234         {};
 235         typedef cds::intrusive::OptimisticQueue< cds::gc::HP, T, traits_OptimisticQueue_HP_stat > OptimisticQueue_HP_stat;
 236
 237         struct traits_OptimisticQueue_DHP_stat: public
 238             cds::intrusive::optimistic_queue::make_traits <
 239                 cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 240                 , cds::opt::stat< cds::intrusive::optimistic_queue::stat<> >
 241             >::type
 242         {};
 243         typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP_stat > OptimisticQueue_DHP_stat;
 244
 245         // TsigasCycleQueue
 246         class TsigasCycleQueue_dyn
 247             : public cds::intrusive::TsigasCycleQueue< T,
 248                 typename cds::intrusive::tsigas_queue::make_traits<
 249                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 250                 >::type
 251             >
 252         {
 253             typedef cds::intrusive::TsigasCycleQueue< T,
 254                 typename cds::intrusive::tsigas_queue::make_traits<
 255                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 256                 >::type
 257             > base_class;
 258         public:
 259             TsigasCycleQueue_dyn()
 260                 : base_class( 1024 * 64 )
 261             {}
 262
 263             TsigasCycleQueue_dyn( size_t nCapacity )
 264                 : base_class( nCapacity )
 265             {}
 266
 267             cds::opt::none statistics() const
 268             {
 269                 return cds::opt::none();
 270             }
 271         };
 272
 273         class TsigasCycleQueue_dyn_ic
 274             : public cds::intrusive::TsigasCycleQueue< T,
 275                 typename cds::intrusive::tsigas_queue::make_traits<
 276                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 277                     ,cds::opt::item_counter< cds::atomicity::item_counter >
 278                 >::type
 279             >
 280         {
 281             typedef cds::intrusive::TsigasCycleQueue< T,
 282                 typename cds::intrusive::tsigas_queue::make_traits<
 283                     cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
 284                     ,cds::opt::item_counter< cds::atomicity::item_counter >
 285                 >::type
 286             > base_class;
 287         public:
 288             TsigasCycleQueue_dyn_ic()
 289                 : base_class( 1024 * 64 )
 290             {}
 291             TsigasCycleQueue_dyn_ic( size_t nCapacity )
 292                 : base_class( nCapacity )
 293             {}
 294
 295             cds::opt::none statistics() const
 296             {
 297                 return cds::opt::none();
 298             }
 299         };
 300
 301         // VyukovMPMCCycleQueue
 302         struct traits_VyukovMPMCCycleQueue_dyn : public cds::intrusive::vyukov_queue::traits
 303         {
 304             typedef cds::opt::v::dynamic_buffer< int > buffer;
 305         };
 306         class VyukovMPMCCycleQueue_dyn
 307             : public cds::intrusive::VyukovMPMCCycleQueue< T, traits_VyukovMPMCCycleQueue_dyn >
 308         {
 309             typedef cds::intrusive::VyukovMPMCCycleQueue< T, traits_VyukovMPMCCycleQueue_dyn > base_class;
 310         public:
 311             VyukovMPMCCycleQueue_dyn()
 312                 : base_class( 1024 * 64 )
 313             {}
 314             VyukovMPMCCycleQueue_dyn( size_t nCapacity )
 315                 : base_class( nCapacity )
 316             {}
 317
 318             cds::opt::none statistics() const
 319             {
 320                 return cds::opt::none();
 321             }
 322         };
 323
 324         struct traits_VyukovMPMCCycleQueue_dyn_ic : public traits_VyukovMPMCCycleQueue_dyn
 325         {
 326             typedef cds::atomicity::item_counter item_counter;
 327         };
 328         class VyukovMPMCCycleQueue_dyn_ic
 329             : public cds::intrusive::VyukovMPMCCycleQueue< T, traits_VyukovMPMCCycleQueue_dyn_ic >
 330         {
 331             typedef cds::intrusive::VyukovMPMCCycleQueue< T, traits_VyukovMPMCCycleQueue_dyn_ic > base_class;
 332         public:
 333             VyukovMPMCCycleQueue_dyn_ic()
 334                 : base_class( 1024 * 64 )
 335             {}
 336             VyukovMPMCCycleQueue_dyn_ic( size_t nCapacity )
 337                 : base_class( nCapacity )
 338             {}
 339
 340             cds::opt::none statistics() const
 341             {
 342                 return cds::opt::none();
 343             }
 344         };
 345
 346         // BasketQueue
 347         struct traits_BasketQueue_HP : public
 348             cds::intrusive::basket_queue::make_traits <
 349                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 350             > ::type
 351         {};
 352         typedef cds::intrusive::BasketQueue< cds::gc::HP, T, traits_BasketQueue_HP > BasketQueue_HP;
 353
 354         struct traits_BasketQueue_HP_seqcst: public
 355             cds::intrusive::basket_queue::make_traits <
 356                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 357                 , cds::opt::memory_model< cds::opt::v::sequential_consistent >
 358             > ::type
 359         {};
 360         typedef cds::intrusive::BasketQueue<cds::gc::HP, T, traits_BasketQueue_HP_seqcst > BasketQueue_HP_seqcst;
 361
 362         struct traits_BasketQueue_DHP : public
 363             cds::intrusive::basket_queue::make_traits <
 364                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 365             > ::type
 366         {};
 367         typedef cds::intrusive::BasketQueue< cds::gc::DHP, T, traits_BasketQueue_DHP > BasketQueue_DHP;
 368
 369         struct traits_BasketQueue_DHP_seqcst: public
 370             cds::intrusive::basket_queue::make_traits <
 371                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 372                 , cds::opt::memory_model< cds::opt::v::sequential_consistent >
 373             > ::type
 374         {};
 375         typedef cds::intrusive::BasketQueue< cds::gc::DHP, T, traits_BasketQueue_DHP_seqcst > BasketQueue_DHP_seqcst;
 376
 377         // BasketQueue + item counter
 378         struct traits_BasketQueue_HP_ic : public
 379             cds::intrusive::basket_queue::make_traits <
 380                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 381                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 382             > ::type
 383         {};
 384         typedef cds::intrusive::BasketQueue< cds::gc::HP, T, traits_BasketQueue_HP_ic > BasketQueue_HP_ic;
 385
 386         struct traits_BasketQueue_DHP_ic : public
 387             cds::intrusive::basket_queue::make_traits <
 388                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 389                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 390             > ::type
 391         {};
 392         typedef cds::intrusive::BasketQueue< cds::gc::DHP, T, traits_BasketQueue_DHP_ic > BasketQueue_DHP_ic;
 393
 394         // BasketQueue + stat
 395         struct traits_BasketQueue_HP_stat : public
 396             cds::intrusive::basket_queue::make_traits <
 397                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
 398                 , cds::opt::stat< cds::intrusive::basket_queue::stat<> >
 399             > ::type
 400         {};
 401         typedef cds::intrusive::BasketQueue< cds::gc::HP, T, traits_BasketQueue_HP_stat > BasketQueue_HP_stat;
 402
 403         struct traits_BasketQueue_DHP_stat : public
 404             cds::intrusive::basket_queue::make_traits <
 405                 cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
 406                 , cds::opt::stat< cds::intrusive::basket_queue::stat<> >
 407             > ::type
 408         {};
 409         typedef cds::intrusive::BasketQueue< cds::gc::DHP, T, traits_BasketQueue_DHP_stat > BasketQueue_DHP_stat;
 410
 411         // FCQueue
 412         class traits_FCQueue_delay2:
 413             public cds::intrusive::fcqueue::make_traits<
 414                 cds::opt::back_off< cds::backoff::delay_of<2> >
 415             >::type
 416         {};
 417         class traits_FCQueue_delay2_elimination:
 418             public cds::intrusive::fcqueue::make_traits<
 419                 cds::opt::back_off< cds::backoff::delay_of<2> >
 420                 ,cds::opt::enable_elimination< true >
 421             >::type
 422         {};
 423         class traits_FCQueue_delay2_elimination_stat:
 424             public cds::intrusive::fcqueue::make_traits<
 425                 cds::opt::back_off< cds::backoff::delay_of<2> >
 426                 ,cds::opt::stat< cds::intrusive::fcqueue::stat<> >
 427                 ,cds::opt::enable_elimination< true >
 428             >::type
 429         {};
 430         class traits_FCQueue_expbackoff_elimination:
 431             public cds::intrusive::fcqueue::make_traits<
 432                 cds::opt::enable_elimination< true >
 433                 ,cds::opt::elimination_backoff< cds::backoff::Default >
 434             >::type
 435         {};
 436         class traits_FCQueue_expbackoff_elimination_stat:
 437             public cds::intrusive::fcqueue::make_traits<
 438                 cds::opt::enable_elimination< true >
 439                 ,cds::opt::stat< cds::intrusive::fcqueue::stat<> >
 440                 ,cds::opt::elimination_backoff< cds::backoff::Default >
 441             >::type
 442         {};
 443
 444         typedef cds::intrusive::FCQueue< T, boost::intrusive::list<T>, traits_FCQueue_delay2 > FCQueue_list_delay2;
 445         typedef cds::intrusive::FCQueue< T, boost::intrusive::list<T>, traits_FCQueue_delay2_elimination > FCQueue_list_delay2_elimination;
 446         typedef cds::intrusive::FCQueue< T, boost::intrusive::list<T>, traits_FCQueue_delay2_elimination_stat > FCQueue_list_delay2_elimination_stat;
 447         typedef cds::intrusive::FCQueue< T, boost::intrusive::list<T>, traits_FCQueue_expbackoff_elimination > FCQueue_list_expbackoff_elimination;
 448         typedef cds::intrusive::FCQueue< T, boost::intrusive::list<T>, traits_FCQueue_expbackoff_elimination_stat > FCQueue_list_expbackoff_elimination_stat;
 449
 450         // SegmentedQueue
 451         class traits_SegmentedQueue_spin_stat:
 452             public cds::intrusive::segmented_queue::make_traits<
 453                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 454             >::type
 455         {};
 456         class traits_SegmentedQueue_spin_padding :
 457             public cds::intrusive::segmented_queue::make_traits<
 458             cds::opt::padding< cds::opt::cache_line_padding >
 459             >::type
 460         {};
 461         class traits_SegmentedQueue_mutex_stat :
 462             public cds::intrusive::segmented_queue::make_traits<
 463                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 464                 ,cds::opt::lock_type< std::mutex >
 465             >::type
 466         {};
 467         class traits_SegmentedQueue_mutex:
 468             public cds::intrusive::segmented_queue::make_traits<
 469                 cds::opt::lock_type< std::mutex >
 470             >::type
 471         {};
 472         class traits_SegmentedQueue_mutex_padding:
 473             public cds::intrusive::segmented_queue::make_traits<
 474                 cds::opt::lock_type< std::mutex >
 475                 ,cds::opt::padding< cds::opt::cache_line_padding >
 476             >::type
 477         {};
 478
 479         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T >  SegmentedQueue_HP_spin;
 480         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T, traits_SegmentedQueue_spin_padding >  SegmentedQueue_HP_spin_padding;
 481         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T, traits_SegmentedQueue_spin_stat >  SegmentedQueue_HP_spin_stat;
 482         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T, traits_SegmentedQueue_mutex >  SegmentedQueue_HP_mutex;
 483         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_HP_mutex_padding;
 484         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, T, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_HP_mutex_stat;
 485
 486         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T >  SegmentedQueue_DHP_spin;
 487         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T, traits_SegmentedQueue_spin_padding >  SegmentedQueue_DHP_spin_padding;
 488         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T, traits_SegmentedQueue_spin_stat >  SegmentedQueue_DHP_spin_stat;
 489         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T, traits_SegmentedQueue_mutex >  SegmentedQueue_DHP_mutex;
 490         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T, traits_SegmentedQueue_mutex_padding >  SegmentedQueue_DHP_mutex_padding;
 491         typedef cds::intrusive::SegmentedQueue< cds::gc::DHP, T, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_DHP_mutex_stat;
 492
 493         // Boost SList
 494         typedef details::BoostSList< T, std::mutex >      BoostSList_mutex;
 495         typedef details::BoostSList< T, cds::sync::spin > BoostSList_spin;
 496     };
 497 }
 498
 499
 500 // *********************************************
 501 // Queue statistics
 502 namespace std {
 503     /*
 504     // cds::intrusive::queue_stat
 505     template <typename Counter>
 506     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_stat<Counter> const& s)
 507     {
 508         return o
 509             << "\tStatistics:\n"
 510             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 511             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 512             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 513             << "\t\t      Dequeue race: " << s.m_DequeueRace.get() << "\n"
 514             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 515             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n";
 516     }
 517     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::queue_dummy_stat const& s)
 518     {
 519         return o;
 520     }
 521     */
 522
 523
 524     template <typename Counter>
 525     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::basket_queue::stat<Counter> const& s)
 526     {
 527         return o
 528             << "\tStatistics:\n"
 529             << "\t\t      Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 530             << "\t\t       Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 531             << "\t\t      Dequeue count: " << s.m_DequeueCount.get() << "\n"
 532             << "\t\t       Dequeue race: " << s.m_DequeueRace.get() << "\n"
 533             << "\t\t Advance tail error: " << s.m_AdvanceTailError.get() << "\n"
 534             << "\t\t           Bad tail: " << s.m_BadTail.get() << "\n"
 535             << "\t\tAdd basket attempts: " << s.m_TryAddBasket.get() << "\n"
 536             << "\t\t Add basket success: " << s.m_AddBasketCount.get() << "\n";
 537     }
 538     static inline std::ostream& operator <<(std::ostream& o, cds::intrusive::basket_queue::empty_stat const& /*s*/)
 539     {
 540         return o;
 541     }
 542
 543     template <typename Counter>
 544     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::msqueue::stat<Counter> const& s )
 545     {
 546         return o
 547             << "\tStatistics:\n"
 548             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 549             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get()  << "\n"
 550             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 551             << "\t\t      Dequeue race: " << s.m_DequeueRace.get()  << "\n"
 552             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 553             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n";
 554     }
 555
 556     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::msqueue::empty_stat const& /*s*/ )
 557     {
 558         return o;
 559     }
 560
 561     static inline std::ostream& operator <<( std::ostream& o, cds::opt::none )
 562     {
 563         return o;
 564     }
 565
 566     // cds::intrusive::optimistic_queue::stat
 567     template <typename Counter>
 568     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::stat<Counter> const& s )
 569     {
 570         return o
 571             << "\tStatistics:\n"
 572             << "\t\t     Enqueue count: " << s.m_EnqueueCount.get() << "\n"
 573             << "\t\t      Enqueue race: " << s.m_EnqueueRace.get() << "\n"
 574             << "\t\t     Dequeue count: " << s.m_DequeueCount.get() << "\n"
 575             << "\t\t      Dequeue race: " << s.m_DequeueRace.get() << "\n"
 576             << "\t\tAdvance tail error: " << s.m_AdvanceTailError.get() << "\n"
 577             << "\t\t          Bad tail: " << s.m_BadTail.get() << "\n"
 578             << "\t\t     fix list call: " << s.m_FixListCount.get() << "\n";
 579     }
 580
 581     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::optimistic_queue::empty_stat const& /*s*/ )
 582     {
 583         return o;
 584     }
 585
 586     // cds::intrusive::fcqueue::stat
 587     template <typename Counter>
 588     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::fcqueue::stat<Counter> const& s )
 589     {
 590             return o << "\tStatistics:\n"
 591                 << "\t                    Push: " << s.m_nEnqueue.get()           << "\n"
 592                 << "\t                     Pop: " << s.m_nDequeue.get()           << "\n"
 593                 << "\t               FailedPop: " << s.m_nFailedDeq.get()         << "\n"
 594                 << "\t  Collided push/pop pair: " << s.m_nCollided.get()          << "\n"
 595                 << "\tFlat combining statistics:\n"
 596                 << "\t        Combining factor: " << s.combining_factor()         << "\n"
 597                 << "\t         Operation count: " << s.m_nOperationCount.get()    << "\n"
 598                 << "\t      Combine call count: " << s.m_nCombiningCount.get()    << "\n"
 599                 << "\t        Compact pub-list: " << s.m_nCompactPublicationList.get() << "\n"
 600                 << "\t   Deactivate pub-record: " << s.m_nDeactivatePubRecord.get()    << "\n"
 601                 << "\t     Activate pub-record: " << s.m_nActivatePubRecord.get() << "\n"
 602                 << "\t       Create pub-record: " << s.m_nPubRecordCreated.get()  << "\n"
 603                 << "\t       Delete pub-record: " << s.m_nPubRecordDeteted.get()  << "\n"
 604                 << "\t      Acquire pub-record: " << s.m_nAcquirePubRecCount.get()<< "\n"
 605                 << "\t      Release pub-record: " << s.m_nReleasePubRecCount.get()<< "\n";
 606     }
 607
 608     static inline std::ostream& operator <<( std::ostream& o, cds::intrusive::fcqueue::empty_stat const& /*s*/ )
 609     {
 610         return o;
 611     }
 612
 613     static inline std::ostream& operator <<( std::ostream& o, queue::details::empty_stat const& /*s*/ )
 614     {
 615         return o;
 616     }
 617
 618 } // namespace std
 619
 620 #endif // #ifndef CDSUNIT_INTRUSIVE_QUEUE_TYPES_H