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