circularBuffer.h

// Copyright 2009-2025 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2025, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.

#ifndef SST_CORE_INTERPROCESS_CIRCULARBUFFER_H
#define SST_CORE_INTERPROCESS_CIRCULARBUFFER_H

#include <cstddef>
#include <cstdio>

#include "sstmutex.h"

namespace SST::Core::Interprocess {

template <typename T>
class CircularBuffer
{

public:
    explicit CircularBuffer(size_t mSize = 0)
    {
        buffSize   = mSize;
        readIndex  = 0;
        writeIndex = 0;
    }

    bool setBufferSize(const size_t bufferSize)
    {
        if ( buffSize != 0 ) {
            fprintf(stderr, "Already specified size for buffer\n");
            return false;
        }

        buffSize = bufferSize;
        __sync_synchronize();
        return true;
    }

    T read()
    {
        int loop_counter = 0;

        while ( true ) {
            bufferMutex.lock();

            if ( readIndex != writeIndex ) {
                const T result = buffer[readIndex];
                readIndex      = (readIndex + 1) % buffSize;

                bufferMutex.unlock();
                return result;
            }

            bufferMutex.unlock();
            bufferMutex.processorPause(loop_counter++);
        }
    }

    bool readNB(T* result)
    {
        if ( bufferMutex.try_lock() ) {
            if ( readIndex != writeIndex ) {
                *result   = buffer[readIndex];
                readIndex = (readIndex + 1) % buffSize;

                bufferMutex.unlock();
                return true;
            }

            bufferMutex.unlock();
        }

        return false;
    }

    void write(const T& v)
    {
        int loop_counter = 0;

        while ( true ) {
            bufferMutex.lock();

            if ( ((writeIndex + 1) % buffSize) != readIndex ) {
                buffer[writeIndex] = v;
                writeIndex         = (writeIndex + 1) % buffSize;

                __sync_synchronize();
                bufferMutex.unlock();
                return;
            }

            bufferMutex.unlock();
            bufferMutex.processorPause(loop_counter++);
        }
    }

    ~CircularBuffer() {}

    void clearBuffer()
    {
        bufferMutex.lock();
        readIndex = writeIndex;
        __sync_synchronize();
        bufferMutex.unlock();
    }

private:
    SSTMutex bufferMutex;
    size_t   buffSize;
    size_t   readIndex;
    size_t   writeIndex;
    T        buffer[0];
};

} // namespace SST::Core::Interprocess

#endif // SST_CORE_INTERPROCESS_CIRCULARBUFFER_H