testsuite/supernova/server_dsp_thread_test.cpp

   1 #include <boost/test/unit_test.hpp>
   2
   3 #include <vector>
   4
   5 #include "dsp_thread_queue/dsp_thread.hpp"
   6 #include "server/memory_pool.hpp"
   7
   8 namespace
   9 {
  10
  11 volatile int gint;
  12
  13 struct dummy_runnable
  14 {
  15     dummy_runnable(void):
  16         i(0)
  17     {}
  18
  19     void operator()(uint dummy)
  20     {
  21         ++i;
  22
  23         for (int j = 0; j != 1000; ++j)
  24         {
  25             int l = gint;
  26             l += 1;
  27             gint = l;
  28         }
  29     }
  30
  31     int i;
  32 };
  33
  34 dummy_runnable dummy;
  35 }
  36
  37 template <typename Alloc>
  38 void run_test_1(void)
  39 {
  40     nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> t(1);
  41 }
  42
  43 BOOST_AUTO_TEST_CASE( dsp_thread_test_1 )
  44 {
  45     nova::rt_pool.init(1024*1024*128);
  46     run_test_1<std::allocator<void*> >();
  47     run_test_1<nova::rt_pool_allocator<void*> >();
  48 }
  49
  50 template <typename Alloc>
  51 void run_test_2(void)
  52 {
  53     nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> t(5);
  54     t.start_threads();
  55     t.terminate_threads();
  56 }
  57
  58
  59 BOOST_AUTO_TEST_CASE( dsp_thread_test_2 )
  60 {
  61     run_test_2<std::allocator<void*> >();
  62     run_test_2<nova::rt_pool_allocator<void*> >();
  63 }
  64
  65 template <typename Alloc>
  66 void run_test_3(void)
  67 {
  68     nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> t(2);
  69     t.start_threads();
  70     t.run();
  71     t.terminate_threads();
  72 }
  73
  74 BOOST_AUTO_TEST_CASE( dsp_thread_test_3 )
  75 {
  76     run_test_3<std::allocator<void*> >();
  77     run_test_3<nova::rt_pool_allocator<void*> >();
  78 }
  79
  80 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  81 #define auto_ptr unique_ptr
  82 #define MOVE(X) std::move(X)
  83 #else
  84 #define MOVE(X) X
  85 #endif
  86
  87 template <typename Alloc>
  88 void run_test_4(void)
  89 {
  90     typedef typename nova::dsp_thread_queue_item<dummy_runnable, Alloc> dsp_thread_queue_item;
  91     typedef typename nova::dsp_thread_queue<dummy_runnable, Alloc> dsp_thread_queue;
  92
  93     typedef typename nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> dsp_threads;
  94     typedef std::auto_ptr<dsp_thread_queue> dsp_thread_queue_ptr;
  95
  96     dsp_threads t(1);
  97     t.start_threads();
  98
  99     dsp_thread_queue_ptr q (new dsp_thread_queue(2));
 100
 101     dsp_thread_queue_item * item1 = q->allocate_queue_item(dummy, typename dsp_thread_queue_item::successor_list(), 1);
 102
 103     typename dsp_thread_queue_item::successor_list sl(1);
 104     sl[0] = item1;
 105
 106     dsp_thread_queue_item * item2 = q->allocate_queue_item(dummy, sl, 0);
 107     q->add_initially_runnable(item2);
 108
 109     t.reset_queue(MOVE(q));
 110
 111     t.run();
 112
 113     t.terminate_threads();
 114
 115     BOOST_REQUIRE_EQUAL(item1->get_job().i, 1);
 116     BOOST_REQUIRE_EQUAL(item2->get_job().i, 1);
 117
 118 }
 119
 120
 121 BOOST_AUTO_TEST_CASE( dsp_thread_test_4 )
 122 {
 123     run_test_4<std::allocator<void*> >();
 124     run_test_4<nova::rt_pool_allocator<void*> >();
 125 }
 126
 127 template <typename Alloc>
 128 void run_test_5(void)
 129 {
 130     typedef nova::dsp_thread_queue_item<dummy_runnable, Alloc> dsp_thread_queue_item;
 131     typedef nova::dsp_thread_queue<dummy_runnable, Alloc> dsp_thread_queue;
 132     typedef nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> dsp_threads;
 133
 134     typedef std::auto_ptr<dsp_thread_queue> dsp_thread_queue_ptr;
 135
 136     dsp_threads t(2);
 137     t.start_threads();
 138
 139     dsp_thread_queue_ptr q (new dsp_thread_queue(5));
 140
 141     dsp_thread_queue_item * item1 = q->allocate_queue_item(dummy, typename dsp_thread_queue_item::successor_list(), 4);
 142
 143     typename dsp_thread_queue_item::successor_list sl(1);
 144     sl[0] = item1;
 145
 146     dsp_thread_queue_item * item2 = q->allocate_queue_item(dummy, sl, 0);
 147     q->add_initially_runnable(item2);
 148
 149     dsp_thread_queue_item * item3 = q->allocate_queue_item(dummy, sl, 0);
 150     q->add_initially_runnable(item3);
 151
 152     dsp_thread_queue_item * item4 = q->allocate_queue_item(dummy, sl, 0);
 153     q->add_initially_runnable(item4);
 154
 155     dsp_thread_queue_item * item5 = q->allocate_queue_item(dummy, sl, 0);
 156     q->add_initially_runnable(item5);
 157
 158     t.reset_queue(MOVE(q));
 159
 160     t.run();
 161
 162     t.terminate_threads();
 163
 164     BOOST_REQUIRE_EQUAL(item1->get_job().i, 1);
 165     BOOST_REQUIRE_EQUAL(item2->get_job().i, 1);
 166     BOOST_REQUIRE_EQUAL(item3->get_job().i, 1);
 167     BOOST_REQUIRE_EQUAL(item4->get_job().i, 1);
 168     BOOST_REQUIRE_EQUAL(item5->get_job().i, 1);
 169 }
 170
 171
 172
 173 BOOST_AUTO_TEST_CASE( dsp_thread_test_5 )
 174 {
 175     run_test_5<std::allocator<void*> >();
 176     run_test_5<nova::rt_pool_allocator<void*> >();
 177 }
 178
 179 template <typename Alloc>
 180 void run_test_6(void)
 181 {
 182     typedef nova::dsp_thread_queue_item<dummy_runnable, Alloc> dsp_thread_queue_item;
 183     typedef nova::dsp_thread_queue<dummy_runnable, Alloc> dsp_thread_queue;
 184     typedef nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> dsp_threads;
 185
 186     typedef std::auto_ptr<dsp_thread_queue> dsp_thread_queue_ptr;
 187
 188     dsp_threads t(2);
 189     t.start_threads();
 190
 191     dsp_thread_queue_ptr q (new dsp_thread_queue(20));
 192
 193     std::vector<dsp_thread_queue_item*> items;
 194
 195     for (int i = 0; i != 20; ++i)
 196     {
 197         items.push_back(q->allocate_queue_item(dummy, typename dsp_thread_queue_item::successor_list(), 0));
 198         q->add_initially_runnable(items.back());
 199     }
 200
 201     t.reset_queue(MOVE(q));
 202
 203     const int iterations = 10000;
 204
 205     for (int i = 0; i != iterations; ++i)
 206     {
 207         for (int item = 0; item != 20; ++item)
 208             BOOST_REQUIRE_EQUAL(items[item]->get_job().i, i);
 209         t.run();
 210     }
 211
 212     t.terminate_threads();
 213
 214     for (int i = 0; i != 20; ++i)
 215         BOOST_REQUIRE_EQUAL(items[i]->get_job().i, iterations);
 216 }
 217
 218 BOOST_AUTO_TEST_CASE( dsp_thread_test_6 )
 219 {
 220     run_test_6<std::allocator<void*> >();
 221     run_test_6<nova::rt_pool_allocator<void*> >();
 222 }