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
  40         virtual ~RingBufferNPT() {
  41                 delete [] buf;
  42         }
  43
  44         void reset () {
  45                 /* !!! NOT THREAD SAFE !!! */
  46                 g_atomic_int_set (&write_ptr, 0);
  47                 g_atomic_int_set (&read_ptr, 0);
  48         }
  49
  50         void set (size_t r, size_t w) {
  51                 /* !!! NOT THREAD SAFE !!! */
  52                 g_atomic_int_set (&write_ptr, w);
  53                 g_atomic_int_set (&read_ptr, r);
  54         }
  55
  56         size_t  read  (T *dest, size_t cnt);
  57         size_t  write (T *src, size_t cnt);
  58
  59         struct rw_vector {
  60             T *buf[2];
  61             size_t len[2];
  62         };
  63
  64         void get_read_vector (rw_vector *);
  65         void get_write_vector (rw_vector *);
  66
  67         void decrement_read_ptr (size_t cnt) {
  68                 g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) - cnt) % size);
  69         }
  70
  71         void increment_read_ptr (size_t cnt) {
  72                 g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) + cnt) % size);
  73         }
  74
  75         void increment_write_ptr (size_t cnt) {
  76                 g_atomic_int_set (&write_ptr,  (g_atomic_int_get(&write_ptr) + cnt) % size);
  77         }
  78
  79         size_t write_space () {
  80                 size_t w, r;
  81
  82                 w = g_atomic_int_get (&write_ptr);
  83                 r = g_atomic_int_get (&read_ptr);
  84
  85                 if (w > r) {
  86                         return ((r - w + size) % size) - 1;
  87                 } else if (w < r) {
  88                         return (r - w) - 1;
  89                 } else {
  90                         return size - 1;
  91                 }
  92         }
  93
  94         size_t read_space () {
  95                 size_t w, r;
  96
  97                 w = g_atomic_int_get (&write_ptr);
  98                 r = g_atomic_int_get (&read_ptr);
  99
 100                 if (w > r) {
 101                         return w - r;
 102                 } else {
 103                         return (w - r + size) % size;
 104                 }
 105         }
 106
 107         T *buffer () { return buf; }
 108         size_t get_write_ptr () const { return g_atomic_int_get (&write_ptr); }
 109         size_t get_read_ptr () const { return g_atomic_int_get (&read_ptr); }
 110         size_t bufsize () const { return size; }
 111
 112   protected:
 113         T *buf;
 114         size_t size;
 115         mutable gint write_ptr;
 116         mutable gint read_ptr;
 117 };
 118
 119 template<class T> size_t
 120 RingBufferNPT<T>::read (T *dest, size_t cnt)
 121 {
 122         size_t free_cnt;
 123         size_t cnt2;
 124         size_t to_read;
 125         size_t n1, n2;
 126         size_t priv_read_ptr;
 127
 128         priv_read_ptr=g_atomic_int_get(&read_ptr);
 129
 130         if ((free_cnt = read_space ()) == 0) {
 131                 return 0;
 132         }
 133
 134         to_read = cnt > free_cnt ? free_cnt : cnt;
 135
 136         cnt2 = priv_read_ptr + to_read;
 137
 138         if (cnt2 > size) {
 139                 n1 = size - priv_read_ptr;
 140                 n2 = cnt2 % size;
 141         } else {
 142                 n1 = to_read;
 143                 n2 = 0;
 144         }
 145
 146         memcpy (dest, &buf[priv_read_ptr], n1 * sizeof (T));
 147         priv_read_ptr = (priv_read_ptr + n1) % size;
 148
 149         if (n2) {
 150                 memcpy (dest+n1, buf, n2 * sizeof (T));
 151                 priv_read_ptr = n2;
 152         }
 153
 154         g_atomic_int_set(&read_ptr, priv_read_ptr);
 155         return to_read;
 156 }
 157
 158 template<class T> size_t
 159 RingBufferNPT<T>::write (T *src, size_t cnt)
 160 {
 161         size_t free_cnt;
 162         size_t cnt2;
 163         size_t to_write;
 164         size_t n1, n2;
 165         size_t priv_write_ptr;
 166
 167         priv_write_ptr=g_atomic_int_get(&write_ptr);
 168
 169         if ((free_cnt = write_space ()) == 0) {
 170                 return 0;
 171         }
 172
 173         to_write = cnt > free_cnt ? free_cnt : cnt;
 174
 175         cnt2 = priv_write_ptr + to_write;
 176
 177         if (cnt2 > size) {
 178                 n1 = size - priv_write_ptr;
 179                 n2 = cnt2 % size;
 180         } else {
 181                 n1 = to_write;
 182                 n2 = 0;
 183         }
 184
 185         memcpy (&buf[priv_write_ptr], src, n1 * sizeof (T));
 186         priv_write_ptr = (priv_write_ptr + n1) % size;
 187
 188         if (n2) {
 189                 memcpy (buf, src+n1, n2 * sizeof (T));
 190                 priv_write_ptr = n2;
 191         }
 192
 193         g_atomic_int_set(&write_ptr, priv_write_ptr);
 194         return to_write;
 195 }
 196
 197 template<class T> void
 198 RingBufferNPT<T>::get_read_vector (RingBufferNPT<T>::rw_vector *vec)
 199 {
 200         size_t free_cnt;
 201         size_t cnt2;
 202         size_t w, r;
 203
 204         w = g_atomic_int_get (&write_ptr);
 205         r = g_atomic_int_get (&read_ptr);
 206
 207         if (w > r) {
 208                 free_cnt = w - r;
 209         } else {
 210                 free_cnt = (w - r + size) % size;
 211         }
 212
 213         cnt2 = r + free_cnt;
 214
 215         if (cnt2 > size) {
 216                 /* Two part vector: the rest of the buffer after the
 217                    current write ptr, plus some from the start of
 218                    the buffer.
 219                 */
 220
 221                 vec->buf[0] = &buf[r];
 222                 vec->len[0] = size - r;
 223                 vec->buf[1] = buf;
 224                 vec->len[1] = cnt2 % size;
 225
 226         } else {
 227
 228                 /* Single part vector: just the rest of the buffer */
 229
 230                 vec->buf[0] = &buf[r];
 231                 vec->len[0] = free_cnt;
 232                 vec->len[1] = 0;
 233         }
 234 }
 235
 236 template<class T> void
 237 RingBufferNPT<T>::get_write_vector (RingBufferNPT<T>::rw_vector *vec)
 238 {
 239         size_t free_cnt;
 240         size_t cnt2;
 241         size_t w, r;
 242
 243         w = g_atomic_int_get (&write_ptr);
 244         r = g_atomic_int_get (&read_ptr);
 245
 246         if (w > r) {
 247                 free_cnt = ((r - w + size) % size) - 1;
 248         } else if (w < r) {
 249                 free_cnt = (r - w) - 1;
 250         } else {
 251                 free_cnt = size - 1;
 252         }
 253
 254         cnt2 = w + free_cnt;
 255
 256         if (cnt2 > size) {
 257
 258                 /* Two part vector: the rest of the buffer after the
 259                    current write ptr, plus some from the start of
 260                    the buffer.
 261                 */
 262
 263                 vec->buf[0] = &buf[w];
 264                 vec->len[0] = size - w;
 265                 vec->buf[1] = buf;
 266                 vec->len[1] = cnt2 % size;
 267         } else {
 268                 vec->buf[0] = &buf[w];
 269                 vec->len[0] = free_cnt;
 270                 vec->len[1] = 0;
 271         }
 272 }
 273
 274 #endif /* __ringbuffer_npt_h__ */