tests/test-hdr/queue/hdr_intrusive_segmented_queue_hp.cpp

   1 //$$CDS-header$$
   2
   3 #include "hdr_intrusive_segmented_queue.h"
   4 #include <cds/intrusive/segmented_queue.h>
   5 #include <cds/gc/hp.h>
   6
   7 namespace queue {
   8
   9     void HdrIntrusiveSegmentedQueue::SegmQueue_HP()
  10     {
  11         struct queue_traits : public cds::intrusive::segmented_queue::traits
  12         {
  13             typedef Disposer disposer;
  14         };
  15         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
  16
  17         test<queue_type>();
  18     }
  19
  20     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_mutex()
  21     {
  22         struct queue_traits : public
  23             cds::intrusive::segmented_queue::make_traits <
  24                 cds::intrusive::opt::disposer< Disposer >
  25                 ,cds::opt::lock_type < std::mutex >
  26             > ::type
  27         {};
  28         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
  29
  30         test<queue_type>();
  31     }
  32
  33     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_shuffle()
  34     {
  35         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
  36             cds::intrusive::segmented_queue::make_traits<
  37                 cds::intrusive::opt::disposer< Disposer >
  38                 ,cds::opt::item_counter< cds::atomicity::item_counter >
  39                 ,cds::opt::permutation_generator< cds::opt::v::random_shuffle_permutation<> >
  40             >::type
  41         > queue_type;
  42
  43         test<queue_type>();
  44     }
  45
  46     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_stat()
  47     {
  48         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
  49             cds::intrusive::segmented_queue::make_traits<
  50                 cds::intrusive::opt::disposer< Disposer >
  51                 ,cds::opt::item_counter< cds::atomicity::item_counter >
  52                 ,cds::opt::permutation_generator< cds::opt::v::random_permutation<> >
  53                 ,cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
  54             >::type
  55         > queue_type;
  56
  57         test<queue_type>();
  58     }
  59
  60     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_cacheline_padding()
  61     {
  62         struct queue_traits : public cds::intrusive::segmented_queue::traits
  63         {
  64             typedef Disposer disposer;
  65             enum { padding = cds::opt::cache_line_padding };
  66         };
  67         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
  68
  69         test<queue_type>();
  70     }
  71
  72     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_mutex_cacheline_padding()
  73     {
  74         struct queue_traits : public
  75             cds::intrusive::segmented_queue::make_traits <
  76                 cds::intrusive::opt::disposer< Disposer >
  77                 ,cds::opt::lock_type < std::mutex >
  78                 ,cds::opt::padding< cds::opt::cache_line_padding >
  79             > ::type
  80         {};
  81         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
  82
  83         test<queue_type>();
  84     }
  85
  86     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_shuffle_cacheline_padding()
  87     {
  88         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
  89             cds::intrusive::segmented_queue::make_traits<
  90                 cds::intrusive::opt::disposer< Disposer >
  91                 ,cds::opt::item_counter< cds::atomicity::item_counter >
  92                 , cds::opt::padding< cds::opt::cache_line_padding >
  93                 ,cds::opt::permutation_generator< cds::opt::v::random_shuffle_permutation<> >
  94             >::type
  95         > queue_type;
  96
  97         test<queue_type>();
  98     }
  99
 100     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_stat_cacheline_padding()
 101     {
 102         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
 103             cds::intrusive::segmented_queue::make_traits<
 104                 cds::intrusive::opt::disposer< Disposer >
 105                 , cds::opt::padding< cds::opt::cache_line_padding >
 106                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 107                 ,cds::opt::permutation_generator< cds::opt::v::random_permutation<> >
 108                 ,cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 109             >::type
 110         > queue_type;
 111
 112         test<queue_type>();
 113     }
 114
 115     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_256_padding()
 116     {
 117         struct queue_traits : public cds::intrusive::segmented_queue::traits
 118         {
 119             typedef Disposer disposer;
 120             enum { padding = 256 };
 121         };
 122         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
 123
 124         test<queue_type>();
 125     }
 126
 127     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_mutex_256_padding()
 128     {
 129         struct queue_traits : public
 130             cds::intrusive::segmented_queue::make_traits <
 131                 cds::intrusive::opt::disposer< Disposer >
 132                 ,cds::opt::lock_type < std::mutex >
 133                 ,cds::opt::padding< 256 >
 134             > ::type
 135         {};
 136         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item, queue_traits > queue_type;
 137
 138         test<queue_type>();
 139     }
 140
 141     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_shuffle_256_padding()
 142     {
 143         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
 144             cds::intrusive::segmented_queue::make_traits<
 145                 cds::intrusive::opt::disposer< Disposer >
 146                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 147                 , cds::opt::padding< 256 >
 148                 ,cds::opt::permutation_generator< cds::opt::v::random_shuffle_permutation<> >
 149             >::type
 150         > queue_type;
 151
 152         test<queue_type>();
 153     }
 154
 155     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_stat_256_padding()
 156     {
 157         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
 158             cds::intrusive::segmented_queue::make_traits<
 159                 cds::intrusive::opt::disposer< Disposer >
 160                 , cds::opt::padding< 256 >
 161                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 162                 ,cds::opt::permutation_generator< cds::opt::v::random_permutation<> >
 163                 ,cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 164             >::type
 165         > queue_type;
 166
 167         test<queue_type>();
 168     }
 169
 170     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_cacheline_padding_bigdata()
 171     {
 172         struct queue_traits : public cds::intrusive::segmented_queue::traits
 173         {
 174             typedef Disposer disposer;
 175             enum { padding = cds::opt::cache_line_padding | cds::opt::padding_tiny_data_only };
 176         };
 177         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, big_item, queue_traits > queue_type;
 178
 179         test<queue_type>();
 180     }
 181
 182     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_mutex_cacheline_padding_bigdata()
 183     {
 184         struct queue_traits : public
 185             cds::intrusive::segmented_queue::make_traits <
 186                 cds::intrusive::opt::disposer< Disposer >
 187                 ,cds::opt::lock_type < std::mutex >
 188                 , cds::opt::padding< cds::opt::cache_line_padding | cds::opt::padding_tiny_data_only >
 189             > ::type
 190         {};
 191         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, big_item, queue_traits > queue_type;
 192
 193         test<queue_type>();
 194     }
 195
 196     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_shuffle_cacheline_padding_bigdata()
 197     {
 198         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, big_item,
 199             cds::intrusive::segmented_queue::make_traits<
 200                 cds::intrusive::opt::disposer< Disposer >
 201                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 202                 , cds::opt::padding< cds::opt::cache_line_padding | cds::opt::padding_tiny_data_only >
 203                 ,cds::opt::permutation_generator< cds::opt::v::random_shuffle_permutation<> >
 204             >::type
 205         > queue_type;
 206
 207         test<queue_type>();
 208     }
 209
 210     void HdrIntrusiveSegmentedQueue::SegmQueue_HP_stat_cacheline_padding_bigdata()
 211     {
 212         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, big_item,
 213             cds::intrusive::segmented_queue::make_traits<
 214                 cds::intrusive::opt::disposer< Disposer >
 215                 , cds::opt::padding< cds::opt::cache_line_padding | cds::opt::padding_tiny_data_only >
 216                 ,cds::opt::item_counter< cds::atomicity::item_counter >
 217                 ,cds::opt::permutation_generator< cds::opt::v::random_permutation<> >
 218                 ,cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
 219             >::type
 220         > queue_type;
 221
 222         test<queue_type>();
 223     }
 224
 225 } // namespace queue