third_party/pigweed/repo/pw_allocator/public/pw_allocator/freelist_heap.h

   1 // Copyright 2020 The Pigweed Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   4 // use this file except in compliance with the License. You may obtain a copy of
   5 // the License at
   6 //
   7 //     https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations under
  13 // the License.
  14
  15 #pragma once
  16
  17 #include <cstddef>
  18 #include <span>
  19
  20 #include "pw_allocator/block.h"
  21 #include "pw_allocator/freelist.h"
  22
  23 namespace pw::allocator {
  24
  25 class FreeListHeap {
  26  public:
  27   template <size_t N>
  28   friend class FreeListHeapBuffer;
  29   struct HeapStats {
  30     size_t total_bytes;
  31     size_t bytes_allocated;
  32     size_t cumulative_allocated;
  33     size_t cumulative_freed;
  34     size_t total_allocate_calls;
  35     size_t total_free_calls;
  36   };
  37   FreeListHeap(std::span<std::byte> region, FreeList& freelist);
  38
  39   void* Allocate(size_t size);
  40   void Free(void* ptr);
  41   void* Realloc(void* ptr, size_t size);
  42   void* Calloc(size_t num, size_t size);
  43
  44   void LogHeapStats();
  45
  46  private:
  47   std::span<std::byte> BlockToSpan(Block* block) {
  48     return std::span<std::byte>(block->UsableSpace(), block->InnerSize());
  49   }
  50
  51   void InvalidFreeCrash();
  52
  53   std::span<std::byte> region_;
  54   FreeList& freelist_;
  55   HeapStats heap_stats_;
  56 };
  57
  58 template <size_t N = 6>
  59 class FreeListHeapBuffer {
  60  public:
  61   static constexpr std::array<size_t, N> defaultBuckets{
  62       16, 32, 64, 128, 256, 512};
  63
  64   FreeListHeapBuffer(std::span<std::byte> region)
  65       : freelist_(defaultBuckets), heap_(region, freelist_) {}
  66
  67   void* Allocate(size_t size) { return heap_.Allocate(size); }
  68   void Free(void* ptr) { heap_.Free(ptr); }
  69   void* Realloc(void* ptr, size_t size) { return heap_.Realloc(ptr, size); }
  70   void* Calloc(size_t num, size_t size) { return heap_.Calloc(num, size); }
  71
  72   const FreeListHeap::HeapStats& heap_stats() const {
  73     return heap_.heap_stats_;
  74   };
  75
  76   void LogHeapStats() { heap_.LogHeapStats(); }
  77
  78  private:
  79   FreeListBuffer<N> freelist_;
  80   FreeListHeap heap_;
  81 };
  82
  83 }  // namespace pw::allocator