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

Last change on this file since 5240 was 5240, checked in by nmedfort, 3 years ago

Cleaned up memory leaks + some warning messages.

File size: 3.7 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(size_type n, const_pointer = nullptr) noexcept {
27        static_assert(sizeof(Type) > 0, "Cannot allocate a zero-length type.");
28        assert ("Cannot allocate 0 items." && n > 0);
29        auto ptr = static_cast<Type *>(mAllocator.Allocate(n * sizeof(Type), sizeof(void*)));
30        assert ("Allocating 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) {
45        return this == &other;
46    }
47
48    template<typename Type = T>
49    inline bool operator!=(SlabAllocator<Type> const & other) {
50        return this != &other;
51    }
52
53    inline SlabAllocator() noexcept {}
54    inline SlabAllocator(const SlabAllocator &) noexcept { assert (false); }
55    template <class U> inline SlabAllocator (const SlabAllocator<U> &) noexcept { assert (false); }
56private:
57    LLVMAllocator mAllocator;
58};
59
60template <typename T = uint8_t>
61class ProxyAllocator {
62    using LLVMAllocator = typename SlabAllocator<T>::LLVMAllocator;
63public:
64    using value_type = T;
65    using pointer = value_type*;
66    using const_pointer = const value_type*;
67    using reference = value_type&;
68    using const_reference = const value_type&;
69    using size_type = std::size_t;
70    using difference_type = std::ptrdiff_t;
71
72    template<class U>
73    struct rebind {
74        typedef ProxyAllocator<U> other;
75    };
76
77    template<typename Type = T>
78    inline Type * allocate(size_type n, const_pointer = nullptr) noexcept {
79        static_assert(sizeof(Type) > 0, "Cannot allocate a zero-length type.");
80        assert ("Cannot allocate 0 items." && n > 0);
81        auto ptr = static_cast<Type *>(mAllocator->Allocate(n * sizeof(Type), sizeof(void*)));
82        assert ("Allocating returned a null pointer. Function was likely called before Allocator creation!" && ptr);
83        return ptr;
84    }
85
86    template<typename Type = T>
87    inline void deallocate(Type * p, size_type size = 0) noexcept {
88        mAllocator->Deallocate(p, size);
89    }
90
91    inline size_type max_size() const {
92        return std::numeric_limits<size_type>::max();
93    }
94
95    template<typename Type = T>
96    inline bool operator==(ProxyAllocator<Type> const & other) {
97        return mAllocator == other.mAllocator;
98    }
99
100    template<typename Type = T>
101    inline bool operator!=(ProxyAllocator<Type> const & other) {
102        return mAllocator != other.mAllocator;
103    }
104
105    inline ProxyAllocator() noexcept { assert (false); }
106    inline ProxyAllocator(ProxyAllocator const & a) noexcept : mAllocator(const_cast<LLVMAllocator *>(a.mAllocator)) {}
107    template <class U> inline ProxyAllocator (const SlabAllocator<U> & a) noexcept : mAllocator(const_cast<LLVMAllocator *>(&a.mAllocator)) {}
108private:
109    LLVMAllocator * const mAllocator;
110};
111
112#endif // SLAB_ALLOCATOR_H
Note: See TracBrowser for help on using the repository browser.