common/ringbuffer.c

   1 /*
   2   Copyright (C) 2000 Paul Davis
   3   Copyright (C) 2003 Rohan Drape
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU Lesser General Public License as published by
   7   the Free Software Foundation; either version 2.1 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU Lesser General Public License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19   ISO/POSIX C version of Paul Davis's lock free ringbuffer C++ code.
  20   This is safe for the case of one read thread and one write thread.
  21 */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #ifdef USE_MLOCK
  26 #include <sys/mman.h>
  27 #endif /* USE_MLOCK */
  28 #include "JackCompilerDeps.h"
  29
  30 typedef struct {
  31     char *buf;
  32     size_t len;
  33 }
  34 jack_ringbuffer_data_t ;
  35
  36 typedef struct {
  37     char        *buf;
  38     volatile size_t write_ptr;
  39     volatile size_t read_ptr;
  40     size_t      size;
  41     size_t      size_mask;
  42     int mlocked;
  43 }
  44 jack_ringbuffer_t ;
  45
  46 EXPORT jack_ringbuffer_t *jack_ringbuffer_create(size_t sz);
  47 EXPORT void jack_ringbuffer_free(jack_ringbuffer_t *rb);
  48 EXPORT void jack_ringbuffer_get_read_vector(const jack_ringbuffer_t *rb,
  49                                          jack_ringbuffer_data_t *vec);
  50 EXPORT void jack_ringbuffer_get_write_vector(const jack_ringbuffer_t *rb,
  51                                           jack_ringbuffer_data_t *vec);
  52 EXPORT size_t jack_ringbuffer_read(jack_ringbuffer_t *rb, char *dest, size_t cnt);
  53 EXPORT size_t jack_ringbuffer_peek(jack_ringbuffer_t *rb, char *dest, size_t cnt);
  54 EXPORT void jack_ringbuffer_read_advance(jack_ringbuffer_t *rb, size_t cnt);
  55 EXPORT size_t jack_ringbuffer_read_space(const jack_ringbuffer_t *rb);
  56 EXPORT int jack_ringbuffer_mlock(jack_ringbuffer_t *rb);
  57 EXPORT void jack_ringbuffer_reset(jack_ringbuffer_t *rb);
  58 EXPORT void jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz);
  59 EXPORT size_t jack_ringbuffer_write(jack_ringbuffer_t *rb, const char *src,
  60                                  size_t cnt);
  61 void jack_ringbuffer_write_advance(jack_ringbuffer_t *rb, size_t cnt);
  62 size_t jack_ringbuffer_write_space(const jack_ringbuffer_t *rb);
  63
  64 /* Create a new ringbuffer to hold at least `sz' bytes of data. The
  65    actual buffer size is rounded up to the next power of two.  */
  66
  67 EXPORT jack_ringbuffer_t *
  68 jack_ringbuffer_create (size_t sz)
  69 {
  70         int power_of_two;
  71         jack_ringbuffer_t *rb;
  72
  73         if ((rb = (jack_ringbuffer_t *) malloc (sizeof (jack_ringbuffer_t))) == NULL) {
  74                 return NULL;
  75         }
  76
  77         for (power_of_two = 1; 1 << power_of_two < sz; power_of_two++);
  78
  79         rb->size = 1 << power_of_two;
  80         rb->size_mask = rb->size;
  81         rb->size_mask -= 1;
  82         rb->write_ptr = 0;
  83         rb->read_ptr = 0;
  84         if ((rb->buf = (char *) malloc (rb->size)) == NULL) {
  85                 free (rb);
  86                 return NULL;
  87         }
  88         rb->mlocked = 0;
  89
  90         return rb;
  91 }
  92
  93 /* Free all data associated with the ringbuffer `rb'. */
  94
  95 EXPORT void
  96 jack_ringbuffer_free (jack_ringbuffer_t * rb)
  97 {
  98 #ifdef USE_MLOCK
  99         if (rb->mlocked) {
 100                 munlock (rb->buf, rb->size);
 101         }
 102 #endif /* USE_MLOCK */
 103         free (rb->buf);
 104         free (rb);
 105 }
 106
 107 /* Lock the data block of `rb' using the system call 'mlock'.  */
 108
 109 EXPORT int
 110 jack_ringbuffer_mlock (jack_ringbuffer_t * rb)
 111 {
 112 #ifdef USE_MLOCK
 113         if (mlock (rb->buf, rb->size)) {
 114                 return -1;
 115         }
 116 #endif /* USE_MLOCK */
 117         rb->mlocked = 1;
 118         return 0;
 119 }
 120
 121 /* Reset the read and write pointers to zero. This is not thread
 122    safe. */
 123
 124 EXPORT void
 125 jack_ringbuffer_reset (jack_ringbuffer_t * rb)
 126 {
 127         rb->read_ptr = 0;
 128         rb->write_ptr = 0;
 129 }
 130
 131 /* Reset the read and write pointers to zero. This is not thread
 132    safe. */
 133
 134 EXPORT void
 135 jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz)
 136 {
 137     rb->size = sz;
 138     rb->size_mask = rb->size;
 139     rb->size_mask -= 1;
 140     rb->read_ptr = 0;
 141     rb->write_ptr = 0;
 142 }
 143
 144 /* Return the number of bytes available for reading.  This is the
 145    number of bytes in front of the read pointer and behind the write
 146    pointer.  */
 147
 148 EXPORT size_t
 149 jack_ringbuffer_read_space (const jack_ringbuffer_t * rb)
 150 {
 151         size_t w, r;
 152
 153         w = rb->write_ptr;
 154         r = rb->read_ptr;
 155
 156         if (w > r) {
 157                 return w - r;
 158         } else {
 159                 return (w - r + rb->size) & rb->size_mask;
 160         }
 161 }
 162
 163 /* Return the number of bytes available for writing.  This is the
 164    number of bytes in front of the write pointer and behind the read
 165    pointer.  */
 166
 167 EXPORT size_t
 168 jack_ringbuffer_write_space (const jack_ringbuffer_t * rb)
 169 {
 170         size_t w, r;
 171
 172         w = rb->write_ptr;
 173         r = rb->read_ptr;
 174
 175         if (w > r) {
 176                 return ((r - w + rb->size) & rb->size_mask) - 1;
 177         } else if (w < r) {
 178                 return (r - w) - 1;
 179         } else {
 180                 return rb->size - 1;
 181         }
 182 }
 183
 184 /* The copying data reader.  Copy at most `cnt' bytes from `rb' to
 185    `dest'.  Returns the actual number of bytes copied. */
 186
 187 EXPORT size_t
 188 jack_ringbuffer_read (jack_ringbuffer_t * rb, char *dest, size_t cnt)
 189 {
 190         size_t free_cnt;
 191         size_t cnt2;
 192         size_t to_read;
 193         size_t n1, n2;
 194
 195         if ((free_cnt = jack_ringbuffer_read_space (rb)) == 0) {
 196                 return 0;
 197         }
 198
 199         to_read = cnt > free_cnt ? free_cnt : cnt;
 200
 201         cnt2 = rb->read_ptr + to_read;
 202
 203         if (cnt2 > rb->size) {
 204                 n1 = rb->size - rb->read_ptr;
 205                 n2 = cnt2 & rb->size_mask;
 206         } else {
 207                 n1 = to_read;
 208                 n2 = 0;
 209         }
 210
 211         memcpy (dest, &(rb->buf[rb->read_ptr]), n1);
 212         rb->read_ptr = (rb->read_ptr + n1) & rb->size_mask;
 213
 214         if (n2) {
 215                 memcpy (dest + n1, &(rb->buf[rb->read_ptr]), n2);
 216                 rb->read_ptr = (rb->read_ptr + n2) & rb->size_mask;
 217         }
 218
 219         return to_read;
 220 }
 221
 222 /* The copying data reader w/o read pointer advance.  Copy at most
 223    `cnt' bytes from `rb' to `dest'.  Returns the actual number of bytes
 224    copied. */
 225
 226 EXPORT size_t
 227 jack_ringbuffer_peek (jack_ringbuffer_t * rb, char *dest, size_t cnt)
 228 {
 229         size_t free_cnt;
 230         size_t cnt2;
 231         size_t to_read;
 232         size_t n1, n2;
 233         size_t tmp_read_ptr;
 234
 235         tmp_read_ptr = rb->read_ptr;
 236
 237         if ((free_cnt = jack_ringbuffer_read_space (rb)) == 0) {
 238                 return 0;
 239         }
 240
 241         to_read = cnt > free_cnt ? free_cnt : cnt;
 242
 243         cnt2 = tmp_read_ptr + to_read;
 244
 245         if (cnt2 > rb->size) {
 246                 n1 = rb->size - tmp_read_ptr;
 247                 n2 = cnt2 & rb->size_mask;
 248         } else {
 249                 n1 = to_read;
 250                 n2 = 0;
 251         }
 252
 253         memcpy (dest, &(rb->buf[tmp_read_ptr]), n1);
 254         tmp_read_ptr = (tmp_read_ptr + n1) & rb->size_mask;
 255
 256         if (n2) {
 257                 memcpy (dest + n1, &(rb->buf[tmp_read_ptr]), n2);
 258         }
 259
 260         return to_read;
 261 }
 262
 263 /* The copying data writer.  Copy at most `cnt' bytes to `rb' from
 264    `src'.  Returns the actual number of bytes copied. */
 265
 266 EXPORT size_t
 267 jack_ringbuffer_write (jack_ringbuffer_t * rb, const char *src, size_t cnt)
 268 {
 269         size_t free_cnt;
 270         size_t cnt2;
 271         size_t to_write;
 272         size_t n1, n2;
 273
 274         if ((free_cnt = jack_ringbuffer_write_space (rb)) == 0) {
 275                 return 0;
 276         }
 277
 278         to_write = cnt > free_cnt ? free_cnt : cnt;
 279
 280         cnt2 = rb->write_ptr + to_write;
 281
 282         if (cnt2 > rb->size) {
 283                 n1 = rb->size - rb->write_ptr;
 284                 n2 = cnt2 & rb->size_mask;
 285         } else {
 286                 n1 = to_write;
 287                 n2 = 0;
 288         }
 289
 290         memcpy (&(rb->buf[rb->write_ptr]), src, n1);
 291         rb->write_ptr = (rb->write_ptr + n1) & rb->size_mask;
 292
 293         if (n2) {
 294                 memcpy (&(rb->buf[rb->write_ptr]), src + n1, n2);
 295                 rb->write_ptr = (rb->write_ptr + n2) & rb->size_mask;
 296         }
 297
 298         return to_write;
 299 }
 300
 301 /* Advance the read pointer `cnt' places. */
 302
 303 EXPORT void
 304 jack_ringbuffer_read_advance (jack_ringbuffer_t * rb, size_t cnt)
 305 {
 306         size_t tmp = (rb->read_ptr + cnt) & rb->size_mask;
 307         rb->read_ptr = tmp;
 308 }
 309
 310 /* Advance the write pointer `cnt' places. */
 311
 312 EXPORT void
 313 jack_ringbuffer_write_advance (jack_ringbuffer_t * rb, size_t cnt)
 314 {
 315         size_t tmp = (rb->write_ptr + cnt) & rb->size_mask;
 316         rb->write_ptr = tmp;
 317 }
 318
 319 /* The non-copying data reader.  `vec' is an array of two places.  Set
 320    the values at `vec' to hold the current readable data at `rb'.  If
 321    the readable data is in one segment the second segment has zero
 322    length.  */
 323
 324 EXPORT void
 325 jack_ringbuffer_get_read_vector (const jack_ringbuffer_t * rb,
 326                                  jack_ringbuffer_data_t * vec)
 327 {
 328         size_t free_cnt;
 329         size_t cnt2;
 330         size_t w, r;
 331
 332         w = rb->write_ptr;
 333         r = rb->read_ptr;
 334
 335         if (w > r) {
 336                 free_cnt = w - r;
 337         } else {
 338                 free_cnt = (w - r + rb->size) & rb->size_mask;
 339         }
 340
 341         cnt2 = r + free_cnt;
 342
 343         if (cnt2 > rb->size) {
 344
 345                 /* Two part vector: the rest of the buffer after the current write
 346                    ptr, plus some from the start of the buffer. */
 347
 348                 vec[0].buf = &(rb->buf[r]);
 349                 vec[0].len = rb->size - r;
 350                 vec[1].buf = rb->buf;
 351                 vec[1].len = cnt2 & rb->size_mask;
 352
 353         } else {
 354
 355                 /* Single part vector: just the rest of the buffer */
 356
 357                 vec[0].buf = &(rb->buf[r]);
 358                 vec[0].len = free_cnt;
 359                 vec[1].len = 0;
 360         }
 361 }
 362
 363 /* The non-copying data writer.  `vec' is an array of two places.  Set
 364    the values at `vec' to hold the current writeable data at `rb'.  If
 365    the writeable data is in one segment the second segment has zero
 366    length.  */
 367
 368 EXPORT void
 369 jack_ringbuffer_get_write_vector (const jack_ringbuffer_t * rb,
 370                                   jack_ringbuffer_data_t * vec)
 371 {
 372         size_t free_cnt;
 373         size_t cnt2;
 374         size_t w, r;
 375
 376         w = rb->write_ptr;
 377         r = rb->read_ptr;
 378
 379         if (w > r) {
 380                 free_cnt = ((r - w + rb->size) & rb->size_mask) - 1;
 381         } else if (w < r) {
 382                 free_cnt = (r - w) - 1;
 383         } else {
 384                 free_cnt = rb->size - 1;
 385         }
 386
 387         cnt2 = w + free_cnt;
 388
 389         if (cnt2 > rb->size) {
 390
 391                 /* Two part vector: the rest of the buffer after the current write
 392                    ptr, plus some from the start of the buffer. */
 393
 394                 vec[0].buf = &(rb->buf[w]);
 395                 vec[0].len = rb->size - w;
 396                 vec[1].buf = rb->buf;
 397                 vec[1].len = cnt2 & rb->size_mask;
 398         } else {
 399                 vec[0].buf = &(rb->buf[w]);
 400                 vec[0].len = free_cnt;
 401                 vec[1].len = 0;
 402         }
 403 }
 404