Allocator.h

Go to the documentation of this file.

//===- Allocator.h - Simple memory allocation abstraction -------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms
/// to the LLVM "Allocator" concept and is similar to MallocAllocator, but
/// objects cannot be deallocated. Their lifetime is tied to the lifetime of the
/// allocator.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_SUPPORT_ALLOCATOR_H
#define LLVM_SUPPORT_ALLOCATOR_H
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/Config/abi-breaking.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/AllocatorBase.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/MathExtras.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <optional>
#include <utility>
 
namespace llvm {
 
namespace detail {
 
// We call out to an external function to actually print the message as the
// printing code uses Allocator.h in its implementation.
LLVM_ABI void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t TotalMemory);
 
} // end namespace detail
 
/// Allocate memory in an ever growing pool, as if by bump-pointer.
///
/// This isn't strictly a bump-pointer allocator as it uses backing slabs of
/// memory rather than relying on a boundless contiguous heap. However, it has
/// bump-pointer semantics in that it is a monotonically growing pool of memory
/// where every allocation is found by merely allocating the next N bytes in
/// the slab, or the next N bytes in the next slab.
///
/// Note that this also has a threshold for forcing allocations above a certain
/// size into their own slab.
///
/// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
/// object, which wraps malloc, to allocate memory, but it can be changed to
/// use a custom allocator.
///
/// The GrowthDelay specifies after how many allocated slabs the allocator
/// increases the size of the slabs.
///
/// MinAlign keeps the bump pointer aligned between allocations: each size is
/// rounded up to a multiple of MinAlign so the fast path can skip realigning
/// CurPtr when the requested alignment is no greater than MinAlign.
template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
          size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128,
          size_t MinAlign = 8>
