libs/lockfree/test/stack_test.cpp

   1 #include <climits>
   2 #define BOOST_TEST_DYN_LINK
   3 #define BOOST_TEST_MAIN
   4 #include <boost/test/unit_test.hpp>
   5
   6 #include "test_helpers.hpp"
   7
   8 #include <boost/lockfree/stack.hpp>
   9
  10 #include <boost/thread.hpp>
  11 #include <iostream>
  12
  13
  14 BOOST_AUTO_TEST_CASE( simple_stack_test )
  15 {
  16     boost::lockfree::stack<long> stk;
  17
  18     stk.push(1);
  19     stk.push(2);
  20     long out;
  21     BOOST_REQUIRE(stk.pop(out)); BOOST_REQUIRE_EQUAL(out, 2);
  22     BOOST_REQUIRE(stk.pop(out)); BOOST_REQUIRE_EQUAL(out, 1);
  23     BOOST_REQUIRE(!stk.pop(out));
  24
  25     stk.push_unsafe(1);
  26     stk.push_unsafe(2);
  27     BOOST_REQUIRE(stk.pop_unsafe(out)); BOOST_REQUIRE_EQUAL(out, 2);
  28     BOOST_REQUIRE(stk.pop_unsafe(out)); BOOST_REQUIRE_EQUAL(out, 1);
  29     BOOST_REQUIRE(!stk.pop_unsafe(out));
  30 }
  31
  32
  33 using namespace boost;
  34 using namespace std;
  35
  36 template <typename freelist_t>
  37 struct stack_tester
  38 {
  39     static const unsigned int buckets = 1<<10;
  40     static const long node_count = 200000;
  41     static const int reader_threads = 4;
  42     static const int writer_threads = 4;
  43
  44     static_hashed_set<long, buckets> data;
  45     boost::array<std::set<long>, buckets> returned;
  46
  47     boost::lockfree::detail::atomic<int> push_count, pop_count;
  48
  49     boost::lockfree::stack<long, freelist_t> stk;
  50
  51     stack_tester(void):
  52         push_count(0), pop_count(0)
  53     {
  54         stk.reserve(128);
  55     }
  56
  57     void add_items(void)
  58     {
  59         for (long i = 0; i != node_count; ++i)
  60         {
  61             long id = generate_id<long>();
  62
  63             bool inserted = data.insert(id);
  64             assert(inserted);
  65
  66             while(stk.push(id) == false)
  67                 thread::yield();
  68             ++push_count;
  69         }
  70     }
  71
  72     boost::atomic<bool> running;
  73
  74     void get_items(void)
  75     {
  76         for (;;)
  77         {
  78             long id;
  79
  80             bool got = stk.pop(id);
  81             if (got)
  82             {
  83                 bool erased = data.erase(id);
  84                 assert(erased);
  85                 ++pop_count;
  86             }
  87             else
  88                 if (not running.load())
  89                     return;
  90         }
  91     }
  92
  93     void run(void)
  94     {
  95         BOOST_WARN(stk.is_lock_free());
  96
  97         running.store(true);
  98
  99         thread_group writer;
 100         thread_group reader;
 101
 102         BOOST_REQUIRE(stk.empty());
 103
 104         for (int i = 0; i != reader_threads; ++i)
 105             reader.create_thread(boost::bind(&stack_tester::get_items, this));
 106
 107         for (int i = 0; i != writer_threads; ++i)
 108             writer.create_thread(boost::bind(&stack_tester::add_items, this));
 109
 110         using namespace std;
 111         cout << "threads created" << endl;
 112
 113         writer.join_all();
 114
 115         cout << "writer threads joined, waiting for readers" << endl;
 116
 117         running = false;
 118         reader.join_all();
 119
 120         cout << "reader threads joined" << endl;
 121
 122         BOOST_REQUIRE_EQUAL(data.count_nodes(), 0);
 123         BOOST_REQUIRE(stk.empty());
 124
 125         BOOST_REQUIRE_EQUAL(push_count, pop_count);
 126         BOOST_REQUIRE_EQUAL(push_count, writer_threads * node_count);
 127     }
 128 };
 129
 130 BOOST_AUTO_TEST_CASE( stack_test_caching )
 131 {
 132     stack_tester<boost::lockfree::caching_freelist_t> tester;
 133     tester.run();
 134 }
 135
 136 BOOST_AUTO_TEST_CASE( stack_test_static )
 137 {
 138     stack_tester<boost::lockfree::static_freelist_t> tester;
 139     tester.run();
 140 }