duckdb::FileBuffer Class Reference

The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle. More...

#include <duckdb.hpp>

Inheritance diagram for duckdb::FileBuffer:

Collaboration diagram for duckdb::FileBuffer:

Classes
struct	MemoryRequirement

Public Member Functions
	FileBuffer (BlockAllocator &allocator, FileBufferType type, uint64_t user_size, idx_t block_header_size)
	FileBuffer (BlockAllocator &allocator, FileBufferType type, BlockManager &block_manager)
	FileBuffer (FileBuffer &source, FileBufferType type, idx_t block_header_size)
void	Read (QueryContext context, FileHandle &handle, uint64_t location)
	Read into the FileBuffer from the location.
void	Write (QueryContext context, FileHandle &handle, const uint64_t location)
	Write the FileBuffer to the location.
void	Clear ()
FileBufferType	GetBufferType () const
void	Resize (uint64_t user_size, idx_t block_header_size)
void	Resize (BlockManager &block_manager)
idx_t	GetHeaderSize () const
uint64_t	AllocSize () const
uint64_t	Size () const
data_ptr_t	InternalBuffer ()
MemoryRequirement	CalculateMemory (uint64_t user_size, uint64_t block_header_size) const
void	Initialize (DebugInitialize info)

Public Attributes
BlockAllocator &	allocator
data_ptr_t	buffer
	The buffer that users can write to.
uint64_t	size

Protected Member Functions
void	ReallocBuffer (idx_t new_size)
void	Init ()

Protected Attributes
FileBufferType	type
	The type of the buffer.
data_ptr_t	internal_buffer
uint64_t	internal_size

Private Member Functions
void	ResizeInternal (uint64_t user_size, uint64_t block_header_size)

Detailed Description

The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle.

Constructor & Destructor Documentation

FileBuffer() [1/3]

duckdb::FileBuffer::FileBuffer	(	BlockAllocator &	allocator,
		FileBufferType	type,
		uint64_t	user_size,
		idx_t	block_header_size
	)

Allocates a buffer of the specified size, with room for additional header bytes (typically 8 bytes). On return, this->AllocSize() >= this->size >= user_size. Our allocation size will always be page-aligned, which is necessary to support DIRECT_IO

    : allocator(allocator), type(type) {
    Init();
    if (user_size) {
        ResizeInternal(user_size, block_header_size);
    }
}

FileBuffer() [2/3]

duckdb::FileBuffer::FileBuffer	(	BlockAllocator &	allocator,
		FileBufferType	type,
		BlockManager &	block_manager
	)

    : allocator(allocator), type(type) {
    Init();
    Resize(block_manager);
}

FileBuffer() [3/3]

duckdb::FileBuffer::FileBuffer	(	FileBuffer &	source,
		FileBufferType	type,
		idx_t	block_header_size
	)

    : allocator(source.allocator), type(type_p) {
    // take over the structures of the source buffer
    buffer = source.internal_buffer + block_header_size;
    size = source.internal_size - block_header_size;
    internal_buffer = source.internal_buffer;
    internal_size = source.internal_size;
 
    source.Init();
}

~FileBuffer()

duckdb::FileBuffer::~FileBuffer ( )

virtual

                        {
    if (!internal_buffer) {
        return;
    }
    allocator.FreeData(internal_buffer, internal_size);
}

Member Function Documentation

Read()

void duckdb::FileBuffer::Read	(	QueryContext	context,
		FileHandle &	handle,
		uint64_t	location
	)

Read into the FileBuffer from the location.

                                                                                 {
    D_ASSERT(type != FileBufferType::TINY_BUFFER);
    handle.Read(context, internal_buffer, internal_size, location);
}

Write()

void duckdb::FileBuffer::Write	(	QueryContext	context,
		FileHandle &	handle,
		const uint64_t	location
	)

Write the FileBuffer to the location.

                                                                                        {
    D_ASSERT(type != FileBufferType::TINY_BUFFER);
    handle.Write(context, internal_buffer, internal_size, location);
}

