libs/lockfree/test/test_helpers.hpp

   1 #include <set>
   2 #include <boost/array.hpp>
   3 #include <boost/lockfree/detail/atomic.hpp>
   4 #include <boost/thread.hpp>
   5
   6 template <typename int_type>
   7 int_type generate_id(void)
   8 {
   9     static boost::lockfree::detail::atomic<int_type> generator(0);
  10     return ++generator;
  11 }
  12
  13 template <typename int_type, unsigned int buckets>
  14 class static_hashed_set
  15 {
  16 public:
  17     bool insert(int_type const & id)
  18     {
  19         std::size_t index = id % buckets;
  20
  21         boost::mutex::scoped_lock lock (ref_mutex[index]);
  22
  23         std::pair<typename std::set<int_type>::iterator, bool> p;
  24         p = data[index].insert(id);
  25
  26         return p.second;
  27     }
  28
  29     bool find (int_type const & id)
  30     {
  31         std::size_t index = id % buckets;
  32
  33         boost::mutex::scoped_lock lock (ref_mutex[index]);
  34
  35         return data[index].find(id) != data[index].end();
  36     }
  37
  38     bool erase(int_type const & id)
  39     {
  40         std::size_t index = id % buckets;
  41
  42         boost::mutex::scoped_lock lock (ref_mutex[index]);
  43
  44         if (data[index].find(id) != data[index].end())
  45         {
  46             data[index].erase(id);
  47             assert(data[index].find(id) == data[index].end());
  48             return true;
  49         }
  50         else
  51             return false;
  52     }
  53
  54     int count_nodes(void) const
  55     {
  56         int ret = 0;
  57         for (int i = 0; i != buckets; ++i)
  58         {
  59             boost::mutex::scoped_lock lock (ref_mutex[i]);
  60             ret += data[i].size();
  61         }
  62         return ret;
  63     }
  64
  65 private:
  66     boost::array<std::set<int_type>, buckets> data;
  67     mutable boost::array<boost::mutex, buckets> ref_mutex;
  68 };