source: icGREP/icgrep-devel/icgrep/util/slab_allocator.h @ 6225

Last change on this file since 6225 was 6225, checked in by cameron, 4 months ago

PrintStats? for REs

File size: 4.3 KB
Line 
1#ifndef SLAB_ALLOCATOR_H
2#define SLAB_ALLOCATOR_H
3
4#include <llvm/Support/Allocator.h>
5
6template <typename T = uint8_t>
7class SlabAllocator {
8    template <typename U> friend class ProxyAllocator;
9    using LLVMAllocator = llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 16 * 1024>;
10public:
11
12    using value_type = T;
13    using pointer = value_type*;
14    using const_pointer = const value_type*;
15    using reference = value_type&;
16    using const_reference = const value_type&;
17    using size_type = std::size_t;
18    using difference_type = std::ptrdiff_t;
19
20    template<class U>
21    struct rebind {
22        typedef SlabAllocator<U> other;
23    };
24
25    template<typename Type = T>
26    inline Type * allocate(const size_type n, const_pointer = nullptr) noexcept {
27        static_assert(sizeof(Type) > 0, "Cannot allocate a zero-length type.");
28        assert ("A memory leak will occur whenever the SlabAllocator allocates 0 items" && n > 0);
29        auto ptr = static_cast<Type *>(mAllocator.Allocate(n * sizeof(Type), sizeof(void*)));
30        assert ("allocator returned a null pointer. Function was likely called before Allocator creation!" && ptr);
31        return ptr;
32    }
33
34    template<typename Type = T>
35    inline void deallocate(Type * p, size_type size = 0) noexcept {
36        mAllocator.Deallocate(p, size);
37    }
38
39    inline size_type max_size() const {
40        return std::numeric_limits<size_type>::max();
41    }
42
43    template<typename Type = T>
44    inline bool operator==(SlabAllocator<Type> const & other) const noexcept {
45        return this == &other;
46    }
47
48    template<typename Type = T>
49    inline bool operator!=(SlabAllocator<Type> const & other) const noexcept {
50        return this != &other;
51    }
52
53    inline size_type getTotalMemory() const noexcept {
54        return mAllocator.getTotalMemory();
55    }
56
57    inline void Reset() {
58        mAllocator.Reset();
59    }
60
61    inline void PrintStats() {
62        mAllocator.PrintStats();
63    }
64    inline SlabAllocator() noexcept {}
65    inline SlabAllocator(const SlabAllocator &) noexcept = delete;
66    template <class U> inline SlabAllocator (const SlabAllocator<U> &) noexcept { }
67private:
68    LLVMAllocator mAllocator;
69};
70
71template <typename T = uint8_t>
72class ProxyAllocator {
73    using LLVMAllocator = typename SlabAllocator<T>::LLVMAllocator;
74    template<typename U> friend class ProxyAllocator;   
75public:
76    using value_type = T;
77    using pointer = value_type*;
78    using const_pointer = const value_type*;
79    using reference = value_type&;
80    using const_reference = const value_type&;
81    using size_type = std::size_t;
82    using difference_type = std::ptrdiff_t;
83
84    template<class U>
85    struct rebind {
86        typedef ProxyAllocator<U> other;
87    };
88
89    template<typename Type = T>
90    inline Type * allocate(size_type n, const_pointer = nullptr) noexcept {
91        static_assert(sizeof(Type) > 0, "Cannot allocate a zero-length type.");
92        assert ("Cannot allocate 0 items." && n > 0);
93        auto ptr = static_cast<Type *>(mAllocator->Allocate(n * sizeof(Type), sizeof(void*)));
94        assert ("Allocating returned a null pointer. Function was likely called before Allocator creation!" && ptr);
95        return ptr;
96    }
97
98    template<typename Type = T>
99    inline void deallocate(Type * p, size_type size = 0) noexcept {
100        mAllocator->Deallocate(p, size);
101    }
102
103    inline size_type max_size() const noexcept {
104        return std::numeric_limits<size_type>::max();
105    }
106
107    template<typename Type = T>
108    inline bool operator==(ProxyAllocator<Type> const & other) const noexcept {
109        return mAllocator == other.mAllocator;
110    }
111
112    template<typename Type = T>
113    inline bool operator!=(ProxyAllocator<Type> const & other) const noexcept {
114        return mAllocator != other.mAllocator;
115    }
116
117    inline size_type getTotalMemory() const noexcept {
118        return mAllocator->getTotalMemory();
119    }
120
121    inline ProxyAllocator() noexcept = delete;
122    template <class U> inline ProxyAllocator(ProxyAllocator<U> & a) noexcept : mAllocator(a.mAllocator) {}
123    template <class U> inline ProxyAllocator(ProxyAllocator<U> && a) noexcept : mAllocator(a.mAllocator) {}
124    template <class U> inline ProxyAllocator (const SlabAllocator<U> & a) noexcept : mAllocator(const_cast<LLVMAllocator *>(&a.mAllocator)) {}
125private:
126    LLVMAllocator * const mAllocator;
127};
128
129#endif // SLAB_ALLOCATOR_H
Note: See TracBrowser for help on using the repository browser.