tigerbeetle-node 0.10.0 → 0.11.0

package/src/tigerbeetle/src/lsm/manifest_log.zig

@@ -31,8 +31,15 @@ const vsr = @import("../vsr.zig");
 
 const SuperBlockType = vsr.SuperBlockType;
 const GridType = @import("grid.zig").GridType;
+const BlockType = @import("grid.zig").BlockType;
 const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
 
+/// ManifestLog block schema:
+/// │ vsr.Header                  │ operation=BlockType.manifest
+/// │ [entry_count_max]Label      │ level index, insert|remove
+/// │ [≤entry_count_max]TableInfo │
+/// │ […]u8{0}                    │ padding (to end of block)
+/// Label and TableInfo entries correspond.
 pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
     return struct {
         const ManifestLog = @This();
@@ -40,8 +47,8 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
         const SuperBlock = SuperBlockType(Storage);
         const Grid = GridType(Storage);
 
-        const BlockPtr = *align(config.sector_size) [config.block_size]u8;
-        const BlockPtrConst = *align(config.sector_size) const [config.block_size]u8;
+        const BlockPtr = Grid.BlockPtr;
+        const BlockPtrConst = Grid.BlockPtrConst;
 
         pub const Callback = fn (manifest_log: *ManifestLog) void;
 
@@ -99,20 +106,27 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
         blocks_closed: u8 = 0,
 
         /// The number of entries in the open block.
+        ///
+        /// Invariants:
+        /// - When `entry_count = 0`, there is no open block.
+        /// - `entry_count < entry_count_max`. When `entry_count` reaches the maximum, the open
+        ///   block is closed, and `entry_count` resets to 0.
         entry_count: u32 = 0,
 
         opened: bool = false,
         open_event: OpenEvent = undefined,
         open_iterator: SuperBlock.Manifest.IteratorReverse = undefined,
 
+        /// Set for the duration of `compact`.
         reading: bool = false,
         read: Grid.Read = undefined,
-        read_callback: Callback = undefined,
+        read_callback: ?Callback = null,
         read_block_reference: ?SuperBlock.Manifest.BlockReference = null,
 
+        /// Set for the duration of `flush` and `checkpoint`.
         writing: bool = false,
         write: Grid.Write = undefined,
-        write_callback: Callback = undefined,
+        write_callback: ?Callback = null,
 
         pub fn init(allocator: mem.Allocator, grid: *Grid, tree_hash: u128) !ManifestLog {
             // TODO RingBuffer for .pointer should be extended to take care of alignment:
@@ -154,6 +168,11 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             assert(!manifest_log.opened);
             assert(!manifest_log.reading);
             assert(!manifest_log.writing);
+            assert(manifest_log.read_callback == null);
+
+            assert(manifest_log.blocks.count == 0);
+            assert(manifest_log.blocks_closed == 0);
+            assert(manifest_log.entry_count == 0);
 
             manifest_log.open_event = event;
             manifest_log.open_iterator = manifest_log.superblock.manifest.iterator_reverse(
@@ -171,6 +190,10 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             assert(manifest_log.reading);
             assert(!manifest_log.writing);
 
+            assert(manifest_log.blocks.count == 0);
+            assert(manifest_log.blocks_closed == 0);
+            assert(manifest_log.entry_count == 0);
+
             manifest_log.read_block_reference = manifest_log.open_iterator.next();
 
             if (manifest_log.read_block_reference) |block| {
@@ -182,15 +205,16 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                     &manifest_log.read,
                     block.address,
                     block.checksum,
+                    .manifest,
                 );
             } else {
                 manifest_log.opened = true;
                 manifest_log.open_event = undefined;
                 manifest_log.open_iterator = undefined;
 
-                const callback = manifest_log.read_callback;
+                const callback = manifest_log.read_callback.?;
                 manifest_log.reading = false;
-                manifest_log.read_callback = undefined;
+                manifest_log.read_callback = null;
                 assert(manifest_log.read_block_reference == null);
 
                 callback(manifest_log);
@@ -229,6 +253,10 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                 }
             }
 
+            if (block_entry_count(block) < entry_count_max) {
+                manifest.queue_for_compaction(block_reference.address);
+            }
+
             log.debug("{}: opened: checksum={} address={} entries={}", .{
                 manifest_log.tree_hash,
                 block_reference.checksum,
@@ -259,11 +287,8 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             assert(table.snapshot_min > 0);
             assert(table.snapshot_max > table.snapshot_min);
 
-            if (manifest_log.blocks.empty()) {
-                manifest_log.acquire_block();
-            } else if (manifest_log.entry_count == entry_count_max) {
-                assert(manifest_log.blocks.count > 0);
-                manifest_log.close_block();
+            if (manifest_log.entry_count == 0) {
+                assert(manifest_log.blocks.count == manifest_log.blocks_closed);
                 manifest_log.acquire_block();
             } else if (manifest_log.entry_count > 0) {
                 assert(manifest_log.blocks.count > 0);
@@ -302,12 +327,18 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             }
 
             manifest_log.entry_count += 1;
+            if (manifest_log.entry_count == entry_count_max) {
+                manifest_log.close_block();
+                assert(manifest_log.entry_count == 0);
+            }
         }
 
-        pub fn flush(manifest_log: *ManifestLog, callback: Callback) void {
+        /// `flush` does not close a partial block; that is only necessary during `checkpoint`.
+        fn flush(manifest_log: *ManifestLog, callback: Callback) void {
             assert(manifest_log.opened);
             assert(!manifest_log.reading);
             assert(!manifest_log.writing);
+            assert(manifest_log.write_callback == null);
 
             manifest_log.writing = true;
             manifest_log.write_callback = callback;
@@ -332,8 +363,8 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                     assert(manifest_log.entry_count < entry_count_max);
                 }
 
-                const callback = manifest_log.write_callback;
-                manifest_log.write_callback = undefined;
+                const callback = manifest_log.write_callback.?;
+                manifest_log.write_callback = null;
                 manifest_log.writing = false;
 
                 callback(manifest_log);
@@ -350,6 +381,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             const entry_count = block_entry_count(block);
 
             if (manifest_log.blocks_closed == 1 and manifest_log.blocks.count == 1) {
+                // This might be the last block of a checkpoint, which can be a partial block.
                 assert(entry_count > 0);
             } else {
                 assert(entry_count == entry_count_max);
@@ -395,41 +427,48 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
         }
 
         pub fn compact(manifest_log: *ManifestLog, callback: Callback) void {
+            assert(manifest_log.opened);
             assert(!manifest_log.reading);
+            assert(!manifest_log.writing);
+            assert(manifest_log.read_callback == null);
             manifest_log.read_callback = callback;
-            manifest_log.flush(flush_callback);
+            manifest_log.flush(compact_flush_callback);
         }
 
-        fn flush_callback(manifest_log: *ManifestLog) void {
-            const callback = manifest_log.read_callback;
-            manifest_log.read_callback = undefined;
+        fn compact_flush_callback(manifest_log: *ManifestLog) void {
+            const callback = manifest_log.read_callback.?;
 
             assert(manifest_log.opened);
             assert(!manifest_log.reading);
             assert(!manifest_log.writing);
+            assert(manifest_log.blocks_closed == 0);
 
             const manifest: *SuperBlock.Manifest = &manifest_log.superblock.manifest;
 
+            // Compact a single manifest block — to minimize latency spikes, we want to do the bare
+            // minimum of compaction work required.
+            // TODO Compact more than 1 block if fragmentation is outstripping the compaction rate.
             if (manifest.oldest_block_queued_for_compaction(manifest_log.tree_hash)) |block| {
                 assert(block.tree == manifest_log.tree_hash);
                 assert(block.address > 0);
 
                 manifest_log.reading = true;
-                manifest_log.read_callback = callback;
                 manifest_log.read_block_reference = block;
 
                 manifest_log.grid.read_block(
-                    compact_callback,
+                    compact_read_block_callback,
                     &manifest_log.read,
                     block.address,
                     block.checksum,
+                    .manifest,
                 );
             } else {
+                manifest_log.read_callback = null;
                 callback(manifest_log);
             }
         }
 
-        fn compact_callback(read: *Grid.Read, block: BlockPtrConst) void {
+        fn compact_read_block_callback(read: *Grid.Read, block: BlockPtrConst) void {
             const manifest_log = @fieldParentPtr(ManifestLog, "read", read);
             assert(manifest_log.opened);
             assert(manifest_log.reading);
@@ -489,11 +528,11 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             );
             assert(!manifest.queued_for_compaction(block_reference.address));
 
-            manifest_log.superblock.free_set.release_at_checkpoint(block_reference.address);
+            manifest_log.grid.release_at_checkpoint(block_reference.address);
 
-            const callback = manifest_log.read_callback;
+            const callback = manifest_log.read_callback.?;
             manifest_log.reading = false;
-            manifest_log.read_callback = undefined;
+            manifest_log.read_callback = null;
             manifest_log.read_block_reference = null;
 
             callback(manifest_log);
@@ -503,6 +542,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             assert(manifest_log.opened);
             assert(!manifest_log.reading);
             assert(!manifest_log.writing);
+            assert(manifest_log.write_callback == null);
 
             manifest_log.writing = true;
             manifest_log.write_callback = callback;
@@ -519,7 +559,9 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
         }
 
         fn acquire_block(manifest_log: *ManifestLog) void {
+            assert(manifest_log.opened);
             assert(manifest_log.entry_count == 0);
+            assert(manifest_log.blocks.count == manifest_log.blocks_closed);
             assert(!manifest_log.blocks.full());
 
             manifest_log.blocks.advance_tail();
@@ -529,15 +571,16 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             const header = mem.bytesAsValue(vsr.Header, block[0..@sizeOf(vsr.Header)]);
             header.* = .{
                 .cluster = manifest_log.superblock.working.cluster,
-                .op = manifest_log.superblock.free_set.acquire().?,
+                .op = manifest_log.grid.acquire(),
                 .size = undefined,
                 .command = .block,
             };
         }
 
         fn close_block(manifest_log: *ManifestLog) void {
-            const block: BlockPtr = manifest_log.blocks.tail().?;
+            assert(manifest_log.blocks.count == manifest_log.blocks_closed + 1);
 
+            const block: BlockPtr = manifest_log.blocks.tail().?;
             const entry_count = manifest_log.entry_count;
             assert(entry_count > 0);
             assert(entry_count <= entry_count_max);
@@ -554,6 +597,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             // Zero unused tables, and padding:
             mem.set(u8, block[header.size..], 0);
 
+            header.operation = BlockType.manifest.operation();
             header.set_checksum_body(block[@sizeOf(vsr.Header)..header.size]);
             header.set_checksum();
 
@@ -569,10 +613,12 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
 
             manifest_log.blocks_closed += 1;
             manifest_log.entry_count = 0;
+            assert(manifest_log.blocks.count == manifest_log.blocks_closed);
         }
 
         fn verify_block(block: BlockPtrConst, checksum: ?u128, address: ?u64) void {
             const header = mem.bytesAsValue(vsr.Header, block[0..@sizeOf(vsr.Header)]);
+            assert(BlockType.from(header.operation) == .manifest);
 
             if (config.verify) {
                 assert(header.valid_checksum());
@@ -623,6 +669,8 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
 
             // Encode the smaller type first because this will be multiplied by entry_count_max.
             const labels_size = entry_count_max * @sizeOf(Label);
+            assert(labels_size == labels_size_max);
+            assert((@sizeOf(vsr.Header) + labels_size) % @alignOf(TableInfo) == 0);
             const tables_size = entry_count * @sizeOf(TableInfo);
 
             return @sizeOf(vsr.Header) + labels_size + tables_size;
@@ -649,14 +697,14 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
         fn tables(block: BlockPtr) *[entry_count_max]TableInfo {
             return mem.bytesAsSlice(
                 TableInfo,
-                block[@sizeOf(vsr.Header) + entry_count_max ..][0..tables_size_max],
+                block[@sizeOf(vsr.Header) + labels_size_max ..][0..tables_size_max],
             )[0..entry_count_max];
         }
 
         fn tables_const(block: BlockPtrConst) *const [entry_count_max]TableInfo {
             return mem.bytesAsSlice(
                 TableInfo,
-                block[@sizeOf(vsr.Header) + entry_count_max ..][0..tables_size_max],
+                block[@sizeOf(vsr.Header) + labels_size_max ..][0..tables_size_max],
             )[0..entry_count_max];
         }
     };
@@ -893,6 +941,7 @@ pub fn main() !void {
     };
     assert(@sizeOf(TableInfo) == 48 + 16 * 2);
     assert(@alignOf(TableInfo) == 16);
+    assert(@bitSizeOf(TableInfo) == @sizeOf(TableInfo) * 8);
 
     const ManifestLogTest = ManifestLogTestType(Storage, TableInfo);
 

package/src/tigerbeetle/src/lsm/posted_groove.zig

@@ -12,6 +12,7 @@ const GridType = @import("grid.zig").GridType;
 const NodePool = @import("node_pool.zig").NodePool(config.lsm_manifest_node_size, 16);
 
 const snapshot_latest = @import("tree.zig").snapshot_latest;
+const compaction_snapshot_for_op = @import("tree.zig").compaction_snapshot_for_op;
 
 /// This type wraps a single LSM tree in the API needed to integrate it with the Forest.
 /// TigerBeetle's state machine requires a map from u128 ID to posted boolean for transfers
@@ -44,7 +45,6 @@ pub fn PostedGrooveType(comptime Storage: type) type {
                 return value.id;
             }
 
-            // TODO(ifreund): disallow this id in the state machine.
             const sentinel_key = math.maxInt(u128);
 
             inline fn tombstone(value: *const Value) bool {
@@ -69,13 +69,13 @@ pub fn PostedGrooveType(comptime Storage: type) type {
             Value.tombstone_from_key,
         );
 
-        const Tree = TreeType(Table, Storage, "groove");
+        const Tree = TreeType(Table, Storage, "posted_groove");
         const Grid = GridType(Storage);
 
         const PrefetchIDs = std.AutoHashMapUnmanaged(u128, void);
-        const PrefetchObjects = std.AutoHashMapUnmanaged(u128, bool);
+        const PrefetchObjects = std.AutoHashMapUnmanaged(u128, bool); // true:posted, false:voided
 
-        cache: *Tree.ValueCache,
+        cache: *Tree.TableMutable.ValuesCache,
         tree: Tree,
 
         /// Object IDs enqueued to be prefetched.
@@ -90,42 +90,31 @@ pub fn PostedGrooveType(comptime Storage: type) type {
         /// sufficient to query this hashmap alone to know the state of the LSM trees.
         prefetch_objects: PrefetchObjects,
 
-        /// This field is necessary to expose the same open()/compact_cpu()/compact_io() function
+        /// The snapshot to prefetch from.
+        prefetch_snapshot: ?u64,
+
+        /// This field is necessary to expose the same open()/compact()/checkpoint() function
         /// signatures as the real Groove type.
         callback: ?fn (*PostedGroove) void = null,
 
+        /// See comments for Groove.Options.
+        pub const Options = struct {
+            cache_entries_max: u32,
+            prefetch_entries_max: u32,
+            commit_entries_max: u32,
+        };
+
         pub fn init(
             allocator: mem.Allocator,
             node_pool: *NodePool,
             grid: *Grid,
-            // The cache size is meant to be computed based on the left over available memory
-            // that tigerbeetle was given to allocate from CLI arguments.
-            cache_size: u32,
-            // In general, the commit count max for a field, depends on the field's object,
-            // how many objects might be changed by a batch:
-            //   (config.message_size_max - sizeOf(vsr.header))
-            // For example, there are at most 8191 transfers in a batch.
-            // So commit_count_max=8191 for transfer objects and indexes.
-            //
-            // However, if a transfer is ever mutated, then this will double commit_count_max
-            // since the old index might need to be removed, and the new index inserted.
-            //
-            // A way to see this is by looking at the state machine. If a transfer is inserted,
-            // how many accounts and transfer put/removes will be generated?
-            //
-            // This also means looking at the state machine operation that will generate the
-            // most put/removes in the worst case.
-            // For example, create_accounts will put at most 8191 accounts.
-            // However, create_transfers will put 2 accounts (8191 * 2) for every transfer, and
-            // some of these accounts may exist, requiring a remove/put to update the index.
-            commit_count_max: u32,
+            options: Options,
         ) !PostedGroove {
-            // Cache is dynamically allocated to pass a pointer into the Object tree.
-            const cache = try allocator.create(Tree.ValueCache);
+            // Cache is heap-allocated to pass a pointer into the Object tree.
+            const cache = try allocator.create(Tree.TableMutable.ValuesCache);
             errdefer allocator.destroy(cache);
 
-            cache.* = .{};
-            try cache.ensureTotalCapacity(allocator, cache_size);
+            cache.* = try Tree.TableMutable.ValuesCache.init(allocator, options.cache_entries_max);
             errdefer cache.deinit(allocator);
 
             var tree = try Tree.init(
@@ -134,20 +123,17 @@ pub fn PostedGrooveType(comptime Storage: type) type {
                 grid,
                 cache,
                 .{
-                    .commit_count_max = commit_count_max,
+                    .commit_entries_max = options.commit_entries_max,
                 },
             );
             errdefer tree.deinit(allocator);
 
-            // TODO: document why this is twice the commit count max.
-            const prefetch_count_max = commit_count_max * 2;
-
             var prefetch_ids = PrefetchIDs{};
-            try prefetch_ids.ensureTotalCapacity(allocator, prefetch_count_max);
+            try prefetch_ids.ensureTotalCapacity(allocator, options.prefetch_entries_max);
             errdefer prefetch_ids.deinit(allocator);
 
             var prefetch_objects = PrefetchObjects{};
-            try prefetch_objects.ensureTotalCapacity(allocator, prefetch_count_max);
+            try prefetch_objects.ensureTotalCapacity(allocator, options.prefetch_entries_max);
             errdefer prefetch_objects.deinit(allocator);
 
             return PostedGroove{
@@ -156,12 +142,11 @@ pub fn PostedGrooveType(comptime Storage: type) type {
 
                 .prefetch_ids = prefetch_ids,
                 .prefetch_objects = prefetch_objects,
+                .prefetch_snapshot = null,
             };
         }
 
         pub fn deinit(groove: *PostedGroove, allocator: mem.Allocator) void {
-            assert(groove.callback == null);
-
             groove.tree.deinit(allocator);
             groove.cache.deinit(allocator);
             allocator.destroy(groove.cache);
@@ -176,10 +161,24 @@ pub fn PostedGrooveType(comptime Storage: type) type {
             return groove.prefetch_objects.get(id);
         }
 
-        /// Must be called directly after the state machine commit is finished and prefetch results
-        /// are no longer needed.
-        pub fn prefetch_clear(groove: *PostedGroove) void {
-            groove.prefetch_objects.clearRetainingCapacity();
+        /// Must be called directly before the state machine begins queuing ids for prefetch.
+        /// When `snapshot` is null, prefetch from the current snapshot.
+        pub fn prefetch_setup(groove: *PostedGroove, snapshot: ?u64) void {
+            // We may query the input tables of an ongoing compaction, but must not query the
+            // output tables until the compaction is complete. (Until then, the output tables may
+            // be in the manifest but not yet on disk).
+            const snapshot_max = groove.tree.lookup_snapshot_max;
+            const snapshot_target = snapshot orelse snapshot_max;
+            assert(snapshot_target <= snapshot_max);
+
+            if (groove.prefetch_snapshot == null) {
+                groove.prefetch_objects.clearRetainingCapacity();
+            } else {
+                // If there is a snapshot already set from the previous prefetch_setup(), then its
+                // prefetch() was never called, so there must already be no queued objects or ids.
+            }
+
+            groove.prefetch_snapshot = snapshot_target;
             assert(groove.prefetch_objects.count() == 0);
             assert(groove.prefetch_ids.count() == 0);
         }
@@ -188,7 +187,7 @@ pub fn PostedGrooveType(comptime Storage: type) type {
         /// We tolerate duplicate IDs enqueued by the state machine.
         /// For example, if all unique operations require the same two dependencies.
         pub fn prefetch_enqueue(groove: *PostedGroove, id: u128) void {
-            if (groove.tree.get_cached(id)) |value| {
+            if (groove.tree.lookup_from_memory(groove.prefetch_snapshot.?, id)) |value| {
                 switch (value.data) {
                     .posted => groove.prefetch_objects.putAssumeCapacity(value.id, true),
                     .voided => groove.prefetch_objects.putAssumeCapacity(value.id, false),
@@ -200,8 +199,7 @@ pub fn PostedGrooveType(comptime Storage: type) type {
         }
 
         /// Ensure the objects corresponding to all ids enqueued with prefetch_enqueue() are
-        /// in memory, either in the value cache of the object tree or in the prefetch_objects
-        /// backup hash map.
+        /// available in `prefetch_objects`.
         pub fn prefetch(
             groove: *PostedGroove,
             callback: fn (*PrefetchContext) void,
@@ -210,14 +208,17 @@ pub fn PostedGrooveType(comptime Storage: type) type {
             context.* = .{
                 .groove = groove,
                 .callback = callback,
+                .snapshot = groove.prefetch_snapshot.?,
                 .id_iterator = groove.prefetch_ids.keyIterator(),
             };
+            groove.prefetch_snapshot = null;
             context.start_workers();
         }
 
         pub const PrefetchContext = struct {
             groove: *PostedGroove,
             callback: fn (*PrefetchContext) void,
+            snapshot: u64,
 
             id_iterator: PrefetchIDs.KeyIterator,
 
@@ -233,17 +234,16 @@ pub fn PostedGrooveType(comptime Storage: type) type {
 
                 // Track an extra "worker" that will finish after the loop.
                 //
-                // This prevents `context.finish()` from being called within the loop body when every
-                // worker finishes synchronously. `context.finish()` sets the `context` to undefined,
-                // but `context` is required for the last loop condition check.
+                // This prevents `context.finish()` from being called within the loop body when
+                // every worker finishes synchronously. `context.finish()` calls the user-provided
+                // callback which may re-use the memory of this `PrefetchContext`. However, we
+                // rely on `context` being well-defined for the loop condition.
                 context.workers_busy += 1;
 
-                // -1 to ignore the extra worker.
-                while (context.workers_busy - 1 < context.workers.len) {
-                    const worker = &context.workers[context.workers_busy - 1];
+                for (context.workers) |*worker| {
                     worker.* = .{ .context = context };
                     context.workers_busy += 1;
-                    if (!worker.lookup_start()) break;
+                    worker.lookup_start_next();
                 }
 
                 assert(context.workers_busy >= 1);
@@ -257,12 +257,12 @@ pub fn PostedGrooveType(comptime Storage: type) type {
 
             fn finish(context: *PrefetchContext) void {
                 assert(context.workers_busy == 0);
-                assert(context.groove.prefetch_ids.count() == 0);
+
                 assert(context.id_iterator.next() == null);
+                context.groove.prefetch_ids.clearRetainingCapacity();
+                assert(context.groove.prefetch_ids.count() == 0);
 
-                const callback = context.callback;
-                context.* = undefined;
-                callback(context);
+                context.callback(context);
             }
         };
 
@@ -272,33 +272,27 @@ pub fn PostedGrooveType(comptime Storage: type) type {
 
             /// Returns true if asynchronous I/O has been started.
             /// Returns false if there are no more IDs to prefetch.
-            fn lookup_start(worker: *PrefetchWorker) bool {
-                const groove = worker.context.groove;
-
+            fn lookup_start_next(worker: *PrefetchWorker) void {
                 const id = worker.context.id_iterator.next() orelse {
-                    groove.prefetch_ids.clearRetainingCapacity();
-                    assert(groove.prefetch_ids.count() == 0);
                     worker.context.worker_finished();
-                    return false;
+                    return;
                 };
 
                 if (config.verify) {
-                    // This is checked in prefetch_enqueue()
-                    assert(groove.tree.get_cached(id.*) == null);
+                    // This was checked in prefetch_enqueue().
+                    assert(worker.context.groove.tree.lookup_from_memory(worker.context.snapshot, id.*) == null);
                 }
 
                 // If not in the LSM tree's cache, the object must be read from disk and added
                 // to the auxillary prefetch_objects hash map.
                 // TODO: this LSM tree function needlessly checks the LSM tree's cache a
                 // second time. Adding API to the LSM tree to avoid this may be worthwhile.
-                groove.tree.lookup(
+                worker.context.groove.tree.lookup_from_levels(
                     lookup_id_callback,
                     &worker.lookup_id,
-                    snapshot_latest,
+                    worker.context.snapshot,
                     id.*,
                 );
-
-                return true;
             }
 
             fn lookup_id_callback(
@@ -321,13 +315,7 @@ pub fn PostedGrooveType(comptime Storage: type) type {
                         },
                     }
                 }
-                worker.lookup_finish();
-            }
-
-            fn lookup_finish(worker: *PrefetchWorker) void {
-                if (!worker.lookup_start()) {
-                    worker.* = undefined;
-                }
+                worker.lookup_start_next();
             }
         };
 
@@ -392,7 +380,7 @@ test "PostedGroove" {
 
     _ = PostedGroove.prefetch_enqueue;
     _ = PostedGroove.prefetch;
-    _ = PostedGroove.prefetch_clear;
+    _ = PostedGroove.prefetch_setup;
 
     std.testing.refAllDecls(PostedGroove.PrefetchWorker);
     std.testing.refAllDecls(PostedGroove.PrefetchContext);