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