libcdsTest/ms-queue/intrusive_msqueue_hp.cc

   1 #include "test_intrusive_msqueue.h"
   2
   3 #include <stdio.h>
   4 #include <cds/init.h>
   5 #include <cds/gc/hp.h>
   6 #include <cds/intrusive/msqueue.h>
   7 #include <vector>
   8
   9 #define NDEBUG          // disable assert()
  10 #include <assert.h>
  11 #include <atomic>
  12
  13 namespace ci = cds::intrusive;
  14 typedef cds::gc::HP gc_type;
  15
  16 typedef cds_test::intrusive_msqueue base_class;
  17 typedef typename base_class::base_hook_item< ci::msqueue::node<gc_type>> base_item_type;
  18 typedef typename base_class::member_hook_item< ci::msqueue::node<gc_type>> member_item_type;
  19
  20 typedef cds_test::intrusive_msqueue::mock_disposer mock_disposer;
  21
  22 std::atomic_int x;
  23
  24 template <typename Queue, typename Data>
  25 void test_enqueue( Queue& q, Data& arr )
  26 {
  27     typedef typename Queue::value_type value_type;
  28     size_t nSize = arr.size();
  29
  30     value_type * pv;
  31 //    for ( size_t i = 0; i < nSize; ++i )
  32 //      arr[i].nVal = static_cast<int>(i);
  33
  34     base_item_type test;
  35     test.nVal = static_cast<int>(4);
  36 //    arr[0].nVal = static_cast<int>(5);
  37     x.load();
  38     q.enqueue( test );
  39 /*
  40     assert(q.empty());
  41     assert(q.size() == 0);
  42
  43     // pop from empty queue
  44 //    pv = q.pop();
  45     assert( pv == nullptr );
  46     assert( q.empty());
  47     assert(q.size() == 0);
  48
  49 //    pv = q.dequeue();
  50     assert( pv == nullptr );
  51     assert( q.empty());
  52     assert(q.size() == 0);
  53 */
  54 /*
  55     for ( size_t i = 0; i < nSize; ++i ) {
  56         if ( i & 1 )
  57             q.push( arr[i] );
  58         else
  59             q.enqueue( arr[i] );
  60         assert( !q.empty());
  61         assert(q.size() == i+1);
  62     }
  63 */
  64 }
  65
  66
  67 template <typename Queue, typename Data>
  68 void test_dequeue( Queue& q, Data& arr )
  69 {
  70     typedef typename Queue::value_type value_type;
  71     size_t nSize = arr.size();
  72
  73     value_type * pv;
  74
  75     for ( size_t i = 0; i < nSize; ++i ) {
  76         assert( !q.empty());
  77         assert( q.size() == nSize - i );
  78         if ( i & 1 )
  79             pv = q.pop();
  80         else
  81             pv = q.dequeue();
  82         assert( pv != nullptr );
  83         assert( pv->nVal == i);
  84     }
  85     assert( q.empty());
  86     assert( q.size() == 0 );
  87
  88 /*
  89     Queue::gc::scan();
  90     --nSize; // last element of array is in queue yet as a dummy item
  91     for ( size_t i = 0; i < nSize; ++i ) {
  92         assert( arr[i].nDisposeCount == 1 );
  93     }
  94     assert( arr[nSize].nDisposeCount == 0 );
  95
  96     // clear test
  97     for ( size_t i = 0; i < nSize; ++i )
  98         q.push( arr[i] );
  99
 100     assert( !q.empty());
 101     assert( q.size() == nSize );
 102
 103     q.clear();
 104     assert( q.empty());
 105     assert( q.size() == 0 );
 106
 107     Queue::gc::scan();
 108     for ( size_t i = 0; i < nSize - 1; ++i ) {
 109         printf("nDisCount (2): %d, (i) %lu\n",  arr[i].nDisposeCount, i );
 110     }
 111     printf("nDisCount: (1) %d\n",  arr[nSize - 1].nDisposeCount ); // this element is in the queue yet
 112     assert( arr[nSize].nDisposeCount == 1 );
 113 */
 114
 115 }
 116
 117 int main () {
 118         cds::Initialize();
 119
 120         {
 121                 typedef ci::MSQueue< gc_type, base_item_type > queue_type;
 122                 cds::gc::hp::GarbageCollector::Construct( queue_type::c_nHazardPtrCount, 1, 16 );
 123                 cds::threading::Manager::attachThread();
 124
 125                 {
 126                         typedef cds::intrusive::MSQueue< gc_type, base_item_type,
 127                             typename ci::msqueue::make_traits<
 128                                 ci::opt::disposer< mock_disposer >
 129                                 , cds::opt::item_counter< cds::atomicity::item_counter >
 130                                 , ci::opt::hook< ci::msqueue::base_hook< ci::opt::gc<gc_type>>>
 131                             >::type
 132                         > test_queue;
 133
 134                         std::vector<base_item_type> arr;
 135                         arr.resize(5);
 136                         printf("test start\n");
 137
 138                         atomic_store_explicit(&x, 0xaaa, std::memory_order_seq_cst);
 139                         test_queue q;
 140                         test_enqueue(q, arr);
 141                         atomic_store_explicit(&x, 0xccc, std::memory_order_seq_cst);
 142 //                      test_dequeue(q, arr);
 143                         atomic_store_explicit(&x, 0xbbb, std::memory_order_seq_cst);
 144
 145                         printf("test end\n");
 146
 147 //                      gc_type::scan();
 148 //                      check_array( arr );
 149
 150                 }
 151
 152         }
 153
 154         cds::Terminate();
 155 }