mtcore::Allocator Struct Reference

Represents a memory allocator Exact behavior depends on the underlying VTable used Should use the a_* methods for working with an allocator. More...

#include <alloc.hpp>

Collaboration diagram for mtcore::Allocator:

Classes
struct	VTable
	V-Table for implementing your own allocator Each allocator has state, some of which is standardized (e.g. More...

Public Member Functions
Result< void, AllocatorError >	deinit ()
	De-initializes a memory allocator.
Result< void *, AllocationError >	alloc (size_t bytes)
	Allocates some block of memory with an allocator May fail.
template<typename T>
Result< Slice< T >, AllocationError >	create_many (size_t count=1)
	Allocates some block of memory with an allocator with a known type Will call default constructor on the memory block.
template<typename T, typename... Args>
Result< T *, AllocationError >	create (Args... args)
	Allocates some block of memory with an allocator with a known type Will pass arguments to the constructor call for the element May fail.
Result< void *, AllocationError >	realloc (void *ptr, size_t newBytes)
	Attempts to reallocate a block of memory to either shrink it or grow it.
template<typename T>
void	free (T *&ptr)
	Marks a block of memory as "free-able" May or may not immediately deallocate memory, depending on what the allocator does Also sets the passed in pointer to nullptr;.
template<typename T>
void	destroy (T *&ptr)
	Destroys an object allocated by this allocator by calling the destructor and freeing memory.
template<typename T>
void	destroy_many (Slice< T > s)
	Destroys objects allocated by this allocator by calling the destructors and freeing memory.

Public Attributes
const VTable *	vtable = nullptr
	VTable to allocation-related methods.
void *	state = nullptr
	Internal state for the allocator.

Detailed Description

Represents a memory allocator Exact behavior depends on the underlying VTable used Should use the a_* methods for working with an allocator.

Definition at line 72 of file core/mtcore/alloc.hpp.

Member Function Documentation

alloc()

Result< void *, AllocationError > mtcore::Allocator::alloc ( size_t bytes )

nodiscard

Allocates some block of memory with an allocator May fail.

On failure, AllocRes.type will be FAIL, and ptr will be nullptr

Parameters

bytes

Number of bytes to allocate

Returns

Returns an allocation Result containing allocated bytes

create()

template<typename T, typename... Args>

Result< T *, AllocationError > mtcore::Allocator::create ( Args... args )

inlinenodiscard

Allocates some block of memory with an allocator with a known type Will pass arguments to the constructor call for the element May fail.

On failure, AllocRes.type will be FAIL, and Slice will be empty

Template Parameters

T	Type of object to allocate (MUST be default constructible)

Parameters

args	Constructor arguments

Returns

A typed allocation Result containing a Slice of allocated objects

Definition at line 196 of file core/mtcore/alloc.hpp.

                                                                    {
      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);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

create_many()

template<typename T>

Result< Slice< T >, AllocationError > mtcore::Allocator::create_many ( size_t count = 1 )

inlinenodiscard

Allocates some block of memory with an allocator with a known type Will call default constructor on the memory block.

May fail. On failure, AllocRes.type will be FAIL, and Slice will be empty

Template Parameters

T	Type of object to allocate (MUST be default constructible)

Parameters

count

Number of objects to allocate

Returns

A typed allocation Result containing a Slice of allocated objects

Definition at line 171 of file core/mtcore/alloc.hpp.

                                                                                  {
      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);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

deinit()

Result< void, AllocatorError > mtcore::Allocator::deinit ( )

nodiscard

De-initializes a memory allocator.

Assume that it makes the allocator invalid to use for future use (unless otherwise stated by the creator)

Can check for memory leaks and report them via ErrCode

Returns

Error code if anything goes wrong during initialization

destroy()

template<typename T>

void mtcore::Allocator::destroy

(

T *&

ptr

)

Destroys an object allocated by this allocator by calling the destructor and freeing memory.

Template Parameters

T	Type of element to destroy, will call destructor

Parameters

ptr	Pointer to element to destroy, will call destructor

Definition at line 466 of file core/mtcore/alloc.hpp.

                                 {
    if (ptr == nullptr) {
      return;
    }
 
    // call deinit if it's there
    impl::alloc::deinit(*this, *ptr);
 
    // call destructor
    ptr->~T();
    this->free(ptr);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_many()

template<typename T>

void mtcore::Allocator::destroy_many

(

Slice< T >

s

)

Destroys objects allocated by this allocator by calling the destructors and freeing memory.

Template Parameters

T	Type of element to destroy, will call destructor

Parameters

s	Slice of elements to destroy, will call destructor on each

Definition at line 480 of file core/mtcore/alloc.hpp.

                                         {
    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);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

free()

template<typename T>

void mtcore::Allocator::free ( T *& ptr )

inline

Marks a block of memory as "free-able" May or may not immediately deallocate memory, depending on what the allocator does Also sets the passed in pointer to nullptr;.

Parameters

ptr	Pointer to memory to free

Definition at line 249 of file core/mtcore/alloc.hpp.

                       {
      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;
    }

Here is the caller graph for this function:

realloc()

Result< void *, AllocationError > mtcore::Allocator::realloc ( void * ptr, size_t newBytes )

nodiscard

Attempts to reallocate a block of memory to either shrink it or grow it.

If the operation cannot be done in place, the allocator may allocate a new block of memory and copy the bytes over May fail. On failure, AllocRes.type will be FAIL and ptr will be nullptr

NOTE: A failure here does NOT mean there's no more memory available, only that the allocator cannot reallocate blocks This may happen if, for example, the allocator does NOT track individual allocations and therefore cannot reallocate blocks This may happen with simple arena allocators, for example

Parameters

ptr	Pointer to existing memory allocated by this allocator
newBytes	Number of new bytes to have for the allocator (bigger = grow, smaller = shrink)

Returns

On success, pointer to new memory, on failure nullptr. On success, old memory is freed, on failure old memory is preserved.

Member Data Documentation

state

void* mtcore::Allocator::state = nullptr

Internal state for the allocator.

Definition at line 140 of file core/mtcore/alloc.hpp.

vtable

const VTable* mtcore::Allocator::vtable = nullptr

VTable to allocation-related methods.

Do not use directly

Definition at line 137 of file core/mtcore/alloc.hpp.

---

The documentation for this struct was generated from the following file:

• core/mtcore/alloc.hpp