WPILibC++ 2024.3.2
AllocatorBase.h
Go to the documentation of this file.
1//===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines MallocAllocator. MallocAllocator conforms to the LLVM
11/// "Allocator" concept which consists of an Allocate method accepting a size
12/// and alignment, and a Deallocate accepting a pointer and size. Further, the
13/// LLVM "Allocator" concept has overloads of Allocate and Deallocate for
14/// setting size and alignment based on the final type. These overloads are
15/// typically provided by a base class template \c AllocatorBase.
16///
17//===----------------------------------------------------------------------===//
18
19#ifndef WPIUTIL_WPI_ALLOCATORBASE_H
20#define WPIUTIL_WPI_ALLOCATORBASE_H
21
22#ifdef _MSC_VER
23#define LLVM_ALLOCATORHOLDER_EMPTYBASE __declspec(empty_bases)
24#else
25#define LLVM_ALLOCATORHOLDER_EMPTYBASE
26#endif // _MSC_VER
27
28#include "wpi/Compiler.h"
29#include "wpi/MemAlloc.h"
30#include <type_traits>
31
32namespace wpi {
33
34/// CRTP base class providing obvious overloads for the core \c
35/// Allocate() methods of LLVM-style allocators.
36///
37/// This base class both documents the full public interface exposed by all
38/// LLVM-style allocators, and redirects all of the overloads to a single core
39/// set of methods which the derived class must define.
40template <typename DerivedT> class AllocatorBase {
41public:
42 /// Allocate \a Size bytes of \a Alignment aligned memory. This method
43 /// must be implemented by \c DerivedT.
44 void *Allocate(size_t Size, size_t Alignment) {
45#ifdef __clang__
46 static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
48 static_cast<void *(DerivedT::*)(size_t, size_t)>(
49 &DerivedT::Allocate),
50 "Class derives from AllocatorBase without implementing the "
51 "core Allocate(size_t, size_t) overload!");
52#endif
53 return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
54 }
55
56 /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
57 /// allocator.
58 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
59#ifdef __clang__
60 static_assert(
61 static_cast<void (AllocatorBase::*)(const void *, size_t, size_t)>(
63 static_cast<void (DerivedT::*)(const void *, size_t, size_t)>(
64 &DerivedT::Deallocate),
65 "Class derives from AllocatorBase without implementing the "
66 "core Deallocate(void *) overload!");
67#endif
68 return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size, Alignment);
69 }
70
71 // The rest of these methods are helpers that redirect to one of the above
72 // core methods.
73
74 /// Allocate space for a sequence of objects without constructing them.
75 template <typename T> T *Allocate(size_t Num = 1) {
76 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
77 }
78
79 /// Deallocate space for a sequence of objects without constructing them.
80 template <typename T>
81 std::enable_if_t<!std::is_same_v<std::remove_cv_t<T>, void>, void>
82 Deallocate(T *Ptr, size_t Num = 1) {
83 Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T));
84 }
85};
86
87class MallocAllocator : public AllocatorBase<MallocAllocator> {
88public:
89 void Reset() {}
90
91 LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
92 return allocate_buffer(Size, Alignment);
93 }
94
95 // Pull in base class overloads.
97
98 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
99 deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment);
100 }
101
102 // Pull in base class overloads.
104
105 void PrintStats() const {}
106};
107
108namespace detail {
109
110template <typename Alloc> class AllocatorHolder : Alloc {
111public:
112 AllocatorHolder() = default;
113 AllocatorHolder(const Alloc &A) : Alloc(A) {}
114 AllocatorHolder(Alloc &&A) : Alloc(static_cast<Alloc &&>(A)) {}
115 Alloc &getAllocator() { return *this; }
116 const Alloc &getAllocator() const { return *this; }
117};
118
119template <typename Alloc> class AllocatorHolder<Alloc &> {
120 Alloc &A;
121
122public:
123 AllocatorHolder(Alloc &A) : A(A) {}
124 Alloc &getAllocator() { return A; }
125 const Alloc &getAllocator() const { return A; }
126};
127
128} // namespace detail
129
130} // namespace wpi
131
132#endif // WPIUTIL_WPI_ALLOCATORBASE_H
#define LLVM_ATTRIBUTE_RETURNS_NONNULL
Definition: Compiler.h:277
This file defines counterparts of C library allocation functions defined in the namespace 'std'.
CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators.
Definition: AllocatorBase.h:40
void * Allocate(size_t Size, size_t Alignment)
Allocate Size bytes of Alignment aligned memory.
Definition: AllocatorBase.h:44
std::enable_if_t<!std::is_same_v< std::remove_cv_t< T >, void >, void > Deallocate(T *Ptr, size_t Num=1)
Deallocate space for a sequence of objects without constructing them.
Definition: AllocatorBase.h:82
T * Allocate(size_t Num=1)
Allocate space for a sequence of objects without constructing them.
Definition: AllocatorBase.h:75
void Deallocate(const void *Ptr, size_t Size, size_t Alignment)
Deallocate Ptr to Size bytes of memory allocated by this allocator.
Definition: AllocatorBase.h:58
Definition: AllocatorBase.h:87
void PrintStats() const
Definition: AllocatorBase.h:105
LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, size_t Alignment)
Definition: AllocatorBase.h:91
void Reset()
Definition: AllocatorBase.h:89
void Deallocate(const void *Ptr, size_t Size, size_t Alignment)
Definition: AllocatorBase.h:98
const Alloc & getAllocator() const
Definition: AllocatorBase.h:125
AllocatorHolder(Alloc &A)
Definition: AllocatorBase.h:123
Alloc & getAllocator()
Definition: AllocatorBase.h:124
Definition: AllocatorBase.h:110
AllocatorHolder(const Alloc &A)
Definition: AllocatorBase.h:113
const Alloc & getAllocator() const
Definition: AllocatorBase.h:116
AllocatorHolder(Alloc &&A)
Definition: AllocatorBase.h:114
Alloc & getAllocator()
Definition: AllocatorBase.h:115
detail namespace with internal helper functions
Definition: xchar.h:20
Definition: ntcore_cpp.h:26
void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment)
Deallocate a buffer of memory with the given size and alignment.
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * allocate_buffer(size_t Size, size_t Alignment)
Allocate a buffer of memory with the given size and alignment.