Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#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() const;
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:
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
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();
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();
};