duckdb::Allocator Class Reference

Collaboration diagram for duckdb::Allocator:

Public Member Functions
DUCKDB_API	Allocator (allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p, reallocate_function_ptr_t reallocate_function_p, unique_ptr< PrivateAllocatorData > private_data)
Allocator &	operator= (Allocator &&allocator) noexcept=delete
DUCKDB_API data_ptr_t	AllocateData (idx_t size)
DUCKDB_API void	FreeData (data_ptr_t pointer, idx_t size)
DUCKDB_API data_ptr_t	ReallocateData (data_ptr_t pointer, idx_t old_size, idx_t new_size)
AllocatedData	Allocate (idx_t size)
PrivateAllocatorData *	GetPrivateData ()

Static Public Member Functions
static data_ptr_t	DefaultAllocate (PrivateAllocatorData *private_data, idx_t size)
static void	DefaultFree (PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size)
static data_ptr_t	DefaultReallocate (PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size, idx_t size)
static Allocator &	Get (ClientContext &context)
static Allocator &	Get (DatabaseInstance &db)
static Allocator &	Get (AttachedDatabase &db)
static DUCKDB_API Allocator &	DefaultAllocator ()
static DUCKDB_API shared_ptr< Allocator > &	DefaultAllocatorReference ()
static bool	SupportsFlush ()
static optional_idx	DecayDelay ()
static void	ThreadFlush (bool allocator_background_threads, idx_t threshold, idx_t thread_count)
static void	ThreadIdle ()
static void	FlushAll ()
static void	SetBackgroundThreads (bool enable)

Private Member Functions
bool	ShouldUseDebugInfo () const

Private Attributes
allocate_function_ptr_t	allocate_function
free_function_ptr_t	free_function
reallocate_function_ptr_t	reallocate_function
unique_ptr< PrivateAllocatorData >	private_data

Static Private Attributes
static constexpr const idx_t	MAXIMUM_ALLOC_SIZE = 281474976710656ULL

Constructor & Destructor Documentation

Allocator() [1/2]

duckdb::Allocator::Allocator

(

)

    : Allocator(Allocator::DefaultAllocate, Allocator::DefaultFree, Allocator::DefaultReallocate, nullptr) {
}

Allocator() [2/2]

duckdb::Allocator::Allocator	(	allocate_function_ptr_t	allocate_function_p,
		free_function_ptr_t	free_function_p,
		reallocate_function_ptr_t	reallocate_function_p,
		unique_ptr< PrivateAllocatorData >	private_data
	)

    : allocate_function(allocate_function_p), free_function(free_function_p),
      reallocate_function(reallocate_function_p), private_data(std::move(private_data_p)) {
    D_ASSERT(allocate_function);
    D_ASSERT(free_function);
    D_ASSERT(reallocate_function);
#ifdef DEBUG
    if (!private_data) {
        private_data = make_uniq<PrivateAllocatorData>();
    }
    private_data->debug_info = make_uniq<AllocatorDebugInfo>();
#endif
}

~Allocator()

duckdb::Allocator::~Allocator

(

)

                      {
}

Member Function Documentation

AllocateData()

data_ptr_t duckdb::Allocator::AllocateData

(

idx_t

size

)

                                             {
    D_ASSERT(size > 0);
    if (size >= MAXIMUM_ALLOC_SIZE) {
        D_ASSERT(false);
        throw InternalException("Requested allocation size of %llu is out of range - maximum allocation size is %llu",
                                size, MAXIMUM_ALLOC_SIZE);
    }
    auto result = allocate_function(private_data.get(), size);
#ifdef DEBUG
    if (ShouldUseDebugInfo()) {
        private_data->debug_info->AllocateData(result, size);
    }
#endif
    if (!result) {
        throw OutOfMemoryException("Failed to allocate block of %llu bytes (bad allocation)", size);
    }
    return result;
}

FreeData()

void duckdb::Allocator::FreeData	(	data_ptr_t	pointer,
		idx_t	size
	)

                                                       {
    if (!pointer) {
        return;
    }
    D_ASSERT(size > 0);
#ifdef DEBUG
    if (ShouldUseDebugInfo()) {
        private_data->debug_info->FreeData(pointer, size);
    }
#endif
    free_function(private_data.get(), pointer, size);
}

ReallocateData()

