libs/pbd/pbd/ringbufferNPT.h

   1 /*
   2     Copyright (C) 2000 Paul Davis & Benno Senoner
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef ringbuffer_npt_h
  21 #define ringbuffer_npt_h
  22
  23 //#include <sys/mman.h>
  24
  25 #include <glib.h>
  26
  27 /* ringbuffer class where the element size is not required to be a power of two */
  28
  29 template<class T>
  30 class RingBufferNPT
  31 {
  32   public:
  33         RingBufferNPT (size_t sz) {
  34                 size = sz;
  35                 buf = new T[size];
  36                 reset ();
  37         }
  38
  39         virtual ~RingBufferNPT () {
  40                 delete [] buf;
  41         }
  42
  43         void reset () {
  44                 /* !!! NOT THREAD SAFE !!! */
  45                 g_atomic_int_set (&write_ptr, 0);
  46                 g_atomic_int_set (&read_ptr, 0);
  47         }
  48
  49         void set (size_t r, size_t w) {
  50                 /* !!! NOT THREAD SAFE !!! */
  51                 g_atomic_int_set (&write_ptr, w);
  52                 g_atomic_int_set (&read_ptr, r);
  53         }
  54
  55         size_t  read  (T *dest, size_t cnt);
  56         size_t  write (T *src, size_t cnt);
  57
  58         struct rw_vector {
  59             T *buf[2];
  60             size_t len[2];
  61         };
  62
  63         void get_read_vector (rw_vector *);
  64         void get_write_vector (rw_vector *);
  65
  66         void decrement_read_ptr (size_t cnt) {
  67                 g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) - cnt) % size);
  68         }
  69
  70         void increment_read_ptr (size_t cnt) {
  71                 g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) + cnt) % size);
  72         }
  73
  74         void increment_write_ptr (size_t cnt) {
  75                 g_atomic_int_set (&write_ptr,  (g_atomic_int_get(&write_ptr) + cnt) % size);
  76         }
  77
  78         size_t write_space () {
  79                 size_t w, r;
  80
  81                 w = g_atomic_int_get (&write_ptr);
  82                 r = g_atomic_int_get (&read_ptr);
  83
  84                 if (w > r) {
  85                         return ((r - w + size) % size) - 1;
  86                 } else if (w < r) {
  87                         return (r - w) - 1;
  88                 } else {
  89                         return size - 1;
  90                 }
  91         }
  92
  93         size_t read_space () {
  94                 size_t w, r;
  95
  96                 w = g_atomic_int_get (&write_ptr);
  97                 r = g_atomic_int_get (&read_ptr);
  98
  99                 if (w > r) {
 100                         return w - r;
 101                 } else {
 102                         return (w - r + size) % size;
 103                 }
 104         }
 105
 106         T *buffer () { return buf; }
 107         size_t get_write_ptr () const { return g_atomic_int_get (&write_ptr); }
 108         size_t get_read_ptr () const { return g_atomic_int_get (&read_ptr); }
 109         size_t bufsize () const { return size; }
 110
 111   protected:
 112         T *buf;
 113         size_t size;
 114         mutable gint write_ptr;
 115         mutable gint read_ptr;
 116 };
 117
 118 template<class T> size_t
 119 RingBufferNPT<T>::read (T *dest, size_t cnt)
 120 {
 121         size_t free_cnt;
 122         size_t cnt2;
 123         size_t to_read;
 124         size_t n1, n2;
 125         size_t priv_read_ptr;
 126
 127         priv_read_ptr=g_atomic_int_get(&read_ptr);
 128
 129         if ((free_cnt = read_space ()) == 0) {
 130                 return 0;
 131         }
 132
 133         to_read = cnt > free_cnt ? free_cnt : cnt;
 134
 135         cnt2 = priv_read_ptr + to_read;
 136
 137         if (cnt2 > size) {
 138                 n1 = size - priv_read_ptr;
 139                 n2 = cnt2 % size;
 140         } else {
 141                 n1 = to_read;
 142                 n2 = 0;
 143         }
 144
 145         memcpy (dest, &buf[priv_read_ptr], n1 * sizeof (T));
 146         priv_read_ptr = (priv_read_ptr + n1) % size;
 147
 148         if (n2) {
 149                 memcpy (dest+n1, buf, n2 * sizeof (T));
 150                 priv_read_ptr = n2;
 151         }
 152
 153         g_atomic_int_set(&read_ptr, priv_read_ptr);
 154         return to_read;
 155 }
 156
 157 template<class T> size_t
 158 RingBufferNPT<T>::write (T *src, size_t cnt)
 159 {
 160         size_t free_cnt;
 161         size_t cnt2;
 162         size_t to_write;
 163         size_t n1, n2;
 164         size_t priv_write_ptr;
 165
 166         priv_write_ptr=g_atomic_int_get(&write_ptr);
 167
 168         if ((free_cnt = write_space ()) == 0) {
 169                 return 0;
 170         }
 171
 172         to_write = cnt > free_cnt ? free_cnt : cnt;
 173
 174         cnt2 = priv_write_ptr + to_write;
 175
 176         if (cnt2 > size) {
 177                 n1 = size - priv_write_ptr;
 178                 n2 = cnt2 % size;
 179         } else {
 180                 n1 = to_write;
 181                 n2 = 0;
 182         }
 183
 184         memcpy (&buf[priv_write_ptr], src, n1 * sizeof (T));
 185         priv_write_ptr = (priv_write_ptr + n1) % size;
 186
 187         if (n2) {
 188                 memcpy (buf, src+n1, n2 * sizeof (T));
 189                 priv_write_ptr = n2;
 190         }
 191
 192         g_atomic_int_set(&write_ptr, priv_write_ptr);
 193         return to_write;
 194 }
 195
 196 template<class T> void
 197 RingBufferNPT<T>::get_read_vector (RingBufferNPT<T>::rw_vector *vec)
 198 {
 199         size_t free_cnt;
 200         size_t cnt2;
 201         size_t w, r;
 202
 203         w = g_atomic_int_get (&write_ptr);
 204         r = g_atomic_int_get (&read_ptr);
 205
 206         if (w > r) {
 207                 free_cnt = w - r;
 208         } else {
 209                 free_cnt = (w - r + size) % size;
 210         }
 211
 212         cnt2 = r + free_cnt;
 213
 214         if (cnt2 > size) {
 215                 /* Two part vector: the rest of the buffer after the
 216                    current write ptr, plus some from the start of
 217                    the buffer.
 218                 */
 219
 220                 vec->buf[0] = &buf[r];
 221                 vec->len[0] = size - r;
 222                 vec->buf[1] = buf;
 223                 vec->len[1] = cnt2 % size;
 224
 225         } else {
 226
 227                 /* Single part vector: just the rest of the buffer */
 228
 229                 vec->buf[0] = &buf[r];
 230                 vec->len[0] = free_cnt;
 231                 vec->len[1] = 0;
 232         }
 233 }
 234
 235 template<class T> void
 236 RingBufferNPT<T>::get_write_vector (RingBufferNPT<T>::rw_vector *vec)
 237 {
 238         size_t free_cnt;
 239         size_t cnt2;
 240         size_t w, r;
 241
 242         w = g_atomic_int_get (&write_ptr);
 243         r = g_atomic_int_get (&read_ptr);
 244
 245         if (w > r) {
 246                 free_cnt = ((r - w + size) % size) - 1;
 247         } else if (w < r) {
 248                 free_cnt = (r - w) - 1;
 249         } else {
 250                 free_cnt = size - 1;
 251         }
 252
 253         cnt2 = w + free_cnt;
 254
 255         if (cnt2 > size) {
 256
 257                 /* Two part vector: the rest of the buffer after the
 258                    current write ptr, plus some from the start of
 259                    the buffer.
 260                 */
 261
 262                 vec->buf[0] = &buf[w];
 263                 vec->len[0] = size - w;
 264                 vec->buf[1] = buf;
 265                 vec->len[1] = cnt2 % size;
 266         } else {
 267                 vec->buf[0] = &buf[w];
 268                 vec->len[0] = free_cnt;
 269                 vec->len[1] = 0;
 270         }
 271 }
 272
 273 #endif /* __ringbuffer_npt_h__ */