chunk_allocator.h

// Copyright 2026 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <tuple>
 
#include "pw_allocator/allocator.h"
#include "pw_allocator/capability.h"
#include "pw_allocator/internal/control_block.h"
#include "pw_allocator/layout.h"
#include "pw_assert/assert.h"
#include "pw_bytes/span.h"
#include "pw_containers/dynamic_vector.h"
#include "pw_containers/storage.h"
#include "pw_multibuf/v1_adapter/chunk.h"
#include "pw_preprocessor/compiler.h"
#include "pw_result/result.h"
 
namespace pw::multibuf::v1_adapter::internal {
 
 
class ChunkAllocator : public Allocator {
 public:
  ~ChunkAllocator() override = default;
 
  constexpr Allocator& metadata_allocator() const {
    return metadata_allocator_;
  }
 
  constexpr size_t alignment() const { return 1u << alignment_log2_; }
 
  constexpr size_t available() const { return available_; }
 
  constexpr ByteSpan buffer() const { return buffer_; }
 
  std::optional<OwnedChunk> AllocateChunk(size_t min_size, size_t desired_size);
 
  std::optional<OwnedChunk> AllocateChunk(size_t size) {
    return AllocateChunk(size, size);
  }
 
 protected:
  using ControlBlock = allocator::internal::ControlBlock;
 
  // A compact representation of a span that may be allocated or free.
  PW_PACKED(struct) Region {
    std::byte* data;
    uint32_t size : 31;
    uint32_t free : 1;
 
    constexpr Region() : data(nullptr), size(0), free(true) {}
  };
 
  ChunkAllocator(Allocator& metadata_allocator, size_t alignment);
 
  constexpr size_t num_allocations() const {
    return static_cast<size_t>(num_allocations_);
  }
 
  void SetRegion(ByteSpan region);
 
 protected:
  void* DoAllocate(allocator::Layout layout) override;
 
  void DoDeallocate(void* ptr) override;
 
  Result<Layout> DoGetInfo(InfoType info_type, const void* ptr) const override;
 
  virtual Region* AllocateRegion(size_t min_size, size_t desired_size) = 0;
 
  virtual size_t TryDeallocateRegion(void* ptr) = 0;
 
 private:
  Allocator& metadata_allocator_;
 
  ByteSpan buffer_;
 
  uint32_t available_;
 
  uint16_t num_allocations_ = 0;
 
  uint8_t alignment_log2_;
};
 
class SingleChunkAllocator : public ChunkAllocator {
 public:
  explicit SingleChunkAllocator(Allocator& metadata_allocator);
 
  using ChunkAllocator::SetRegion;
 
 protected:
  constexpr bool control_block_free() const { return control_block_free_; }
 
  void DeallocateControlBlock(void* ptr);
 
  void* DoAllocate(Layout layout) override;
 
  void DoDeallocate(void* ptr) override;
 
  Region* AllocateRegion(size_t min_size, size_t desired_size) override;
 
  size_t TryDeallocateRegion(void* ptr) override;
 
  virtual void Destroy() {}
 
 private:
  Region region_;
 
  bool control_block_free_ = true;
 
  containers::StorageFor<ControlBlock> control_block_;
};
 
 
}  // namespace pw::multibuf::v1_adapter::internal