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

Last change on this file since 5893 was 5782, checked in by nmedfort, 22 months ago

Initial check-in of LookAhead? support; modified LineBreakKernel? to compute CR+LF using LookAhead?(1) + misc. fixes.

File size: 4.2 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 SlabAllocator() noexcept {}
62    inline SlabAllocator(const SlabAllocator &) noexcept = delete;
63    template <class U> inline SlabAllocator (const SlabAllocator<U> &) noexcept { }
64private:
65    LLVMAllocator mAllocator;
66};
67
68template <typename T = uint8_t>
69class ProxyAllocator {
70    using LLVMAllocator = typename SlabAllocator<T>::LLVMAllocator;
71    template<typename U> friend class ProxyAllocator;   
72public:
73    using value_type = T;
74    using pointer = value_type*;
75    using const_pointer = const value_type*;
76    using reference = value_type&;
77    using const_reference = const value_type&;
78    using size_type = std::size_t;
79    using difference_type = std::ptrdiff_t;
80
81    template<class U>
82    struct rebind {
83        typedef ProxyAllocator<U> other;
84    };
85
86    template<typename Type = T>
87    inline Type * allocate(size_type n, const_pointer = nullptr) noexcept {
88        static_assert(sizeof(Type) > 0, "Cannot allocate a zero-length type.");
89        assert ("Cannot allocate 0 items." && n > 0);
90        auto ptr = static_cast<Type *>(mAllocator->Allocate(n * sizeof(Type), sizeof(void*)));
91        assert ("Allocating returned a null pointer. Function was likely called before Allocator creation!" && ptr);
92        return ptr;
93    }
94
95    template<typename Type = T>
96    inline void deallocate(Type * p, size_type size = 0) noexcept {
97        mAllocator->Deallocate(p, size);
98    }
99
100    inline size_type max_size() const noexcept {
101        return std::numeric_limits<size_type>::max();
102    }
103
104    template<typename Type = T>
105    inline bool operator==(ProxyAllocator<Type> const & other) const noexcept {
106        return mAllocator == other.mAllocator;
107    }
108
109    template<typename Type = T>
110    inline bool operator!=(ProxyAllocator<Type> const & other) const noexcept {
111        return mAllocator != other.mAllocator;
112    }
113
114    inline size_type getTotalMemory() const noexcept {
115        return mAllocator->getTotalMemory();
116    }
117
118    inline ProxyAllocator() noexcept = delete;
119    template <class U> inline ProxyAllocator(ProxyAllocator<U> & a) noexcept : mAllocator(a.mAllocator) {}
120    template <class U> inline ProxyAllocator(ProxyAllocator<U> && a) noexcept : mAllocator(a.mAllocator) {}
121    template <class U> inline ProxyAllocator (const SlabAllocator<U> & a) noexcept : mAllocator(const_cast<LLVMAllocator *>(&a.mAllocator)) {}
122private:
123    LLVMAllocator * const mAllocator;
124};
125
126#endif // SLAB_ALLOCATOR_H
Note: See TracBrowser for help on using the repository browser.