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 #include <stdexcept>
  29
  30 #include "almalloc.h"
  31
  32
  33 RingBufferPtr RingBuffer::Create(size_t sz, size_t elem_sz, int limit_writes)
  34 {
  35     size_t power_of_two{0u};
  36     if(sz > 0)
  37     {
  38         power_of_two = sz;
  39         power_of_two |= power_of_two>>1;
  40         power_of_two |= power_of_two>>2;
  41         power_of_two |= power_of_two>>4;
  42         power_of_two |= power_of_two>>8;
  43         power_of_two |= power_of_two>>16;
  44 #if SIZE_MAX > UINT_MAX
  45         power_of_two |= power_of_two>>32;
  46 #endif
  47     }
  48     ++power_of_two;
  49     if(power_of_two <= sz || power_of_two > std::numeric_limits<size_t>::max()/elem_sz)
  50         throw std::overflow_error{"Ring buffer size overflow"};
  51
  52     const size_t bufbytes{power_of_two * elem_sz};
  53     RingBufferPtr rb{new(FamCount(bufbytes)) RingBuffer{bufbytes}};
  54     rb->mWriteSize = limit_writes ? sz : (power_of_two-1);
  55     rb->mSizeMask = power_of_two - 1;
  56     rb->mElemSize = elem_sz;
  57
  58     return rb;
  59 }
  60
  61 void RingBuffer::reset() noexcept
  62 {
  63     mWritePtr.store(0, std::memory_order_relaxed);
  64     mReadPtr.store(0, std::memory_order_relaxed);
  65     std::fill_n(mBuffer.begin(), (mSizeMask+1)*mElemSize, al::byte{});
  66 }
  67
  68
  69 size_t RingBuffer::read(void *dest, size_t cnt) noexcept
  70 {
  71     const size_t free_cnt{readSpace()};
  72     if(free_cnt == 0) return 0;
  73
  74     const size_t to_read{std::min(cnt, free_cnt)};
  75     size_t read_ptr{mReadPtr.load(std::memory_order_relaxed) & mSizeMask};
  76
  77     size_t n1, n2;
  78     const size_t cnt2{read_ptr + to_read};
  79     if(cnt2 > mSizeMask+1)
  80     {
  81         n1 = mSizeMask+1 - read_ptr;
  82         n2 = cnt2 & mSizeMask;
  83     }
  84     else
  85     {
  86         n1 = to_read;
  87         n2 = 0;
  88     }
  89
  90     auto outiter = std::copy_n(mBuffer.begin() + read_ptr*mElemSize, n1*mElemSize,
  91         static_cast<al::byte*>(dest));
  92     read_ptr += n1;
  93     if(n2 > 0)
  94     {
  95         std::copy_n(mBuffer.begin(), n2*mElemSize, outiter);
  96         read_ptr += n2;
  97     }
  98     mReadPtr.store(read_ptr, std::memory_order_release);
  99     return to_read;
 100 }
 101
 102 size_t RingBuffer::peek(void *dest, size_t cnt) const noexcept
 103 {
 104     const size_t free_cnt{readSpace()};
 105     if(free_cnt == 0) return 0;
 106
 107     const size_t to_read{std::min(cnt, free_cnt)};
 108     size_t read_ptr{mReadPtr.load(std::memory_order_relaxed) & mSizeMask};
 109
 110     size_t n1, n2;
 111     const size_t cnt2{read_ptr + to_read};
 112     if(cnt2 > mSizeMask+1)
 113     {
 114         n1 = mSizeMask+1 - read_ptr;
 115         n2 = cnt2 & mSizeMask;
 116     }
 117     else
 118     {
 119         n1 = to_read;
 120         n2 = 0;
 121     }
 122
 123     auto outiter = std::copy_n(mBuffer.begin() + read_ptr*mElemSize, n1*mElemSize,
 124         static_cast<al::byte*>(dest));
 125     if(n2 > 0)
 126         std::copy_n(mBuffer.begin(), n2*mElemSize, outiter);
 127     return to_read;
 128 }
 129
 130 size_t RingBuffer::write(const void *src, size_t cnt) noexcept
 131 {
 132     const size_t free_cnt{writeSpace()};
 133     if(free_cnt == 0) return 0;
 134
 135     const size_t to_write{std::min(cnt, free_cnt)};
 136     size_t write_ptr{mWritePtr.load(std::memory_order_relaxed) & mSizeMask};
 137
 138     size_t n1, n2;
 139     const size_t cnt2{write_ptr + to_write};
 140     if(cnt2 > mSizeMask+1)
 141     {
 142         n1 = mSizeMask+1 - write_ptr;
 143         n2 = cnt2 & mSizeMask;
 144     }
 145     else
 146     {
 147         n1 = to_write;
 148         n2 = 0;
 149     }
 150
 151     auto srcbytes = static_cast<const al::byte*>(src);
 152     std::copy_n(srcbytes, n1*mElemSize, mBuffer.begin() + write_ptr*mElemSize);
 153     write_ptr += n1;
 154     if(n2 > 0)
 155     {
 156         std::copy_n(srcbytes + n1*mElemSize, n2*mElemSize, mBuffer.begin());
 157         write_ptr += n2;
 158     }
 159     mWritePtr.store(write_ptr, std::memory_order_release);
 160     return to_write;
 161 }
 162
 163
 164 void RingBuffer::readAdvance(size_t cnt) noexcept
 165 {
 166     mReadPtr.fetch_add(cnt, std::memory_order_acq_rel);
 167 }
 168
 169 void RingBuffer::writeAdvance(size_t cnt) noexcept
 170 {
 171     mWritePtr.fetch_add(cnt, std::memory_order_acq_rel);
 172 }
 173
 174
 175 ll_ringbuffer_data_pair RingBuffer::getReadVector() const noexcept
 176 {
 177     ll_ringbuffer_data_pair ret;
 178
 179     size_t w{mWritePtr.load(std::memory_order_acquire)};
 180     size_t r{mReadPtr.load(std::memory_order_acquire)};
 181     w &= mSizeMask;
 182     r &= mSizeMask;
 183     const size_t free_cnt{(w-r) & mSizeMask};
 184
 185     const size_t cnt2{r + free_cnt};
 186     if(cnt2 > mSizeMask+1)
 187     {
 188         /* Two part vector: the rest of the buffer after the current read ptr,
 189          * plus some from the start of the buffer. */
 190         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + r*mElemSize);
 191         ret.first.len = mSizeMask+1 - r;
 192         ret.second.buf = const_cast<al::byte*>(mBuffer.data());
 193         ret.second.len = cnt2 & mSizeMask;
 194     }
 195     else
 196     {
 197         /* Single part vector: just the rest of the buffer */
 198         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + r*mElemSize);
 199         ret.first.len = free_cnt;
 200         ret.second.buf = nullptr;
 201         ret.second.len = 0;
 202     }
 203
 204     return ret;
 205 }
 206
 207 ll_ringbuffer_data_pair RingBuffer::getWriteVector() const noexcept
 208 {
 209     ll_ringbuffer_data_pair ret;
 210
 211     size_t w{mWritePtr.load(std::memory_order_acquire)};
 212     size_t r{mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask};
 213     w &= mSizeMask;
 214     r &= mSizeMask;
 215     const size_t free_cnt{(r-w-1) & mSizeMask};
 216
 217     const size_t cnt2{w + free_cnt};
 218     if(cnt2 > mSizeMask+1)
 219     {
 220         /* Two part vector: the rest of the buffer after the current write ptr,
 221          * plus some from the start of the buffer. */
 222         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + w*mElemSize);
 223         ret.first.len = mSizeMask+1 - w;
 224         ret.second.buf = const_cast<al::byte*>(mBuffer.data());
 225         ret.second.len = cnt2 & mSizeMask;
 226     }
 227     else
 228     {
 229         ret.first.buf = const_cast<al::byte*>(mBuffer.data() + w*mElemSize);
 230         ret.first.len = free_cnt;
 231         ret.second.buf = nullptr;
 232         ret.second.len = 0;
 233     }
 234
 235     return ret;
 236 }