core/mtcore/alloc.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
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
 
   http://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
 
#ifndef MTCORE_ALLOC_HPP
#define MTCORE_ALLOC_HPP
 
#include <algorithm>
#include <unordered_map>
 
#include "mtcore/colls/result.hpp"
#include "mtcore/colls/slice.hpp"
#include "mtcore/core.hpp"
#include "mtcore/traits.hpp"

namespace mtcore {

  enum class AllocationError { ALLOCATION_FAILED };

  enum class AllocatorError {
    MEMORY_LEAK_DETECTED,
  };
 
  namespace impl::alloc {
    template<typename T>
    struct Deiniter;
  }

  struct Allocator {
    struct VTable {
      void *(*alloc)(void *state, size_t bytes);

      void *(*realloc)(void *state, void *ptr, size_t bytes);

      void (*free)(void *state, void *ptr);

      Result<void, AllocatorError> (*deinit)(void *state);
    };

    const VTable *vtable = nullptr;

    void *state = nullptr;

    [[nodiscard]] Result<void, AllocatorError> deinit();

    [[nodiscard]] Result<void *, AllocationError> alloc(size_t bytes);

    template<typename T>
    [[nodiscard]] Result<Slice<T>, AllocationError> create_many(size_t count = 1) {
      ensure(count, "CANNOT ALLOC 0 ELEMENTS!");
      ensure(vtable, "DEREFERENCING NULL VTABLE! ENSURE ALLOCATOR HAS NOT BEEN "
                     "DEINITIALIZED!");
      ensure(vtable->alloc, "VTABLE CORRUPTED, MISSING ALLOC");
      auto s = Slice<T>{static_cast<T *>(vtable->alloc(state, sizeof(T) * count)), count};
      if (s.head) {
        for (size_t i = 0; i < count; ++i) {
          s[i] = T{};
        }
        return success(s);
      }
      return error(AllocationError::ALLOCATION_FAILED);
    }

    template<typename T, typename... Args>
    [[nodiscard]] Result<T *, AllocationError> create(Args... args) {
      ensure(vtable, "DEREFERENCING NULL VTABLE! ENSURE ALLOCATOR HAS NOT BEEN "
                     "DEINITIALIZED!");
      ensure(vtable->alloc, "VTABLE CORRUPTED, MISSING ALLOC");
      auto res = static_cast<T *>(vtable->alloc(state, sizeof(T)));
      if (res) {
        if constexpr (std::is_copy_assignable<T>::value) {
          *res = T{args...};
        }
        else if constexpr (std::is_move_assignable<T>::value) {
          *res = std::move(T{args...});
        }
        else if constexpr (std::is_trivially_constructible_v<T> && is_initable<T, Args...>) {
          *res = T{};
          res->init(args...);
        }
        else {
          new (res) T(args...);
        }
        return success(res);
      }
      return error(AllocationError::ALLOCATION_FAILED);
    }

    [[nodiscard]] Result<void *, AllocationError> realloc(void *ptr, size_t newBytes);

    template<typename T>
    void free(T *&ptr) {
      ensure(vtable, "DEREFERENCING NULL VTABLE! ENSURE ALLOCATOR HAS NOT BEEN "
                     "DEINITIALIZED!");
 
      // no need to free nullptr
      if (ptr == nullptr) {
        return;
      }
 
      if (!vtable->free) {
        mtcore_warn("NO FREE ON ALLOCATOR! FREE IS A NO-OP!");
        return;
      }
      vtable->free(state, ptr);
 
      ptr = nullptr;
    }

    template<typename T>
    void destroy(T *&ptr);

    template<typename T>
    void destroy_many(Slice<T> s);
  };

  struct MallocAllocator {
    Allocator allocator() noexcept;
  };

  MallocAllocator malloc_alloc() noexcept;

  struct ThreadLocalDebugAllocator {
    size_t allocatedBytes = 0;
    i64 lastId            = 0;
#ifndef MTCORE_NO_STACKTRACE
    std::unordered_map<i64, cpptrace::stacktrace> trace = {};
#endif

    Allocator allocator() noexcept;
  };

  ThreadLocalDebugAllocator debug_alloc_thread_local() noexcept;

  struct ThreadLocalFixedBufferAllocator {
    Slice<u8> buff;

    Allocator allocator() noexcept;
  };

  ThreadLocalFixedBufferAllocator fixed_buff_thread_local(Slice<u8> bytes) noexcept;

  struct ThreadLocalFixedArenaAllocator {
    Slice<u8> buff;
    size_t offset = 0;

    Allocator allocator() noexcept;
  };

  ThreadLocalFixedArenaAllocator fixed_arena_thread_local(Slice<u8> bytes) noexcept;

  struct ThreadLocalDynamicArenaAllocator {
    Slice<u8> buff;
    Allocator *root       = nullptr;
    size_t arenaSizeHint  = 0;
    size_t arenaCountHint = 0;
    size_t offset         = 0;

    Allocator allocator() noexcept;
  };

  ThreadLocalDynamicArenaAllocator dynamic_arena_thread_local(Allocator *root, size_t elementSizeHint,
                                                              size_t elementCountHint) noexcept;
 
  namespace impl::alloc {
    template<typename T>
    struct Deiniter;
 
    template<AllocatorDeinit T>
    struct Deiniter<T> {
      void operator()(Allocator &alloc, T &t) { t.deinit(alloc); }
    };
 
    template<DefaultDeinit T>
    struct Deiniter<T> {
      void operator()(Allocator &, T &t) { t.deinit(); }
    };
 
    template<typename T>
    struct Deiniter {
      void operator()(Allocator &, T &) {}
    };
 
    template<typename T>
    void deinit(Allocator &alloc, T &t) {
      (Deiniter<T>{})(alloc, t);
    }
  }  // namespace impl::alloc
 
  template<typename T>
  void Allocator::destroy(T *&ptr) {
    if (ptr == nullptr) {
      return;
    }
 
    // call deinit if it's there
    impl::alloc::deinit(*this, *ptr);
 
    // call destructor
    ptr->~T();
    this->free(ptr);
  }
 
  template<typename T>
  void Allocator::destroy_many(Slice<T> s) {
    if (s.head == nullptr || s.len == 0) {
      return;
    }
 
    // call destructors & deinit
    for (size_t i = 0; i < s.len; ++i) {
      impl::alloc::deinit(*this, s[i]);
      s[i].~T();
    }
    this->free(s.head);
  }
}  // namespace mtcore
 
#endif