class BumpPtrAllocatorImpl
    : public AllocatorBase<BumpPtrAllocatorImpl<
          AllocatorT, SlabSize, SizeThreshold, GrowthDelay, MinAlign>>,
      private detail::AllocatorHolder<AllocatorT> {
  using AllocTy = detail::AllocatorHolder<AllocatorT>;
 
public:
  static_assert(SizeThreshold <= SlabSize,
                "The SizeThreshold must be at most the SlabSize to ensure "
                "that objects larger than a slab go into their own memory "
                "allocation.");
  static_assert(GrowthDelay > 0,
                "GrowthDelay must be at least 1 which already increases the"
                "slab size after each allocated slab.");
  static_assert(MinAlign > 0 && (MinAlign & (MinAlign - 1)) == 0,
                "MinAlign must be a power of two");
  static_assert(MinAlign <= alignof(std::max_align_t),
                "MinAlign must not exceed the alignment of fresh slabs");
 
  BumpPtrAllocatorImpl() = default;
 
  template <typename T>
  BumpPtrAllocatorImpl(T &&Allocator)
      : AllocTy(std::forward<T &&>(Allocator)) {}
 
  // Manually implement a move constructor as we must clear the old allocator's
  // slabs as a matter of correctness.
  BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
      : AllocTy(std::move(Old.getAllocator())), CurPtr(Old.CurPtr),
        EndSentinel(Old.EndSentinel), Slabs(std::move(Old.Slabs)),
        CustomSizedSlabs(std::move(Old.CustomSizedSlabs)) {
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
    RedZoneSize = Old.RedZoneSize;
#endif
    Old.CurPtr = nullptr;
    Old.EndSentinel = 0;
    Old.Slabs.clear();
    Old.CustomSizedSlabs.clear();
  }
 
  ~BumpPtrAllocatorImpl() {
    DeallocateSlabs(Slabs.begin(), Slabs.end());
    DeallocateCustomSizedSlabs();
  }
 
  BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) {
    DeallocateSlabs(Slabs.begin(), Slabs.end());
    DeallocateCustomSizedSlabs();
 
    CurPtr = RHS.CurPtr;
    EndSentinel = RHS.EndSentinel;
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
    RedZoneSize = RHS.RedZoneSize;
#endif
    Slabs = std::move(RHS.Slabs);
    CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
    AllocTy::operator=(std::move(RHS.getAllocator()));
 
    RHS.CurPtr = nullptr;
    RHS.EndSentinel = 0;
    RHS.Slabs.clear();
    RHS.CustomSizedSlabs.clear();
    return *this;
  }
 
  /// Deallocate all but the current slab and reset the current pointer
  /// to the beginning of it, freeing all memory allocated so far.
  void Reset() {
    // Deallocate all but the first slab, and deallocate all custom-sized slabs.
    DeallocateCustomSizedSlabs();
    CustomSizedSlabs.clear();
 
    if (Slabs.empty())
      return;
 
    // Reset the state.
    CurPtr = (char *)Slabs.front();
    EndSentinel = uintptr_t(CurPtr) + SlabSize + 1;
 
    __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
    DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
    Slabs.erase(std::next(Slabs.begin()), Slabs.end());
  }
 
  /// Allocate space at the specified alignment.
  // This method is *not* marked noalias, because
  // SpecificBumpPtrAllocator::DestroyAll() loops over all allocations, and
  // that loop is not based on the Allocate() return value.
  //
  // Allocate(0, N) is valid, it returns a non-null pointer (which should not
  // be dereferenced).
  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, Align Alignment) {
    size_t SizeToAllocate = Size;
#if LLVM_ADDRESS_SANITIZER_BUILD && LLVM_ENABLE_ABI_BREAKING_CHECKS
    // Add trailing bytes as a "red zone" under ASan. RedZoneSize only exists
    // when both conditions are true.
    SizeToAllocate += RedZoneSize;
#endif
    SizeToAllocate = alignToPowerOf2(SizeToAllocate, MinAlign);
 
    // CurPtr is already MinAlign-aligned, so only a stricter request realigns.
    uintptr_t AlignedPtr = uintptr_t(CurPtr);
    if (Alignment.value() > MinAlign)
      AlignedPtr = alignAddr(CurPtr, Alignment);
    uintptr_t AllocEndPtr = AlignedPtr + SizeToAllocate;
    assert(AllocEndPtr >= uintptr_t(CurPtr) &&
           "Alignment + Size must not overflow");
 
    // Check if we have enough space. `EndSentinel` is 0 for an empty allocator,
    // so this also rejects a null CurPtr when `SizeToAllocate` is 0.
    if (LLVM_LIKELY(AllocEndPtr < EndSentinel)) {
      CurPtr = reinterpret_cast<char *>(AllocEndPtr);
      // Update the allocation point of this memory block in MemorySanitizer.
      // Without this, MemorySanitizer messages for values originated from here
      // will point to the allocation of the entire slab.
      __msan_allocated_memory(reinterpret_cast<char *>(AlignedPtr), Size);
      // Similarly, tell ASan about this space.
      __asan_unpoison_memory_region(reinterpret_cast<char *>(AlignedPtr), Size);
      return reinterpret_cast<char *>(AlignedPtr);
    }
 
    return AllocateSlow(Size, SizeToAllocate, Alignment);
  }
 
  LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_NOINLINE void *
  AllocateSlow(size_t Size, size_t SizeToAllocate, Align Alignment) {
    // If Size is really big, allocate a separate slab for it.
    size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
    if (PaddedSize > SizeThreshold) {
      void *NewSlab =
          this->getAllocator().Allocate(PaddedSize, alignof(std::max_align_t));
      // We own the new slab and don't want anyone reading anyting other than
      // pieces returned from this method.  So poison the whole slab.
      __asan_poison_memory_region(NewSlab, PaddedSize);
      CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));
 
      uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
      assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize);
      char *AlignedPtr = (char*)AlignedAddr;
      __msan_allocated_memory(AlignedPtr, Size);
      __asan_unpoison_memory_region(AlignedPtr, Size);
      return AlignedPtr;
    }
 
    // Otherwise, start a new slab and try again.
    StartNewSlab();
    uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
    assert(AlignedAddr + SizeToAllocate < EndSentinel &&
           "Unable to allocate memory!");
    char *AlignedPtr = (char*)AlignedAddr;
    CurPtr = AlignedPtr + SizeToAllocate;
    __msan_allocated_memory(AlignedPtr, Size);
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }
 
  inline LLVM_ATTRIBUTE_RETURNS_NONNULL void *
  Allocate(size_t Size, size_t Alignment) {
    assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.");
    return Allocate(Size, Align(Alignment));
  }
 
  // Pull in base class overloads.
  using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;
 
  // Bump pointer allocators are expected to never free their storage; and
  // clients expect pointers to remain valid for non-dereferencing uses even
  // after deallocation.
  void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
    __asan_poison_memory_region(Ptr, Size);
  }
 
  // Pull in base class overloads.
  using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;
 
  size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }
 
  /// \return An index uniquely and reproducibly identifying
  /// an input pointer \p Ptr in the given allocator.
  /// The returned value is negative iff the object is inside a custom-size
  /// slab.
  /// Returns an empty optional if the pointer is not found in the allocator.
  std::optional<int64_t> identifyObject(const void *Ptr) {
    const char *P = static_cast<const char *>(Ptr);
    int64_t InSlabIdx = 0;
    for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) {
      const char *S = static_cast<const char *>(Slabs[Idx]);
      if (P >= S && P < S + computeSlabSize(Idx))
        return InSlabIdx + static_cast<int64_t>(P - S);
      InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx));
    }
 
    // Use negative index to denote custom sized slabs.
    int64_t InCustomSizedSlabIdx = -1;
    for (const auto &Slab : CustomSizedSlabs) {
      const char *S = static_cast<const char *>(Slab.first);
      size_t Size = Slab.second;
      if (P >= S && P < S + Size)
        return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
      InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
    }
    return std::nullopt;
  }
 
  /// A wrapper around identifyObject that additionally asserts that
  /// the object is indeed within the allocator.
  /// \return An index uniquely and reproducibly identifying
  /// an input pointer \p Ptr in the given allocator.
  int64_t identifyKnownObject(const void *Ptr) {
    std::optional<int64_t> Out = identifyObject(Ptr);
    assert(Out && "Wrong allocator used");
    return *Out;
  }
 
  /// A wrapper around identifyKnownObject. Accepts type information
  /// about the object and produces a smaller identifier by relying on
  /// the alignment information. Note that sub-classes may have different
  /// alignment, so the most base class should be passed as template parameter
  /// in order to obtain correct results. For that reason automatic template
  /// parameter deduction is disabled.
  /// \return An index uniquely and reproducibly identifying
  /// an input pointer \p Ptr in the given allocator. This identifier is
  /// different from the ones produced by identifyObject and
  /// identifyAlignedObject.
  template <typename T>
  int64_t identifyKnownAlignedObject(const void *Ptr) {
    int64_t Out = identifyKnownObject(Ptr);
    assert(Out % alignof(T) == 0 && "Wrong alignment information");
    return Out / alignof(T);
  }
 
  size_t getTotalMemory() const {
    size_t TotalMemory = 0;
    for (auto I = Slabs.begin(), E = Slabs.end(); I != E; ++I)
      TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
    for (const auto &PtrAndSize : CustomSizedSlabs)
      TotalMemory += PtrAndSize.second;
    return TotalMemory;
  }
 
  void setRedZoneSize([[maybe_unused]] size_t NewSize) {
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
    RedZoneSize = NewSize;
#endif
  }
 
  void PrintStats() const {
    detail::printBumpPtrAllocatorStats(Slabs.size(), getTotalMemory());
  }
 