Clear()

void duckdb::FileBuffer::Clear

(

)

                       {
    memset(internal_buffer, 0, internal_size);
}

GetBufferType()

FileBufferType duckdb::FileBuffer::GetBufferType ( ) const

inline

                                         {
        return type;
    }

Resize() [1/2]

void duckdb::FileBuffer::Resize	(	uint64_t	user_size,
		idx_t	block_header_size
	)

                                                                  {
    ResizeInternal(new_size, block_header_size);
}

Resize() [2/2]

void duckdb::FileBuffer::Resize

(

BlockManager &

block_manager

)

                                                   {
    ResizeInternal(block_manager.GetBlockSize(), block_manager.GetBlockHeaderSize());
}

GetHeaderSize()

idx_t duckdb::FileBuffer::GetHeaderSize ( ) const

inline

                                {
        return internal_size - size;
    }

AllocSize()

uint64_t duckdb::FileBuffer::AllocSize ( ) const

inline

                               {
        return internal_size;
    }

Size()

uint64_t duckdb::FileBuffer::Size ( ) const

inline

                          {
        return size;
    }

InternalBuffer()

data_ptr_t duckdb::FileBuffer::InternalBuffer ( )

inline

                                {
        return internal_buffer;
    }

CalculateMemory()

FileBuffer::MemoryRequirement duckdb::FileBuffer::CalculateMemory	(	uint64_t	user_size,
		uint64_t	block_header_size
	)		const

                                                                                                            {
    FileBuffer::MemoryRequirement result;
    if (type == FileBufferType::TINY_BUFFER) {
        // We never do IO on tiny buffers, so there's no need to add a header or sector-align.
        result.header_size = 0;
        result.alloc_size = user_size;
    } else {
        result.header_size = block_header_size;
        result.alloc_size = AlignValue<idx_t, Storage::SECTOR_SIZE>(result.header_size + user_size);
    }
    return result;
}

Initialize()

void duckdb::FileBuffer::Initialize

(

DebugInitialize

info

)

                                                      {
    if (initialize == DebugInitialize::NO_INITIALIZE) {
        return;
    }
    uint8_t value = initialize == DebugInitialize::DEBUG_ZERO_INITIALIZE ? 0 : 0xFF;
    memset(internal_buffer, value, internal_size);
}

ReallocBuffer()

void duckdb::FileBuffer::ReallocBuffer ( idx_t  new_size )

protected

                                             {
    data_ptr_t new_buffer;
    if (internal_buffer) {
        new_buffer = allocator.ReallocateData(internal_buffer, internal_size, new_size);
    } else {
        new_buffer = allocator.AllocateData(new_size);
    }
 
    // FIXME: should we throw one of our exceptions here?
    if (!new_buffer) {
        throw std::bad_alloc();
    }
 
    internal_buffer = new_buffer;
    internal_size = new_size;
 
    // The caller must update these.
    buffer = nullptr;
    size = 0;
}

Init()

void duckdb::FileBuffer::Init ( )

protected

                      {
    buffer = nullptr;
    size = 0;
    internal_buffer = nullptr;
    internal_size = 0;
}

ResizeInternal()

void duckdb::FileBuffer::ResizeInternal ( uint64_t  user_size, uint64_t  block_header_size  )

private

                                                                             {
    auto req = CalculateMemory(new_size, block_header_size);
    ReallocBuffer(req.alloc_size);
 
    if (new_size > 0) {
        buffer = internal_buffer + req.header_size;
        size = internal_size - req.header_size;
    }
}

Member Data Documentation

size

uint64_t duckdb::FileBuffer::size

The user-facing size of the buffer. This is equivalent to internal_size - block_header_size.

internal_buffer

data_ptr_t duckdb::FileBuffer::internal_buffer

protected

The pointer to the internal buffer that will be read from or written to. This includes the buffer header.

internal_size

uint64_t duckdb::FileBuffer::internal_size

protected

The aligned size as passed to the constructor. This is the size that is read from or written to disk.

---

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

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