duckdb::FixedSizeBuffer Class Reference

Collaboration diagram for duckdb::FixedSizeBuffer:

Public Member Functions
	FixedSizeBuffer (BlockManager &block_manager, MemoryTag memory_tag)
	Constructor for a new in-memory buffer.
	FixedSizeBuffer (BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size, const BlockPointer &block_pointer)
	Constructor for deserializing buffer metadata from disk.

Static Public Attributes
static constexpr idx_t	BASE [] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1}
	Constants for fast offset calculations in the bitmask.
static constexpr uint8_t	SHIFT [] = {32, 16, 8, 4, 2, 1}

Private Member Functions
data_ptr_t	GetDeprecated (const bool dirty_p=true)
bool	InMemory () const
	Returns true, if the buffer is in-memory.
bool	OnDisk () const
	Returns true, if the block is on-disk.
void	Serialize (PartialBlockManager &partial_block_manager, const idx_t available_segments, const idx_t segment_size, const idx_t bitmask_offset)
	Serializes a buffer, if dirty or not on disk.
void	LoadFromDisk ()
	Load a buffer from disk, if not in memory.
uint32_t	GetOffset (const idx_t bitmask_count, const idx_t available_segments)
	Returns the first free offset in a bitmask.
void	SetAllocationSize (const idx_t available_segments, const idx_t segment_size, const idx_t bitmask_offset)
	Sets the allocation size, if dirty.

Private Attributes
BlockManager &	block_manager
	Block manager of the database instance.
atomic< idx_t >	readers
	The number of active segments.
idx_t	segment_count
	The number of allocated segments.
idx_t	allocation_size
	The size of allocated memory in this buffer (necessary for copying while pinning)
bool	dirty
	True: the in-memory buffer is no longer consistent with its optional copy on disk.
bool	vacuum
	True: can be vacuumed after the vacuum operation.
bool	loaded
	True: has been loaded from disk.
BlockPointer	block_pointer
	Partial block id and offset.
BufferHandle	buffer_handle
	The buffer handle of the in-memory buffer.
shared_ptr< BlockHandle >	block_handle
	The block handle of the on-disk buffer.
mutex	lock
	The lock for this fixed size buffer handle.

Friends
class	FixedSizeAllocator
class	SegmentHandle

Detailed Description

A fixed-size buffer holds fixed-size segments of data. It lazily deserializes a buffer, if on-disk and not in memory, and it only serializes dirty and non-written buffers to disk during serialization.

Member Function Documentation

GetDeprecated()

data_ptr_t duckdb::FixedSizeBuffer::GetDeprecated ( const bool  dirty_p = true )

inlineprivate

Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory. DEPRECATED. Use segment handles.

                                                        {
        lock_guard<mutex> l(lock);
        if (!InMemory()) {
            LoadFromDisk();
        }
        if (dirty_p) {
            dirty = dirty_p;
        }
        return buffer_handle.Ptr();
    }

Here is the call graph for this function:

InMemory()

bool duckdb::FixedSizeBuffer::InMemory ( ) const

inlineprivate

Returns true, if the buffer is in-memory.

                          {
        return buffer_handle.IsValid();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

OnDisk()

bool duckdb::FixedSizeBuffer::OnDisk ( ) const

inlineprivate

Returns true, if the block is on-disk.

                        {
        return block_pointer.IsValid();
    }

Member Data Documentation

BASE

constexpr idx_t duckdb::FixedSizeBuffer::BASE[] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1}

staticconstexpr

Constants for fast offset calculations in the bitmask.

{0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1};

SHIFT

constexpr uint8_t duckdb::FixedSizeBuffer::SHIFT[] = {32, 16, 8, 4, 2, 1}

staticconstexpr

{32, 16, 8, 4, 2, 1};

---

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

• external/duckdb/duckdb.cpp