data_ptr_t duckdb::Allocator::ReallocateData	(	data_ptr_t	pointer,
		idx_t	old_size,
		idx_t	new_size
	)

                                                                                   {
    if (!pointer) {
        return nullptr;
    }
    if (size >= MAXIMUM_ALLOC_SIZE) {
        D_ASSERT(false);
        throw InternalException(
            "Requested re-allocation size of %llu is out of range - maximum allocation size is %llu", size,
            MAXIMUM_ALLOC_SIZE);
    }
    auto new_pointer = reallocate_function(private_data.get(), pointer, old_size, size);
#ifdef DEBUG
    if (ShouldUseDebugInfo()) {
        private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size);
    }
#endif
    if (!new_pointer) {
        throw OutOfMemoryException("Failed to re-allocate block of %llu bytes (bad allocation)", size);
    }
    return new_pointer;
}

Allocate()

AllocatedData duckdb::Allocator::Allocate ( idx_t  size )

inline

                                       {
        return AllocatedData(*this, AllocateData(size), size);
    }

DefaultAllocate()

data_ptr_t duckdb::Allocator::DefaultAllocate ( PrivateAllocatorData *  private_data, idx_t  size  )

static

                                                                                    {
#ifdef USE_JEMALLOC
    return JemallocExtension::Allocate(private_data, size);
#else
    auto default_allocate_result = malloc(size);
    if (!default_allocate_result) {
        throw std::bad_alloc();
    }
    return data_ptr_cast(default_allocate_result);
#endif
}

DefaultFree()

void duckdb::Allocator::DefaultFree ( PrivateAllocatorData *  private_data, data_ptr_t  pointer, idx_t  size  )

static

                                                                                              {
#ifdef USE_JEMALLOC
    JemallocExtension::Free(private_data, pointer, size);
#else
    free(pointer);
#endif
}

DefaultReallocate()

data_ptr_t duckdb::Allocator::DefaultReallocate ( PrivateAllocatorData *  private_data, data_ptr_t  pointer, idx_t  old_size, idx_t  size  )

static

                                                    {
#ifdef USE_JEMALLOC
    return JemallocExtension::Reallocate(private_data, pointer, old_size, size);
#else
    return data_ptr_cast(realloc(pointer, size));
#endif
}

GetPrivateData()

PrivateAllocatorData * duckdb::Allocator::GetPrivateData ( )

inline

                                           {
        return private_data.get();
    }

DefaultAllocator()

Allocator & duckdb::Allocator::DefaultAllocator ( )

static

                                       {
    return *DefaultAllocatorReference();
}

DefaultAllocatorReference()

shared_ptr< Allocator > & duckdb::Allocator::DefaultAllocatorReference ( )

static

                                                            {
    static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared_ptr<Allocator>();
    return DEFAULT_ALLOCATOR;
}

SupportsFlush()

bool duckdb::Allocator::SupportsFlush ( )

static

                              {
#if defined(USE_JEMALLOC) || defined(__GLIBC__)
    return true;
#else
    return false;
#endif
}

DecayDelay()

optional_idx duckdb::Allocator::DecayDelay ( )

static

                                   {
#ifdef USE_JEMALLOC
    return NumericCast<idx_t>(JemallocExtension::DecayDelay());
#else
    return optional_idx();
#endif
}

ThreadFlush()

void duckdb::Allocator::ThreadFlush ( bool  allocator_background_threads, idx_t  threshold, idx_t  thread_count  )

static

                                                                                                  {
#ifdef USE_JEMALLOC
    if (!allocator_background_threads) {
        JemallocExtension::ThreadFlush(threshold);
    }
#endif
    MallocTrim(thread_count * threshold);
}

ThreadIdle()

void duckdb::Allocator::ThreadIdle ( )

static

                           {
#ifdef USE_JEMALLOC
    JemallocExtension::ThreadIdle();
#endif
}

FlushAll()

void duckdb::Allocator::FlushAll ( )

static

                         {
#ifdef USE_JEMALLOC
    JemallocExtension::FlushAll();
#endif
    MallocTrim(0);
}

SetBackgroundThreads()

void duckdb::Allocator::SetBackgroundThreads ( bool  enable )

static

                                                {
#ifdef USE_JEMALLOC
    JemallocExtension::SetBackgroundThreads(enable);
#endif
}

ShouldUseDebugInfo()

bool duckdb::Allocator::ShouldUseDebugInfo ( ) const

inlineprivate

                                    {
        return private_data && private_data->free_type != AllocatorFreeType::DOES_NOT_REQUIRE_FREE &&
               private_data->debug_info;
    }

---

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

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp