alc/ringbuffer.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "ringbuffer.h"
  24
  25 #include <algorithm>
  26 #include <climits>
  27 #include <cstdint>
  28
  29 #include "almalloc.h"
  30
  31
  32 RingBufferPtr CreateRingBuffer(size_t sz, size_t elem_sz, int limit_writes)
  33 {
  34     size_t power_of_two{0u};
  35     if(sz > 0)
  36     {
  37         power_of_two = sz;
  38         power_of_two |= power_of_two>>1;
  39         power_of_two |= power_of_two>>2;
  40         power_of_two |= power_of_two>>4;
  41         power_of_two |= power_of_two>>8;
  42         power_of_two |= power_of_two>>16;
  43 #if SIZE_MAX > UINT_MAX
  44         power_of_two |= power_of_two>>32;
  45 #endif
  46     }
  47     ++power_of_two;
  48     if(power_of_two < sz) return nullptr;
  49
  50     const size_t bufbytes{power_of_two * elem_sz};
  51     RingBufferPtr rb{new (FamCount{bufbytes}) RingBuffer{bufbytes}};
  52     rb->mWriteSize = limit_writes ? sz : (power_of_two-1);
  53     rb->mSizeMask = power_of_two - 1;
  54     rb->mElemSize = elem_sz;
  55
  56     return rb;
  57 }
  58
  59 void RingBuffer::reset() noexcept
  60 {
  61     mWritePtr.store(0, std::memory_order_relaxed);
  62     mReadPtr.store(0, std::memory_order_relaxed);
  63     std::fill_n(mBuffer.begin(), (mSizeMask+1)*mElemSize, al::byte{});
  64 }
  65
  66
  67 size_t RingBuffer::readSpace() const noexcept
  68 {
  69     size_t w = mWritePtr.load(std::memory_order_acquire);
  70     size_t r = mReadPtr.load(std::memory_order_acquire);
  71     return (w-r) & mSizeMask;
  72 }
  73
  74 size_t RingBuffer::writeSpace() const noexcept
  75 {
  76     size_t w = mWritePtr.load(std::memory_order_acquire);
  77     size_t r = mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask;
  78     return (r-w-1) & mSizeMask;
  79 }
  80
  81
  82 size_t RingBuffer::read(void *dest, size_t cnt) noexcept
  83 {
  84     const size_t free_cnt{readSpace()};
  85     if(free_cnt == 0) return 0;
  86
  87     const size_t to_read{std::min(cnt, free_cnt)};
  88     size_t read_ptr{mReadPtr.load(std::memory_order_relaxed) & mSizeMask};
  89
  90     size_t n1, n2;
  91     const size_t cnt2{read_ptr + to_read};
  92     if(cnt2 > mSizeMask+1)
  93     {
  94         n1 = mSizeMask+1 - read_ptr;
  95         n2 = cnt2 & mSizeMask;
  96     }
  97     else
  98     {
  99         n1 = to_read;
 100         n2 = 0;
 101     }
 102
 103     auto outiter = std::copy_n(mBuffer.begin() + read_ptr*mElemSize, n1*mElemSize,
 104         static_cast<al::byte*>(dest));
 105     read_ptr += n1;
 106     if(n2 > 0)
 107     {
 108         std::copy_n(mBuffer.begin(), n2*mElemSize, outiter);
 109         read_ptr += n2;
 110     }
 111     mReadPtr.store(read_ptr, std::memory_order_release);
 112     return to_read;
 113 }
 114
 115 size_t RingBuffer::peek(void *dest, size_t cnt) const noexcept
 116 {
 117     const size_t free_cnt{readSpace()};
 118     if(free_cnt == 0) return 0;
 119
 120     const size_t to_read{std::min(cnt, free_cnt)};
 121     size_t read_ptr{mReadPtr.load(std::memory_order_relaxed) & mSizeMask};
 122
 123     size_t n1, n2;
 124     const size_t cnt2{read_ptr + to_read};
 125     if(cnt2 > mSizeMask+1)
 126     {
 127         n1 = mSizeMask+1 - read_ptr;
 128         n2 = cnt2 & mSizeMask;
 129     }
 130     else
 131     {
 132         n1 = to_read;
 133         n2 = 0;
 134     }
 135
 136     auto outiter = std::copy_n(mBuffer.begin() + read_ptr*mElemSize, n1*mElemSize,
 137         static_cast<al::byte*>(dest));
 138     if(n2 > 0)
 139         std::copy_n(mBuffer.begin(), n2*mElemSize, outiter);
 140     return to_read;
 141 }
 142
 143 size_t RingBuffer::write(const void *src, size_t cnt) noexcept
 144 {
 145     const size_t free_cnt{writeSpace()};
 146     if(free_cnt == 0) return 0;
 147
 148     const size_t to_write{std::min(cnt, free_cnt)};
 149     size_t write_ptr{mWritePtr.load(std::memory_order_relaxed) & mSizeMask};
 150
 151     size_t n1, n2;
 152     const size_t cnt2{write_ptr + to_write};
 153     if(cnt2 > mSizeMask+1)
 154     {
 155         n1 = mSizeMask+1 - write_ptr;
 156         n2 = cnt2 & mSizeMask;
 157     }
 158     else
 159     {
 160         n1 = to_write;
 161         n2 = 0;
 162     }
 163
 164     auto srcbytes = static_cast<const al::byte*>(src);
 165     std::copy_n(srcbytes, n1*mElemSize, mBuffer.begin() + write_ptr*mElemSize);
 166     write_ptr += n1;
 167     if(n2 > 0)
 168     {
 169         std::copy_n(srcbytes + n1*mElemSize, n2*mElemSize, mBuffer.begin());
 170         write_ptr += n2;
 171     }
 172     mWritePtr.store(write_ptr, std::memory_order_release);
 173     return to_write;
 174 }
 175
 176
 177 void RingBuffer::readAdvance(size_t cnt) noexcept
 178 {
 179     mReadPtr.fetch_add(cnt, std::memory_order_acq_rel);
 180 }
 181
 182 void RingBuffer::writeAdvance(size_t cnt) noexcept
 183 {
 184     mWritePtr.fetch_add(cnt, std::memory_order_acq_rel);
 185 }
 186
 187
 188 ll_ringbuffer_data_pair RingBuffer::getReadVector() const noexcept
 189 {
 190     ll_ringbuffer_data_pair ret;
 191
 192     size_t w{mWritePtr.load(std::memory_order_acquire)};
 193     size_t r{mReadPtr.load(std::memory_order_acquire)};
 194     w &= mSizeMask;
 195     r &= mSizeMask;
 196     const size_t free_cnt{(w-r) & mSizeMask};
 197
 198     const size_t cnt2{r + free_cnt};
 199     if(cnt2 > mSizeMask+1)
 200     {
 201         /* Two part vector: the rest of the buffer after the current read ptr,
 202          * plus some from the start of the buffer. */
 203         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + r*mElemSize);
 204         ret.first.len = mSizeMask+1 - r;
 205         ret.second.buf = const_cast<al::byte*>(mBuffer.data());
 206         ret.second.len = cnt2 & mSizeMask;
 207     }
 208     else
 209     {
 210         /* Single part vector: just the rest of the buffer */
 211         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + r*mElemSize);
 212         ret.first.len = free_cnt;
 213         ret.second.buf = nullptr;
 214         ret.second.len = 0;
 215     }
 216
 217     return ret;
 218 }
 219
 220 ll_ringbuffer_data_pair RingBuffer::getWriteVector() const noexcept
 221 {
 222     ll_ringbuffer_data_pair ret;
 223
 224     size_t w{mWritePtr.load(std::memory_order_acquire)};
 225     size_t r{mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask};
 226     w &= mSizeMask;
 227     r &= mSizeMask;
 228     const size_t free_cnt{(r-w-1) & mSizeMask};
 229
 230     const size_t cnt2{w + free_cnt};
 231     if(cnt2 > mSizeMask+1)
 232     {
 233         /* Two part vector: the rest of the buffer after the current write ptr,
 234          * plus some from the start of the buffer. */
 235         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + w*mElemSize);
 236         ret.first.len = mSizeMask+1 - w;
 237         ret.second.buf = const_cast<al::byte*>(mBuffer.data());
 238         ret.second.len = cnt2 & mSizeMask;
 239     }
 240     else
 241     {
 242         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + w*mElemSize);
 243         ret.first.len = free_cnt;
 244         ret.second.buf = nullptr;
 245         ret.second.len = 0;
 246     }
 247
 248     return ret;
 249 }