RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-23 14:07:42 +00:00
Code Issues Activity Actions

LibSQL: Find free blocks when opening a database file

Browse source 
The free block list now gets populated on opening a database file.
Ideally we persist this list inside the heap itself, but for now this
prevents excessive heap growth.
This commit is contained in:
Jelle Raaijmakers 2023-05-24 15:35:35 +02:00 • committed by Tim Flynn
parent a6abc1697f
commit d7bbb8d64a
2 changed files with 53 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

40
Tests/LibSQL/TestSqlHeap.cpp
View file

@ -127,3 +127,43 @@ TEST_CASE(heap_reuse_freed_blocks_after_storage_trim)
auto heap_size_after_second_storage = MUST(heap->file_size_in_bytes());
EXPECT(heap_size_after_second_storage <= original_heap_size);
}
TEST_CASE(heap_reuse_freed_blocks_after_reopening_file)
{
ScopeGuard guard([]() { MUST(Core::System::unlink(db_path)); });
size_t original_heap_size = 0;
StringBuilder builder;
MUST(builder.try_append_repeated('x', SQL::Block::DATA_SIZE * 4));
auto long_string = builder.string_view();
{
auto heap = create_heap();
// First, write storage spanning 4 blocks
auto first_index = heap->request_new_block_index();
TRY_OR_FAIL(heap->write_storage(first_index, long_string.bytes()));
MUST(heap->flush());
original_heap_size = MUST(heap->file_size_in_bytes());
// Then, overwrite the first storage and reduce it to 2 blocks
builder.clear();
MUST(builder.try_append_repeated('x', SQL::Block::DATA_SIZE * 2));
long_string = builder.string_view();
TRY_OR_FAIL(heap->write_storage(first_index, long_string.bytes()));
MUST(heap->flush());
auto heap_size_after_reduction = MUST(heap->file_size_in_bytes());
EXPECT(heap_size_after_reduction <= original_heap_size);
}
// Reopen the database file; we expect the heap to support reading back free blocks somehow.
// Add the second storage spanning 2 blocks - heap should not have grown compared to the original storage.
{
auto heap = create_heap();
auto second_index = heap->request_new_block_index();
TRY_OR_FAIL(heap->write_storage(second_index, long_string.bytes()));
MUST(heap->flush());
auto heap_size_after_second_storage = MUST(heap->file_size_in_bytes());
EXPECT(heap_size_after_second_storage <= original_heap_size);
}
}

16
Userland/Libraries/LibSQL/Heap.cpp
View file

@ -68,7 +68,16 @@ ErrorOr<void> Heap::open()
return open();
}
dbgln_if(SQL_DEBUG, "Heap file {} opened; number of blocks = {}", name(), m_highest_block_written);
// Perform a heap scan to find all free blocks
// FIXME: this is very inefficient; store free blocks in a persistent heap structure
for (Block::Index index = 1; index <= m_highest_block_written; ++index) {
auto block_data = TRY(read_raw_block(index));
auto size_in_bytes = *reinterpret_cast<u32*>(block_data.data());
if (size_in_bytes == 0)
TRY(m_free_block_indices.try_append(index));
}
dbgln_if(SQL_DEBUG, "Heap file {} opened; number of blocks = {}; free blocks = {}", name(), m_highest_block_written, m_free_block_indices.size());
return {};
}
@ -159,8 +168,8 @@ ErrorOr<ByteBuffer> Heap::read_raw_block(Block::Index index)
VERIFY(m_file);
VERIFY(index < m_next_block);
if (auto data = m_write_ahead_log.get(index); data.has_value())
return data.value();
if (auto wal_entry = m_write_ahead_log.get(index); wal_entry.has_value())
return wal_entry.value();
TRY(m_file->seek(index * Block::SIZE, SeekMode::SetPosition));
auto buffer = TRY(ByteBuffer::create_uninitialized(Block::SIZE));
@ -211,6 +220,7 @@ ErrorOr<void> Heap::write_block(Block const& block)
{
VERIFY(block.index() < m_next_block);
VERIFY(block.next_block() < m_next_block);
VERIFY(block.size_in_bytes() > 0);
VERIFY(block.data().size() <= Block::DATA_SIZE);
auto size_in_bytes = block.size_in_bytes();