memory-holder.h

#pragma once
#include <cstdlib>
#include <vector>
#include "TemplateParameters.h"

enum class buf_choose_policy
{
    naiv,
    sorted_vec,
    unsorted_vec
};

template< MemType mem >
class buffer
{
private:
    void *ptr;
    size_t allocated_size;
    size_t scalar_size;
    bool is_free;
    int id;

public:
    buffer();
    ~buffer();
    buffer(const size_t required_size);

    bool is_available() const;
    void* get_ptr();
    bool get_status() const;
    size_t get_size() const;
    buffer<mem>& operator=(buffer<mem>& other);
    void reallocate(const size_t required_size);
    void set_status(const bool status);
    void set_id(const int id);
};

class memory_pipline
{
private:
#ifdef INCLUDE_CUDA
    std::vector<buffer<MemType::GPU> > gpu_buff;
#endif
    std::vector<buffer<MemType::CPU> > cpu_buff;
public:
    memory_pipline();
    ~memory_pipline();

    template< MemType mem >
    int get_buffer(const size_t required_size, void *& ptr);

    template< MemType mem >
    std::vector<buffer<mem> >& get_memtyped_vector();

    template< MemType mem >
    void set_available(const int id);
};

class memory_faucet
{
private:
    memory_faucet() = delete;
    memory_faucet(const memory_faucet&) = delete;
    memory_faucet& operator=(const memory_faucet&) = delete;

    static memory_pipline* mem_pipe;

public:
    static memory_pipline* get_faucet();
};

template< MemType mem >
class memBuf
{
private:
    void* buf;
    int id;
    size_t size;

public:
    memBuf(const size_t required_size);
    ~memBuf();
    void* ptr();
    int get_size();
};