l7vsd/include/atomic.h

   1 #ifndef ATOMIC_H
   2 #define ATOMIC_H
   3 #include <boost/utility.hpp>
   4 #include "wrlock.h"
   5
   6 namespace l7vs
   7 {
   8
   9 template<class T> class atomic : boost::noncopyable
  10 {
  11 protected:
  12         mutable volatile T p;
  13         wr_mutex     mutex;
  14 public:
  15         explicit atomic() : p(0) {}
  16
  17         T get() {
  18                 rd_scoped_lock lock(mutex);
  19                 return p;
  20         }
  21         atomic &operator=(const T &q) {
  22                 rw_scoped_lock lock(mutex);
  23                 p = q;
  24                 return *this;
  25         }
  26         atomic &operator++(const int) {
  27                 rw_scoped_lock lock(mutex);
  28                 p++;
  29                 return *this;
  30         }
  31         atomic &operator--(const int) {
  32                 rw_scoped_lock lock(mutex);
  33                 p--;
  34                 return *this;
  35         }
  36         atomic &operator+=(const T &q) {
  37                 rw_scoped_lock lock(mutex);
  38                 p += q;
  39                 return *this;
  40         }
  41         atomic &operator-=(const T &q) {
  42                 rw_scoped_lock lock(mutex);
  43                 p -= q;
  44                 return *this;
  45         }
  46         bool operator<(T &q) const {
  47                 return p < q;
  48         }
  49         bool operator<=(T &q) const {
  50                 return p <= q;
  51         }
  52         bool operator>(T &q) const {
  53                 return p > q;
  54         }
  55         bool operator>=(T &q) const {
  56                 return p >= q;
  57         }
  58         bool operator==(T &q) const {
  59                 return p == q;
  60         }
  61         bool operator!=(T &q) const {
  62                 return p != q;
  63         }
  64 };
  65
  66
  67 //int
  68 template <>
  69 class atomic<int>
  70 {
  71 protected:
  72         mutable volatile int p;
  73 public:
  74         int get() {
  75                 return p;
  76         }
  77         atomic &operator=(const int &q) {
  78                 __sync_lock_test_and_set(&p, q);
  79                 return *this;
  80         }
  81         atomic &operator++(const int) {
  82                 __sync_add_and_fetch(&p, 1);
  83                 return *this;
  84         }
  85         atomic &operator--(const int) {
  86                 __sync_sub_and_fetch(&p, 1);
  87                 return *this;
  88         }
  89         atomic &operator+=(const int &q) {
  90                 __sync_add_and_fetch(&p, q);
  91                 return *this;
  92         }
  93         atomic &operator-=(const int &q) {
  94                 __sync_sub_and_fetch(&p, q);
  95                 return *this;
  96         }
  97         bool operator<(const int &q) const {
  98                 return p < q;
  99         }
 100         bool operator<=(const int &q) const {
 101                 return p <= q;
 102         }
 103         bool operator>(const int &q) const {
 104                 return p > q;
 105         }
 106         bool operator>=(const int &q) const {
 107                 return p >= q;
 108         }
 109         bool operator==(const int &q) const {
 110                 return p == q;
 111         }
 112         bool operator!=(const int &q) const {
 113                 return p != q;
 114         }
 115 };
 116
 117
 118 //longlong
 119 template <>
 120 class atomic<long long>
 121 {
 122 protected:
 123         mutable volatile long long p;
 124 public:
 125         long long get() {
 126                 return p;
 127         }
 128         atomic &operator=(const long long &q) {
 129                 __sync_lock_test_and_set(&p, q);
 130                 return *this;
 131         }
 132         atomic &operator++(const int) {
 133                 __sync_add_and_fetch(&p, 1);
 134                 return *this;
 135         }
 136         atomic &operator--(const int) {
 137                 __sync_sub_and_fetch(&p, 1);
 138                 return *this;
 139         }
 140         atomic &operator+=(const long long &q) {
 141                 __sync_add_and_fetch(&p, q);
 142                 return *this;
 143         }
 144         atomic &operator-=(const long long &q) {
 145                 __sync_sub_and_fetch(&p, q);
 146                 return *this;
 147         }
 148         bool operator<(const long long &q) const {
 149                 return p < q;
 150         }
 151         bool operator<=(const long long &q) const {
 152                 return p <= q;
 153         }
 154         bool operator>(const long long &q) const {
 155                 return p > q;
 156         }
 157         bool operator>=(const long long &q) const {
 158                 return p >= q;
 159         }
 160         bool operator==(const long long &q) const {
 161                 return p == q;
 162         }
 163         bool operator!=(const long long &q) const {
 164                 return p != q;
 165         }
 166 };
 167
 168 //unsigned longlong
 169 template <>
 170 class atomic<unsigned long long>
 171 {
 172 protected:
 173         mutable volatile unsigned long long  p;
 174 public:
 175         unsigned long long get() {
 176                 return p;
 177         }
 178         atomic &operator=(const unsigned long long &q) {
 179                 __sync_lock_test_and_set(&p, q);
 180                 return *this;
 181         }
 182         atomic &operator++(const int) {
 183                 __sync_add_and_fetch(&p, 1);
 184                 return *this;
 185         }
 186         atomic &operator--(const int) {
 187                 __sync_sub_and_fetch(&p, 1);
 188                 return *this;
 189         }
 190         atomic &operator+=(const unsigned long long &q) {
 191                 __sync_add_and_fetch(&p, q);
 192                 return *this;
 193         }
 194         atomic &operator-=(const unsigned long long &q) {
 195                 __sync_sub_and_fetch(&p, q);
 196                 return *this;
 197         }
 198         bool operator<(const unsigned long long &q) const {
 199                 return p < q;
 200         }
 201         bool operator<=(const unsigned long long &q) const {
 202                 return p <= q;
 203         }
 204         bool operator>(const unsigned long long &q) const {
 205                 return p > q;
 206         }
 207         bool operator>=(const unsigned long long &q) const {
 208                 return p >= q;
 209         }
 210         bool operator==(const unsigned long long &q) const {
 211                 return p == q;
 212         }
 213         bool operator!=(const unsigned long long &q) const {
 214                 return p != q;
 215         }
 216 };
 217
 218 } //namespace l7vsd
 219 #endif