duckdb::ArenaAllocator Class Reference

Collaboration diagram for duckdb::ArenaAllocator:

Public Member Functions
DUCKDB_API	ArenaAllocator (Allocator &allocator, idx_t initial_capacity=ARENA_ALLOCATOR_INITIAL_CAPACITY)
data_ptr_t	Allocate (idx_t len)
DUCKDB_API data_ptr_t	Reallocate (data_ptr_t pointer, idx_t old_size, idx_t size)
DUCKDB_API data_ptr_t	AllocateAligned (idx_t size)
DUCKDB_API data_ptr_t	ReallocateAligned (data_ptr_t pointer, idx_t old_size, idx_t size)
DUCKDB_API void	AlignNext ()
	Increment the internal cursor (if required) so the next allocation is guaranteed to be aligned to 8 bytes.
DUCKDB_API void	ShrinkHead (idx_t shrink_size) const
DUCKDB_API void	Reset ()
	Resets the current head and destroys all previous arena chunks.
DUCKDB_API void	Destroy ()
DUCKDB_API void	Move (ArenaAllocator &allocator)
DUCKDB_API ArenaChunk *	GetHead ()
DUCKDB_API ArenaChunk *	GetTail ()
DUCKDB_API bool	IsEmpty () const
DUCKDB_API idx_t	SizeInBytes () const
	Get the total used size (not cached)
DUCKDB_API idx_t	AllocationSize () const
	Get the currently allocated size in bytes (cached, read from "allocated_size")
Allocator &	GetAllocator ()
	Returns an "Allocator" wrapper for this arena allocator.
template<class T , class... ARGS>
T *	Make (ARGS &&... args)
template<class T , class... ARGS>
arena_ptr< T >	MakePtr (ARGS &&... args)
template<class T , class... ARGS>
unsafe_arena_ptr< T >	MakeUnsafePtr (ARGS &&... args)
String	MakeString (const char *data, const size_t len)
String	MakeString (const std::string &data)

Static Public Attributes
static constexpr const idx_t	ARENA_ALLOCATOR_INITIAL_CAPACITY = 2048
static constexpr const idx_t	ARENA_ALLOCATOR_MAX_CAPACITY = 1ULL << 24ULL

Private Member Functions
void	AllocateNewBlock (idx_t min_size)

Private Attributes
Allocator &	allocator
	Internal allocator that is used by the arena allocator.
idx_t	initial_capacity
unsafe_unique_ptr< ArenaChunk >	head
ArenaChunk *	tail
Allocator	arena_allocator
	An allocator wrapper using this arena allocator.
idx_t	allocated_size = 0
	The total allocated size.

Member Function Documentation

Allocate()

data_ptr_t duckdb::ArenaAllocator::Allocate ( idx_t  len )

inline

                                   {
        D_ASSERT(!head || head->current_position <= head->maximum_size);
        if (!head || head->current_position + len > head->maximum_size) {
            AllocateNewBlock(len);
        }
        D_ASSERT(head->current_position + len <= head->maximum_size);
        auto result = head->data.get() + head->current_position;
        head->current_position += len;
        return result;
    }

ShrinkHead()

DUCKDB_API void duckdb::ArenaAllocator::ShrinkHead ( idx_t  shrink_size ) const

inline

This shrinks the LAST allocation that was made using the allocator Note that we can ONLY safely call this method if Allocate has been called previously with a size >= shrink_size

                                                        {
        D_ASSERT(head && head->current_position >= shrink_size);
        head->current_position -= shrink_size;
    }

GetAllocator()

Allocator & duckdb::ArenaAllocator::GetAllocator ( )

inline

Returns an "Allocator" wrapper for this arena allocator.

                              {
        return arena_allocator;
    }

Make()

template<class T , class... ARGS>

T * duckdb::ArenaAllocator::Make ( ARGS &&...  args )

inline

                             {
        auto mem = AllocateAligned(sizeof(T));
        return new (mem) T(std::forward<ARGS>(args)...);
    }

MakePtr()

template<class T , class... ARGS>

arena_ptr< T > duckdb::ArenaAllocator::MakePtr ( ARGS &&...  args )

inline

                                          {
        return arena_ptr<T>(Make<T>(std::forward<ARGS>(args)...));
    }

MakeUnsafePtr()

template<class T , class... ARGS>

unsafe_arena_ptr< T > duckdb::ArenaAllocator::MakeUnsafePtr ( ARGS &&...  args )

inline

                                                       {
        return unsafe_arena_ptr<T>(Make<T>(std::forward<ARGS>(args)...));
    }

MakeString() [1/2]

String duckdb::ArenaAllocator::MakeString ( const char *  data, const size_t  len  )

inline

                                                          {
        data_ptr_t mem = nullptr;
 
        D_ASSERT(len < NumericLimits<uint32_t>::Maximum());
        const auto size = static_cast<uint32_t>(len);
        if (!String::CanBeInlined(size)) {
            // If the string can't be inlined, we allocate it on the arena allocator
            mem = AllocateAligned(sizeof(char) * size + 1); // +1 for null terminator
            memcpy(mem, data, size);
            mem[size] = '\0';
        }
 
        return String::Reference(mem ? reinterpret_cast<char *>(mem) : data, size);
    }

MakeString() [2/2]

String duckdb::ArenaAllocator::MakeString ( const std::string &  data )

inline

                                             {
        return MakeString(data.c_str(), data.size());
    }

---

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

• external/duckdb/duckdb.hpp