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
41
42
43
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*========================== begin_copyright_notice ============================
Copyright (C) 2017-2021 Intel Corporation
SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/
// An arena based memory manager implementation.
// NOTE: Object requiring dword alignment is NOT supported.
#ifndef _MEM_MANAGER_H_
#define _MEM_MANAGER_H_
#include "Arena.h"
#include <memory>
namespace vISA {
class Mem_Manager {
public:
Mem_Manager(size_t defaultArenaSize);
~Mem_Manager();
Mem_Manager(const Mem_Manager &) = delete;
Mem_Manager &operator=(const Mem_Manager &) = delete;
void *alloc(size_t size) {
return _arenaManager.AllocDataSpace(size, ArenaHeader::defaultAlign);
}
void *alloc(size_t size, std::align_val_t al) {
return _arenaManager.AllocDataSpace(size, static_cast<size_t>(al));
}
private:
vISA::ArenaManager _arenaManager;
};
template <class T> class std_arena_based_allocator {
protected:
std::shared_ptr<Mem_Manager> mem_manager_ptr;
public:
// for allocator_traits
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef T *pointer;
typedef const T *const_pointer;
typedef T &reference;
typedef const T &const_reference;
typedef T value_type;
~std_arena_based_allocator() = default;
explicit std_arena_based_allocator(std::shared_ptr<Mem_Manager> _other_ptr)
: mem_manager_ptr(_other_ptr) {}
explicit std_arena_based_allocator() : mem_manager_ptr(nullptr) {
// This implicitly calls Mem_manager constructor.
mem_manager_ptr = std::make_shared<Mem_Manager>(4096);
}
explicit std_arena_based_allocator(const std_arena_based_allocator &other)
: mem_manager_ptr(other.mem_manager_ptr) {}
template <class U>
std_arena_based_allocator(const std_arena_based_allocator<U> &other)
: mem_manager_ptr(other.mem_manager_ptr) {}
template <class U>
std_arena_based_allocator &
operator=(const std_arena_based_allocator<U> &other) {
mem_manager_ptr = other.mem_manager_ptr;
return *this;
}
template <class U> struct rebind {
typedef std_arena_based_allocator<U> other;
};
template <class U> friend class std_arena_based_allocator;
pointer allocate(size_type n, const void * = 0) {
T *t = (T *)mem_manager_ptr->alloc(n * sizeof(T));
return t;
}
void deallocate(void *p, size_type) {
// No deallocation for arena allocator.
}
pointer address(reference x) const { return &x; }
const_pointer address(const_reference x) const { return &x; }
std_arena_based_allocator<T> &operator=(const std_arena_based_allocator &) {
return *this;
}
void construct(pointer p, const T &val) { new ((T *)p) T(val); }
void destroy(pointer p) { p->~T(); }
size_type max_size() const { return size_t(-1); }
bool operator==(const std_arena_based_allocator &) const { return true; }
bool operator!=(const std_arena_based_allocator &a) const {
return !operator==(a);
}
};
} // namespace vISA
#endif
|
