ScratchBufferManager.h

Go to the documentation of this file.

/***********************************************************************************************************************
*                                                                                                                      *
* libscopehal                                                                                                          *
*                                                                                                                      *
* Copyright (c) 2012-2026 Andrew D. Zonenberg and contributors                                                         *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef ScratchBufferManager_h
#define ScratchBufferManager_h
 
class ScratchBufferManager
{
public:
 
    // Pool IDs
 
    enum PoolID_uint8
    {
        //Roughly one uint8_t per sample in the waveform, GPU resident
        U8_GPU_WAVEFORM
    };
 
    enum PoolID_uint32
    {
        //Roughly one uint32_t per sample in the waveform, GPU resident
        U32_GPU_WAVEFORM
    };
 
    enum PoolID_float32
    {
        //Roughly one float32 per sample in the waveform, GPU resident
        F32_GPU_WAVEFORM
    };
 
    enum PoolID_int64
    {
        //Roughly one int64_t per sample in the waveform, GPU resident
        I64_GPU_WAVEFORM,
 
        //Small buffers (a few values per thread), GPU resident
        I64_GPU_SMALL
    };
 
    // System stats
 
    static size_t GetTotalSize();
    static size_t GetPoolSize(PoolID_uint8 id);
    static size_t GetPoolSize(PoolID_uint32 id);
    static size_t GetPoolSize(PoolID_float32 id);
    static size_t GetPoolSize(PoolID_int64 id);
 
    // Memory pressure and cleanup
 
    static void clear();
    static bool OnMemoryPressure(MemoryPressureLevel level, MemoryPressureType type, size_t requestedSize);
 
    // The pools
 
    static std::shared_ptr< AcceleratorBuffer<uint8_t> > Allocate(PoolID_uint8 pool);
    static std::shared_ptr< AcceleratorBuffer<uint32_t> > Allocate(PoolID_uint32 pool);
    static std::shared_ptr< AcceleratorBuffer<float> > Allocate(PoolID_float32 pool);
    static std::shared_ptr< AcceleratorBuffer<int64_t> > Allocate(PoolID_int64 pool);
 
    static void Free(std::shared_ptr< AcceleratorBuffer<uint8_t> >& p, PoolID_uint8 pool);
    static void Free(std::shared_ptr< AcceleratorBuffer<uint32_t> >& p, PoolID_uint32 pool);
    static void Free(std::shared_ptr< AcceleratorBuffer<float> >& p, PoolID_float32 pool);
    static void Free(std::shared_ptr< AcceleratorBuffer<int64_t> >& p, PoolID_int64 pool);
 
protected:
 
    static std::mutex m_poolMutex;
 
    static std::list< std::shared_ptr<AcceleratorBuffer<uint8_t> > > m_pool_u8_gpu_waveform;
 
    static std::list< std::shared_ptr<AcceleratorBuffer<uint32_t> > > m_pool_u32_gpu_waveform;
 
    static std::list< std::shared_ptr<AcceleratorBuffer<float> > > m_pool_f32_gpu_waveform;
 
    static std::list< std::shared_ptr<AcceleratorBuffer<int64_t> > > m_pool_i64_gpu_waveform;
 
    static std::list< std::shared_ptr<AcceleratorBuffer<int64_t> > > m_pool_i64_gpu_small;
};
 
template<class ID, class T>
class ScratchBuffer : public ScratchBufferBase
{
public:
 
    ScratchBuffer()
        : m_ptr(nullptr)
        , m_pool(static_cast<ID>(0))
    {}
 
    //move one scratchbuffer to another, disconnecting the original one
    ScratchBuffer(ScratchBuffer<ID, T>&& rhs)
        : m_ptr(rhs.m_ptr)
        , m_pool(rhs.m_pool)
    {
        rhs.m_ptr = nullptr;
    }
 
    ScratchBuffer(ID id)
        : m_ptr(ScratchBufferManager::Allocate(id))
        , m_pool(id)
    {}
 
    virtual ~ScratchBuffer()
    {
        if(m_ptr != nullptr)
            ScratchBufferManager::Free(m_ptr, m_pool);
    }
 
    //move one scratchbuffer to another, disconnecting the original one
    auto& operator=(ScratchBuffer<ID, T>&& rhs)
    {
        m_ptr = rhs.m_ptr;
        m_pool = rhs.m_pool;
 
        rhs.m_ptr = nullptr;
        return *this;
    }
 
    AcceleratorBuffer<T>& operator*()
    { return *m_ptr.get(); }
 
    AcceleratorBuffer<T>* operator->()
    { return m_ptr.get(); }
 
protected:
 
    std::shared_ptr< AcceleratorBuffer<T> > m_ptr;
 
    ID m_pool;
};
 
//needs to be after ScratchBufferManager declaration
template<class T>
void QueueHandle::MarkScratchBufferUsed(T& buf)
{ m_usedScratchBuffers.emplace(std::make_unique<T>(std::move(buf))); }
 
typedef ScratchBuffer<ScratchBufferManager::PoolID_uint8, uint8_t> ScratchBuffer_uint8_t;
typedef ScratchBuffer<ScratchBufferManager::PoolID_uint32, uint32_t> ScratchBuffer_uint32_t;
typedef ScratchBuffer<ScratchBufferManager::PoolID_float32, float> ScratchBuffer_float32_t;
typedef ScratchBuffer<ScratchBufferManager::PoolID_int64, int64_t> ScratchBuffer_int64_t;
 
#endif