ringbuffer.cpp

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "iatomic.h"
#include "ringbuffer.h"
 
#include "logger.h"
 
/******************************************************************************
 * cSoftHdRingbuffer class
 *
 * Lock free ring buffer with only one writer and one reader
 *****************************************************************************/
 
cSoftHdRingbuffer::cSoftHdRingbuffer(size_t size)
{
    if (!(m_pBuffer = (char *)malloc(size)))    // allocate buffer
    LOGFATAL("ringbuffer: %s: can't allocate memory for ringbuffer", __FUNCTION__);
 
    m_Size = size;
    m_pBufferEnd = m_pBuffer + size;
    m_pReadPointer = m_pBuffer;
    m_pWritePointer = m_pBuffer;
    atomic_set(&m_filled, 0);
}
 
cSoftHdRingbuffer::~cSoftHdRingbuffer(void)
{
    free(m_pBuffer);
}
 
void cSoftHdRingbuffer::Reset(void)
{
    m_pReadPointer = m_pBuffer;
    m_pWritePointer = m_pBuffer;
    atomic_set(&m_filled, 0);
}
 
size_t cSoftHdRingbuffer::WriteAdvance(size_t cnt)
{
    size_t n;
 
    n = m_Size - atomic_read(&m_filled);
    if (cnt > n) {      // not enough space
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pWritePointer;
    if (n > cnt) {      // don't cross the end
        m_pWritePointer += cnt;
    } else {        // reached or cross the end
        m_pWritePointer = m_pBuffer;
        if (n < cnt) {
            n = cnt - n;
            m_pWritePointer += n;
        }
    }
 
    //
    //  Only atomic modification!
    //
    atomic_add(cnt, &m_filled);
    return cnt;
}
 
size_t cSoftHdRingbuffer::Write(const void *buf, size_t cnt)
{
    size_t n;
 
    n = m_Size - atomic_read(&m_filled);
    if (cnt > n) {          // not enough space
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pWritePointer;
    if (n > cnt) {          // don't cross the end
        memcpy(m_pWritePointer, buf, cnt);
        m_pWritePointer += cnt;
    } else {                // reached or cross the end
        memcpy(m_pWritePointer, buf, n);
        m_pWritePointer = m_pBuffer;
        if (n < cnt) {
            buf = (uint8_t *)buf + n;
            n = cnt - n;
            memcpy(m_pWritePointer, buf, n);
            m_pWritePointer += n;
        }
    }
 
    //
    //  Only atomic modification!
    //
    atomic_add(cnt, &m_filled);
    return cnt;
}
 
size_t cSoftHdRingbuffer::GetWritePointer(void **wp)
{
    size_t n;
    size_t cnt;
 
    //  Total free bytes available in ring buffer
    cnt = m_Size - atomic_read(&m_filled);
 
    *wp = m_pWritePointer;
 
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pWritePointer;
    if (n <= cnt) {         // reached or cross the end
        return n;
    }
    return cnt;
}
 
size_t cSoftHdRingbuffer::ReadAdvance(size_t cnt)
{
    size_t n;
 
    n = atomic_read(&m_filled);
    if (cnt > n) {          // not enough filled
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pReadPointer;
    if (n > cnt) {          // don't cross the end
        m_pReadPointer += cnt;
    } else {                // reached or cross the end
        m_pReadPointer = m_pBuffer;
        if (n < cnt) {
            n = cnt - n;
            m_pReadPointer += n;
        }
    }
 
    //
    //  Only atomic modification!
    //
    atomic_sub(cnt, &m_filled);
    return cnt;
}
 
size_t cSoftHdRingbuffer::Read(void *buf, size_t cnt)
{
    size_t n;
 
    n = atomic_read(&m_filled);
    if (cnt > n) {          // not enough filled
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pReadPointer;
    if (n > cnt) {          // don't cross the end
        memcpy(buf, m_pReadPointer, cnt);
        m_pReadPointer += cnt;
    } else {                // reached or cross the end
        memcpy(buf, m_pReadPointer, n);
        m_pReadPointer = m_pBuffer;
        if (n < cnt) {
            buf = (uint8_t *)buf + n;
            n = cnt - n;
            memcpy(buf, m_pReadPointer, n);
            m_pReadPointer += n;
        }
    }
 
    //
    //  Only atomic modification!
    //
    atomic_sub(cnt, &m_filled);
    return cnt;
}
 
size_t cSoftHdRingbuffer::GetReadPointer(const void **rp)
{
    size_t n;
    size_t cnt;
 
    //  Total used bytes in ring buffer
    cnt = atomic_read(&m_filled);
 
    *rp = m_pReadPointer;
 
    //
    //  Hitting end of buffer?
    //
    n = m_pBufferEnd - m_pReadPointer;
    if (n <= cnt) {         // reached or cross the end
        return n;
    }
    return cnt;
}
 
size_t cSoftHdRingbuffer::FreeBytes(void)
{
    return m_Size - atomic_read(&m_filled);
}
 
size_t cSoftHdRingbuffer::UsedBytes(void)
{
    return atomic_read(&m_filled);
}