BufferHandler.h

#ifndef IPPL_BUFFER_HANDLER_H
#define IPPL_BUFFER_HANDLER_H
 
#include <memory>
#include <set>
 
#include "Communicate/Archive.h"
 
namespace ippl {
 
    template <typename MemorySpace>
    class BufferHandler {
    public:
        using archive_type = ippl::detail::Archive<MemorySpace>;
        using buffer_type  = std::shared_ptr<archive_type>;
        using size_type    = ippl::detail::size_type;
 
        virtual ~BufferHandler() {}
 
        virtual buffer_type getBuffer(size_type size, double overallocation) = 0;
 
        virtual void freeBuffer(buffer_type buffer) = 0;
 
        virtual void freeAllBuffers() = 0;
 
        virtual void deleteAllBuffers() = 0;
 
        virtual size_type getUsedSize() const = 0;
 
        virtual size_type getFreeSize() const = 0;
    };
 
    template <typename MemorySpace>
    class DefaultBufferHandler : public BufferHandler<MemorySpace> {
    public:
        using typename BufferHandler<MemorySpace>::archive_type;
        using typename BufferHandler<MemorySpace>::buffer_type;
        using typename BufferHandler<MemorySpace>::size_type;
 
        ~DefaultBufferHandler() override;
 
        buffer_type getBuffer(size_type size, double overallocation) override;
 
        void freeBuffer(buffer_type buffer) override;
 
        void freeAllBuffers() override;
 
        void deleteAllBuffers() override;
 
        size_type getUsedSize() const override;
 
        size_type getFreeSize() const override;
 
    private:
        using buffer_comparator_type = bool (*)(const buffer_type&, const buffer_type&);
        using buffer_set_type        = std::set<buffer_type, buffer_comparator_type>;
 
        static bool bufferSizeComparator(const buffer_type& lhs, const buffer_type& rhs);
 
        bool isBufferUsed(buffer_type buffer) const;
        void releaseUsedBuffer(buffer_type buffer);
        buffer_type findFreeBuffer(size_type requiredSize);
        typename buffer_set_type::iterator findSmallestSufficientBuffer(size_type requiredSize);
        buffer_type getFreeBuffer(buffer_type buffer);
        buffer_type reallocateLargestFreeBuffer(size_type requiredSize);
        buffer_type allocateNewBuffer(size_type requiredSize);
 
        size_type usedSize_m;  
        size_type freeSize_m;  
 
    protected:
        buffer_set_type used_buffers{
            &DefaultBufferHandler::bufferSizeComparator};  
        buffer_set_type free_buffers{
            &DefaultBufferHandler::bufferSizeComparator};  
    };
}  // namespace ippl
 
#include "Communicate/BufferHandler.hpp"
 
#endif