private:
  /// The current pointer into the current slab.
  ///
  /// This points to the next free byte in the slab.
  char *CurPtr = nullptr;
 
  /// One past the slab end (0 when there is no slab). +1 is so that the fast
  /// path condition also rejects a empty allocator with a 0-size allocation.
  uintptr_t EndSentinel = 0;
 
  /// The slabs allocated so far.
  SmallVector<void *, 4> Slabs;
 
  /// Custom-sized slabs allocated for too-large allocation requests.
  SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;
 
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
  /// The number of bytes to put between allocations when running under a
  /// sanitizer.
  size_t RedZoneSize = 1;
#endif
 
  static size_t computeSlabSize(unsigned SlabIdx) {
    // Scale the actual allocated slab size based on the number of slabs
    // allocated. Every GrowthDelay slabs allocated, we double
    // the allocated size to reduce allocation frequency, but saturate at
    // multiplying the slab size by 2^30.
    return SlabSize *
           ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay));
  }
 
  /// Allocate a new slab and move the bump pointers over into the new
  /// slab, modifying CurPtr and EndSentinel.
  void StartNewSlab() {
    size_t AllocatedSlabSize = computeSlabSize(Slabs.size());
 
    void *NewSlab = this->getAllocator().Allocate(AllocatedSlabSize,
                                                  alignof(std::max_align_t));
    // We own the new slab and don't want anyone reading anything other than
    // pieces returned from this method.  So poison the whole slab.
    __asan_poison_memory_region(NewSlab, AllocatedSlabSize);
 
    Slabs.push_back(NewSlab);
    CurPtr = (char *)(NewSlab);
    EndSentinel = uintptr_t(NewSlab) + AllocatedSlabSize + 1;
  }
 
  /// Deallocate a sequence of slabs.
  void DeallocateSlabs(SmallVectorImpl<void *>::iterator I,
                       SmallVectorImpl<void *>::iterator E) {
    for (; I != E; ++I) {
      size_t AllocatedSlabSize =
          computeSlabSize(std::distance(Slabs.begin(), I));
      this->getAllocator().Deallocate(*I, AllocatedSlabSize,
                                      alignof(std::max_align_t));
    }
  }
 
  /// Deallocate all memory for custom sized slabs.
  void DeallocateCustomSizedSlabs() {
    for (auto &PtrAndSize : CustomSizedSlabs) {
      void *Ptr = PtrAndSize.first;
      size_t Size = PtrAndSize.second;
      this->getAllocator().Deallocate(Ptr, Size, alignof(std::max_align_t));
    }
  }
 
  template <typename T> friend class SpecificBumpPtrAllocator;
};
 
