tigerbeetle-node 0.11.2 → 0.11.4

package/src/tigerbeetle/src/lsm/compaction.zig

@@ -36,7 +36,9 @@ const math = std.math;
 const assert = std.debug.assert;
 
 const log = std.log.scoped(.compaction);
-const config = @import("../config.zig");
+const tracer = @import("../tracer.zig");
+
+const config = @import("../constants.zig");
 
 const GridType = @import("grid.zig").GridType;
 const ManifestType = @import("manifest.zig").ManifestType;
@@ -120,6 +122,8 @@ pub fn CompactionType(
             done,
         };
 
+        tree_name: [:0]const u8,
+
         grid: *Grid,
         grid_reservation: Grid.Reservation,
         range: Manifest.CompactionRange,
@@ -155,7 +159,9 @@ pub fn CompactionType(
 
         tables_output_count: usize = 0,
 
-        pub fn init(allocator: mem.Allocator) !Compaction {
+        tracer_slot: ?tracer.SpanStart = null,
+
+        pub fn init(allocator: mem.Allocator, tree_name: [:0]const u8) !Compaction {
             var iterator_a = try IteratorA.init(allocator);
             errdefer iterator_a.deinit(allocator);
 
@@ -166,6 +172,8 @@ pub fn CompactionType(
             errdefer table_builder.deinit(allocator);
 
             return Compaction{
+                .tree_name = tree_name,
+
                 // Assigned by start()
                 .grid = undefined,
                 .grid_reservation = undefined,
@@ -216,6 +224,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done and compaction.merge_iterator == null);
+            assert(compaction.tracer_slot == null);
 
             assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
             assert(range.table_count > 0);
@@ -230,6 +239,8 @@ pub fn CompactionType(
             assert(drop_tombstones or level_b < config.lsm_levels - 1);
 
             compaction.* = .{
+                .tree_name = compaction.tree_name,
+
                 .grid = grid,
                 // Reserve enough blocks to write our output tables in the worst case, where:
                 // - no tombstones are dropped,
@@ -337,6 +348,16 @@ pub fn CompactionType(
 
             compaction.callback = callback;
 
+            tracer.start(
+                &compaction.tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_tick = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+                @src(),
+            );
+
             // Generate fake IO to make sure io_pending doesn't reach zero multiple times from
             // IO being completed inline down below.
             // The fake IO is immediately resolved and triggers the cpu_merge_start if all
@@ -405,6 +426,17 @@ pub fn CompactionType(
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done);
 
+            var tracer_slot: ?tracer.SpanStart = null;
+            tracer.start(
+                &tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_merge = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+                @src(),
+            );
+
             // Create the merge iterator only when we can peek() from the read iterators.
             // This happens after IO for the first reads complete.
             if (compaction.merge_iterator == null) {
@@ -422,6 +454,23 @@ pub fn CompactionType(
                 compaction.cpu_merge_finish();
             }
 
+            tracer.end(
+                &tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_merge = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+            tracer.end(
+                &compaction.tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_tick = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+
             // TODO Implement pacing here by deciding if we should do another compact_tick()
             // instead of invoking the callback, using compaction.range.table_count as the heuristic.
 
@@ -455,6 +504,8 @@ pub fn CompactionType(
             // Finalize the data block if it's full or if it contains pending values when there's
             // no more left to merge.
             if (compaction.table_builder.data_block_full() or
+                compaction.table_builder.filter_block_full() or
+                compaction.table_builder.index_block_full() or
                 (merge_iterator.empty() and !compaction.table_builder.data_block_empty()))
             {
                 compaction.table_builder.data_block_finish(.{
@@ -471,6 +522,7 @@ pub fn CompactionType(
             // Finalize the filter block if it's full or if it contains pending data blocks
             // when there's no more merged values to fill them.
             if (compaction.table_builder.filter_block_full() or
+                compaction.table_builder.index_block_full() or
                 (merge_iterator.empty() and !compaction.table_builder.filter_block_empty()))
             {
                 compaction.table_builder.filter_block_finish(.{
@@ -560,6 +612,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(compaction.merge_done);
+            assert(compaction.tracer_slot == null);
 
             // TODO(Beat Pacing) This should really be where the compaction callback is invoked,
             // but currently that can occur multiple times per beat.

package/src/tigerbeetle/src/lsm/forest.zig

@@ -4,7 +4,7 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 
 const GridType = @import("grid.zig").GridType;

package/src/tigerbeetle/src/lsm/forest_fuzz.zig

@@ -3,10 +3,12 @@ const testing = std.testing;
 const allocator = testing.allocator;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
+
 const log = std.log.scoped(.lsm_forest_fuzz);
+const tracer = @import("../tracer.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
@@ -23,6 +25,8 @@ const Forest = StateMachine.Forest;
 const Grid = GridType(Storage);
 const SuperBlock = vsr.SuperBlockType(Storage);
 
+pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
+
 const FuzzOp = union(enum) {
     // TODO Test secondary index lookups and range queries.
     compact: struct {
@@ -306,11 +310,7 @@ fn random_id(random: std.rand.Random, comptime Int: type) Int {
     return fuzz.random_int_exponential(random, Int, avg_int);
 }
 
-pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
-    const fuzz_op_count = @minimum(
-        @as(usize, 1E7),
-        fuzz.random_int_exponential(random, usize, 1E6),
-    );
+pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const FuzzOp {
     log.info("fuzz_op_count = {}", .{fuzz_op_count});
 
     const fuzz_ops = try allocator.alloc(FuzzOp, fuzz_op_count);
@@ -395,11 +395,19 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 }
 
 pub fn main() !void {
+    try tracer.init(allocator);
+    defer tracer.deinit(allocator);
+
     const fuzz_args = try fuzz.parse_fuzz_args(allocator);
     var rng = std.rand.DefaultPrng.init(fuzz_args.seed);
     const random = rng.random();
 
-    const fuzz_ops = try generate_fuzz_ops(random);
+    const fuzz_op_count = @minimum(
+        fuzz_args.events_max orelse @as(usize, 1E7),
+        fuzz.random_int_exponential(random, usize, 1E6),
+    );
+
+    const fuzz_ops = try generate_fuzz_ops(random, fuzz_op_count);
     defer allocator.free(fuzz_ops);
 
     try run_fuzz_ops(Storage.Options{

package/src/tigerbeetle/src/lsm/grid.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const free_set = @import("../vsr/superblock_free_set.zig");
 

package/src/tigerbeetle/src/lsm/groove.zig

@@ -4,7 +4,7 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 
 const TableType = @import("table.zig").TableType;
 const TreeType = @import("tree.zig").TreeType;
@@ -120,7 +120,7 @@ comptime {
 fn IndexTreeType(
     comptime Storage: type,
     comptime Field: type,
-    comptime tree_name: []const u8,
+    comptime tree_name: [:0]const u8,
 ) type {
     const Key = CompositeKey(IndexCompositeKeyType(Field));
     const Table = TableType(
@@ -404,12 +404,8 @@ pub fn GrooveType(
         join_pending: usize = 0,
         join_callback: ?Callback = null,
 
-        objects_cache: *ObjectTree.TableMutable.ValuesCache,
         objects: ObjectTree,
-
-        ids_cache: *IdTree.TableMutable.ValuesCache,
         ids: IdTree,
-
         indexes: IndexTrees,
 
         /// Object IDs enqueued to be prefetched.
@@ -428,10 +424,6 @@ pub fn GrooveType(
         prefetch_snapshot: ?u64,
 
         pub const Options = struct {
-            /// TODO Improve unit in this name to make more clear what should be passed.
-            /// For example, is this a size in bytes or a count in objects? It's a count in objects,
-            /// but the name poorly reflects this.
-            cache_entries_max: u32,
             /// The maximum number of objects that might be prefetched by a batch.
             prefetch_entries_max: u32,
 
@@ -446,38 +438,19 @@ pub fn GrooveType(
             grid: *Grid,
             options: Options,
         ) !Groove {
-            // Cache is heap-allocated to pass a pointer into the Object tree.
-            const objects_cache = try allocator.create(ObjectTree.TableMutable.ValuesCache);
-            errdefer allocator.destroy(objects_cache);
-
-            objects_cache.* = try ObjectTree.TableMutable.ValuesCache.init(
-                allocator,
-                options.cache_entries_max,
-            );
-            errdefer objects_cache.deinit(allocator);
-
             // Intialize the object LSM tree.
             var object_tree = try ObjectTree.init(
                 allocator,
                 node_pool,
                 grid,
-                objects_cache,
                 options.tree_options_object,
             );
             errdefer object_tree.deinit(allocator);
 
-            // Cache is heap-allocated to pass a pointer into the ID tree.
-            const ids_cache = try allocator.create(IdTree.TableMutable.ValuesCache);
-            errdefer allocator.destroy(ids_cache);
-
-            ids_cache.* = try IdTree.TableMutable.ValuesCache.init(allocator, options.cache_entries_max);
-            errdefer ids_cache.deinit(allocator);
-
             var id_tree = try IdTree.init(
                 allocator,
                 node_pool,
                 grid,
-                ids_cache,
                 options.tree_options_id,
             );
             errdefer id_tree.deinit(allocator);
@@ -494,11 +467,13 @@ pub fn GrooveType(
 
             // Initialize index LSM trees.
             inline for (std.meta.fields(IndexTrees)) |field| {
+                // No value cache for index trees, since they only do range queries.
+                assert(@field(options.tree_options_index, field.name).cache_entries_max == 0);
+
                 @field(index_trees, field.name) = try field.field_type.init(
                     allocator,
                     node_pool,
                     grid,
-                    null, // No value cache for index trees, since they only do range queries.
                     @field(options.tree_options_index, field.name),
                 );
                 index_trees_initialized += 1;
@@ -513,12 +488,8 @@ pub fn GrooveType(
             errdefer prefetch_objects.deinit(allocator);
 
             return Groove{
-                .objects_cache = objects_cache,
                 .objects = object_tree,
-
-                .ids_cache = ids_cache,
                 .ids = id_tree,
-
                 .indexes = index_trees,
 
                 .prefetch_ids = prefetch_ids,
@@ -533,12 +504,7 @@ pub fn GrooveType(
             }
 
             groove.objects.deinit(allocator);
-            groove.objects_cache.deinit(allocator);
-            allocator.destroy(groove.objects_cache);
-
             groove.ids.deinit(allocator);
-            groove.ids_cache.deinit(allocator);
-            allocator.destroy(groove.ids_cache);
 
             groove.prefetch_ids.deinit(allocator);
             groove.prefetch_objects.deinit(allocator);

package/src/tigerbeetle/src/lsm/level_iterator.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 
 const Direction = @import("direction.zig").Direction;
 const TableIteratorType = @import("table_iterator.zig").TableIteratorType;

package/src/tigerbeetle/src/lsm/manifest.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const growth_factor = config.lsm_growth_factor;
 
 const table_count_max = @import("tree.zig").table_count_max;
@@ -279,8 +279,6 @@ pub fn ManifestType(comptime Table: type, comptime Storage: type) type {
             key: Key,
             level: u8 = 0,
             inner: ?Level.Iterator = null,
-            // Verifies that we never check a newer table after an older one.
-            precedence: ?u64 = null,
 
             pub fn next(it: *LookupIterator) ?*const TableInfo {
                 while (it.level < config.lsm_levels) : (it.level += 1) {
@@ -294,9 +292,6 @@ pub fn ManifestType(comptime Table: type, comptime Storage: type) type {
                     );
 
                     if (inner.next()) |table| {
-                        if (it.precedence) |p| assert(p > table.snapshot_min);
-                        it.precedence = table.snapshot_min;
-
                         assert(table.visible(it.snapshot));
                         assert(compare_keys(it.key, table.key_min) != .lt);
                         assert(compare_keys(it.key, table.key_max) != .gt);

package/src/tigerbeetle/src/lsm/manifest_level.zig

@@ -4,7 +4,7 @@ const math = std.math;
 const mem = std.mem;
 const meta = std.meta;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const lsm = @import("tree.zig");
 const binary_search = @import("binary_search.zig");
 

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

@@ -26,7 +26,7 @@ const mem = std.mem;
 
 const log = std.log.scoped(.manifest_log);
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const util = @import("../util.zig");
 

package/src/tigerbeetle/src/lsm/manifest_log_fuzz.zig

@@ -16,7 +16,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_lsm_manifest_log);
 
 const vsr = @import("../vsr.zig");
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const SuperBlock = @import("../vsr/superblock.zig").SuperBlockType(Storage);
@@ -28,6 +28,8 @@ const BlockType = @import("grid.zig").BlockType;
 const ManifestLog = @import("manifest_log.zig").ManifestLogType(Storage, TableInfo);
 const fuzz = @import("../test/fuzz.zig");
 
+pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
+
 const storage_size_max = data_file_size_min + config.block_size * 1024;
 
 const entries_max_block = ManifestLog.Block.entry_count_max;
@@ -40,7 +42,12 @@ pub fn main() !void {
 
     var prng = std.rand.DefaultPrng.init(args.seed);
 
-    const events = try generate_events(allocator, prng.random());
+    const events_count = std.math.min(
+        args.events_max orelse @as(usize, 2e5),
+        fuzz.random_int_exponential(prng.random(), usize, 1e4),
+    );
+
+    const events = try generate_events(allocator, prng.random(), events_count);
     defer allocator.free(events);
 
     try run_fuzz(allocator, prng.random(), events);
@@ -122,6 +129,7 @@ const ManifestEvent = union(enum) {
 fn generate_events(
     allocator: std.mem.Allocator,
     random: std.rand.Random,
+    events_count: usize,
 ) ![]const ManifestEvent {
     const EventType = enum {
         insert_new,
@@ -132,20 +140,17 @@ fn generate_events(
         checkpoint,
     };
 
-    const events = try allocator.alloc(ManifestEvent, std.math.min(
-        @as(usize, 1e6),
-        fuzz.random_int_exponential(random, usize, 1e4),
-    ));
+    const events = try allocator.alloc(ManifestEvent, events_count);
     errdefer allocator.free(events);
 
     var event_distribution = fuzz.random_enum_distribution(random, EventType);
     // Don't remove too often, so that there are plenty of tables accumulating.
-    event_distribution.remove /= config.lsm_levels;
+    event_distribution.remove /= @intToFloat(f64, config.lsm_levels);
     // Don't compact or checkpoint too often, to approximate a real workload.
     // Additionally, checkpoint is slow because of the verification, so run it less
     // frequently.
-    event_distribution.compact /= config.lsm_levels * config.lsm_batch_multiple;
-    event_distribution.checkpoint /= config.lsm_levels * config.journal_slot_count;
+    event_distribution.compact /= @intToFloat(f64, config.lsm_levels * config.lsm_batch_multiple);
+    event_distribution.checkpoint /= @intToFloat(f64, config.lsm_levels * config.journal_slot_count);
 
     log.info("event_distribution = {d:.2}", .{event_distribution});
     log.info("event_count = {d}", .{events.len});

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

@@ -4,7 +4,7 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 
 const TableType = @import("table.zig").TableType;
 const TreeType = @import("tree.zig").TreeType;
@@ -75,7 +75,6 @@ pub fn PostedGrooveType(comptime Storage: type) type {
         const PrefetchIDs = std.AutoHashMapUnmanaged(u128, void);
         const PrefetchObjects = std.AutoHashMapUnmanaged(u128, bool); // true:posted, false:voided
 
-        cache: *Tree.TableMutable.ValuesCache,
         tree: Tree,
 
         /// Object IDs enqueued to be prefetched.
@@ -110,19 +109,12 @@ pub fn PostedGrooveType(comptime Storage: type) type {
             grid: *Grid,
             options: Options,
         ) !PostedGroove {
-            // 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 Tree.TableMutable.ValuesCache.init(allocator, options.cache_entries_max);
-            errdefer cache.deinit(allocator);
-
             var tree = try Tree.init(
                 allocator,
                 node_pool,
                 grid,
-                cache,
                 .{
+                    .cache_entries_max = options.cache_entries_max,
                     .commit_entries_max = options.commit_entries_max,
                 },
             );
@@ -137,7 +129,6 @@ pub fn PostedGrooveType(comptime Storage: type) type {
             errdefer prefetch_objects.deinit(allocator);
 
             return PostedGroove{
-                .cache = cache,
                 .tree = tree,
 
                 .prefetch_ids = prefetch_ids,
@@ -148,8 +139,6 @@ pub fn PostedGrooveType(comptime Storage: type) type {
 
         pub fn deinit(groove: *PostedGroove, allocator: mem.Allocator) void {
             groove.tree.deinit(allocator);
-            groove.cache.deinit(allocator);
-            allocator.destroy(groove.cache);
 
             groove.prefetch_ids.deinit(allocator);
             groove.prefetch_objects.deinit(allocator);

package/src/tigerbeetle/src/lsm/segmented_array_benchmark.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const NodePoolType = @import("node_pool.zig").NodePool;
 const table_count_max_for_level = @import("tree.zig").table_count_max_for_level;
 const table_count_max_for_tree = @import("tree.zig").table_count_max_for_tree;

package/src/tigerbeetle/src/lsm/set_associative_cache.zig

@@ -7,7 +7,7 @@ const mem = std.mem;
 const meta = std.meta;
 const Vector = meta.Vector;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const div_ceil = @import("../util.zig").div_ceil;
 const verify = config.verify;
 

package/src/tigerbeetle/src/lsm/table.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const binary_search = @import("binary_search.zig");
 const bloom_filter = @import("bloom_filter.zig");
@@ -561,8 +561,9 @@ pub fn TableType(
                     }
                 }
 
-                assert(@divExact(data.key_layout_size, key_size) == data.key_count + 1);
                 if (data.key_count > 0) {
+                    assert(@divExact(data.key_layout_size, key_size) == data.key_count + 1);
+
                     const key_layout_bytes = @alignCast(
                         @alignOf(Key),
                         block[data.key_layout_offset..][0..data.key_layout_size],
@@ -638,6 +639,7 @@ pub fn TableType(
 
             pub fn filter_block_finish(builder: *Builder, options: FilterFinishOptions) void {
                 assert(!builder.filter_block_empty());
+                assert(builder.data_block_empty());
                 assert(options.address > 0);
 
                 const header_bytes = builder.filter_block[0..@sizeOf(vsr.Header)];
@@ -680,6 +682,8 @@ pub fn TableType(
 
             pub fn index_block_finish(builder: *Builder, options: IndexFinishOptions) TableInfo {
                 assert(options.address > 0);
+                assert(builder.filter_block_empty());
+                assert(builder.data_block_empty());
                 assert(builder.data_block_count > 0);
                 assert(builder.value == 0);
                 assert(builder.data_blocks_in_filter == 0);
@@ -916,22 +920,26 @@ pub fn TableType(
         }
 
         pub fn data_block_search(data_block: BlockPtrConst, key: Key) ?*const Value {
-            assert(@divExact(data.key_layout_size, key_size) == data.key_count + 1);
-            const key_layout_bytes = @alignCast(
-                @alignOf(Key),
-                data_block[data.key_layout_offset..][0..data.key_layout_size],
-            );
-            const key_layout = mem.bytesAsValue([data.key_count + 1]Key, key_layout_bytes);
+            const values = blk: {
+                if (data.key_count == 0) break :blk data_block_values_used(data_block);
 
-            const e = eytzinger(data.key_count, data.value_count_max);
-            const values = e.search_values(
-                Key,
-                Value,
-                compare_keys,
-                key_layout,
-                data_block_values_used(data_block),
-                key,
-            );
+                assert(@divExact(data.key_layout_size, key_size) == data.key_count + 1);
+                const key_layout_bytes = @alignCast(
+                    @alignOf(Key),
+                    data_block[data.key_layout_offset..][0..data.key_layout_size],
+                );
+                const key_layout = mem.bytesAsValue([data.key_count + 1]Key, key_layout_bytes);
+
+                const e = eytzinger(data.key_count, data.value_count_max);
+                break :blk e.search_values(
+                    Key,
+                    Value,
+                    compare_keys,
+                    key_layout,
+                    data_block_values_used(data_block),
+                    key,
+                );
+            };
 
             const result = binary_search.binary_search_values(
                 Key,

package/src/tigerbeetle/src/lsm/table_immutable.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const div_ceil = @import("../util.zig").div_ceil;
 const binary_search = @import("binary_search.zig");
 const snapshot_latest = @import("tree.zig").snapshot_latest;

package/src/tigerbeetle/src/lsm/table_iterator.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 
 const util = @import("../util.zig");
 const RingBuffer = @import("../ring_buffer.zig").RingBuffer;

package/src/tigerbeetle/src/lsm/table_mutable.zig

@@ -3,7 +3,7 @@ const mem = std.mem;
 const math = std.math;
 const assert = std.debug.assert;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const div_ceil = @import("../util.zig").div_ceil;
 const SetAssociativeCache = @import("set_associative_cache.zig").SetAssociativeCache;
 

package/src/tigerbeetle/src/lsm/test.zig

@@ -4,7 +4,7 @@ const allocator = testing.allocator;
 const assert = std.debug.assert;
 const os = std.os;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const log = std.log.scoped(.lsm_forest_test);