/// The standard BumpPtrAllocator which just uses the default template
/// parameters.
using BumpPtrAllocator = BumpPtrAllocatorImpl<>;
 
/// A BumpPtrAllocator that allows only elements of a specific type to be
/// allocated.
///
/// This allows calling the destructor in DestroyAll() and when the allocator is
/// destroyed.
template <typename T> class SpecificBumpPtrAllocator {
  // DestroyAll() walks objects at a fixed sizeof(T) stride, so it needs tight
  // packing: MinAlign=1 disables the size rounding. (alignof(T) would pack just
  // as tightly and reuse the default instantiation, but T may be incomplete
  // here, e.g. SpecificBumpPtrAllocator<MCSectionELF>.)
  using BumpPtrAllocatorTy =
      BumpPtrAllocatorImpl<MallocAllocator, 4096, 4096, 128, /*MinAlign=*/1>;
  BumpPtrAllocatorTy Allocator;
 
public:
  SpecificBumpPtrAllocator() {
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
    // it can't have red zones between allocations.
    Allocator.setRedZoneSize(0);
  }
  SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
      : Allocator(std::move(Old.Allocator)) {}
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
 
  SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
    Allocator = std::move(RHS.Allocator);
    return *this;
  }
 
  /// Call the destructor of each allocated object and deallocate all but the
  /// current slab and reset the current pointer to the beginning of it, freeing
  /// all memory allocated so far.
  void DestroyAll() {
    auto DestroyElements = [](char *Begin, char *End) {
      assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
        reinterpret_cast<T *>(Ptr)->~T();
    };
 
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
         ++I) {
      size_t AllocatedSlabSize = BumpPtrAllocatorTy::computeSlabSize(
          std::distance(Allocator.Slabs.begin(), I));
      char *Begin = (char *)alignAddr(*I, Align::Of<T>());
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                               : (char *)*I + AllocatedSlabSize;
 
      DestroyElements(Begin, End);
    }
 
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
      void *Ptr = PtrAndSize.first;
      size_t Size = PtrAndSize.second;
      DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
                      (char *)Ptr + Size);
    }
 
    Allocator.Reset();
  }
 
  /// Allocate space for an array of objects without constructing them.
  T *Allocate(size_t num = 1) {
    // Slabs are max_align_t-aligned and every size is a multiple of alignof(T),
    // so the bump pointer is already alignof(T)-aligned. Request alignment 1 so
    // the fast path skips realigning CurPtr; over-aligned T still needs it.
    if constexpr (alignof(T) <= alignof(std::max_align_t))
      return static_cast<T *>(Allocator.Allocate(num * sizeof(T), Align()));
    return Allocator.Allocate<T>(num);
  }
 
  /// \return An index uniquely and reproducibly identifying
  /// an input pointer \p Ptr in the given allocator.
  /// Returns an empty optional if the pointer is not found in the allocator.
  std::optional<int64_t> identifyObject(const void *Ptr) {
    return Allocator.identifyObject(Ptr);
  }
};
 
} // end namespace llvm
 
template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
          size_t GrowthDelay, size_t MinAlign>
void *
operator new(size_t Size,
             llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
                                        GrowthDelay, MinAlign> &Allocator) {
  return Allocator.Allocate(
      Size, std::min(llvm::bit_ceil(Size), alignof(std::max_align_t)));
}
 
template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
          size_t GrowthDelay, size_t MinAlign>
void operator delete(
    void *, llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
                                       GrowthDelay, MinAlign> &) {}
 
#endif // LLVM_SUPPORT_ALLOCATOR_H