tigerbeetle-node 0.11.0 → 0.11.1

package/src/tigerbeetle/src/ewah_benchmark.zig

@@ -35,15 +35,16 @@ pub fn main() !void {
         var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
         defer arena.deinit();
 
+        const allocator = arena.allocator();
         var i: usize = 0;
         var bitsets: [samples][]usize = undefined;
         var bitsets_encoded: [samples][]align(@alignOf(usize)) u8 = undefined;
         var bitsets_decoded: [samples][]usize = undefined;
         var bitset_lengths: [samples]usize = undefined;
         while (i < samples) : (i += 1) {
-            bitsets[i] = try make_bitset(&arena.allocator, config);
-            bitsets_encoded[i] = try arena.allocator.alignedAlloc(u8, @alignOf(usize), ewah.encode_size_max(bitsets[0].len));
-            bitsets_decoded[i] = try arena.allocator.alloc(usize, config.words);
+            bitsets[i] = try make_bitset(allocator, config);
+            bitsets_encoded[i] = try allocator.alignedAlloc(u8, @alignOf(usize), ewah.encode_size_max(bitsets[0].len));
+            bitsets_decoded[i] = try allocator.alloc(usize, config.words);
         }
 
         // Benchmark encoding.
@@ -96,16 +97,14 @@ pub fn main() !void {
     }
 }
 
-fn make_bitset(allocator: *std.mem.Allocator, config: BitSetConfig) ![]usize {
+fn make_bitset(allocator: std.mem.Allocator, config: BitSetConfig) ![]usize {
     var words = try allocator.alloc(usize, config.words);
     var w: usize = 0;
-    var run: bool = true;
     var literal: usize = 1;
     while (w < words.len) : (w += 1) {
-        const start = w;
-        const run_length = prng.random.uintLessThan(usize, 2 * config.run_length_e);
-        const literals_length = prng.random.uintLessThan(usize, 2 * config.literals_length_e);
-        const run_bit = prng.random.boolean();
+        const run_length = prng.random().uintLessThan(usize, 2 * config.run_length_e);
+        const literals_length = prng.random().uintLessThan(usize, 2 * config.literals_length_e);
+        const run_bit = prng.random().boolean();
 
         const run_end = std.math.min(w + run_length, words.len);
         while (w < run_end) : (w += 1) {

package/src/tigerbeetle/src/lsm/README.md

@@ -25,7 +25,7 @@ A tree is a hierarchy of in-memory and on-disk tables. There are three categorie
   - The mutable table's contents are periodically moved to the immutable table,
     where they are stored while being flushed to level `0`.
 - Level `0` … level `config.lsm_levels - 1` each contain an exponentially increasing number of
-  on-disk tables.
+  immutable on-disk tables.
   - Each tree has as many as `config.lsm_growth_factor ^ (level + 1)` tables per level.
     (`config.lsm_growth_factor` is typically 8).
   - Within a given level and snapshot, the tables' key ranges are [disjoint](manifest_level.zig).
@@ -47,7 +47,7 @@ The first half of the bar compacts even levels while the latter compacts odd lev
 Mutable table changes are sorted and compacted into the immutable table.
 The immutable table is compacted into level 0 during the odd level half of the bar.
 
-At any given point, there are at most `levels/2` compactions running concurrently.
+At any given point, there are at most `⌈levels/2⌉` compactions running concurrently.
 The source level is denoted as `level_a` and the target level as `level_b`.
 The last level in the LSM tree has no target level so it is never a source level.
 Each compaction compacts a [single table](#table-selection) from `level_a` into all tables in
@@ -55,7 +55,7 @@ Each compaction compacts a [single table](#table-selection) from `level_a` into
 
 Invariants:
 * At the end of every beat, there is space in mutable table for the next beat.
-* The manifest is compacted at the end of every beat.
+* The manifest log is compacted at the end of every beat.
 * The compactions' output tables are not [visible](#snapshots-and-compaction) until the compaction has finished.
 
 1. First half-bar, first beat ("first beat"):
@@ -63,15 +63,20 @@ Invariants:
     * Allow the per-level table limits to overflow if needed (for example, if we may compact a table
       from level `A` to level `B`, where level `B` is already full).
     * Start compactions from even levels that have reached their table limit.
+    * Acquire reservations from the Free Set for all blocks (upper-bound) that will be written
+      during this half-bar.
 
 2. First half-bar, last beat:
     * Finish ticking any incomplete even-level compactions.
     * Assert on callback completion that all compactions are complete.
+    * Release reservations from the Free Set.
 
 3. Second half-bar, first beat ("middle beat"):
     * Assert no compactions are currently running.
     * Start compactions from odd levels that have reached their table limit.
     * Compact the immutable table if it contains any sorted values (it might be empty).
+    * Acquire reservations from the Free Set for all blocks (upper-bound) that will be written
+      during this half-bar.
 
 4. Second half-bar, last beat:
     * Finish ticking any incomplete odd-level and immutable table compactions.
@@ -79,6 +84,7 @@ Invariants:
     * Assert on callback completion that no level's table count overflows.
     * Flush, clear, and sort mutable table values into immutable table for next bar.
     * Remove input tables that are invisible to all current and persisted snapshots.
+    * Release reservations from the Free Set.
 
 ### Compaction Selection Policy
 
@@ -212,3 +218,91 @@ At the end of the last beat of the compaction bar (`23`):
 - Updates from ops `0→B` (`0…15`) are on disk.
 - Updates from ops `B→C` (`16…23`) are moved from the mutable table to the immutable table.
 - `tree.lookup_snapshot_max` is `x` when committing op `x` (for `x ∈ {24,25,…}`).
+
+
+## Manifest
+
+The manifest is a tree's index of table locations and metadata.
+(Not to be confused with the [SuperBlock Manifest](../vsr/README.md#manifest)).
+
+Each manifest has two components:
+- a single [`ManifestLog`](#manifest-log) shared by all levels, and
+- one [`ManifestLevel`](#manifest-level) for each on-disk level.
+
+### Manifest Log
+
+The manifest log is an on-disk log of all updates to the tree's table index.
+
+The manifest log tracks:
+
+  - tables created as compaction output
+  - tables updated as compaction input (modifying their `snapshot_max`)
+  - tables moved between levels by compaction
+  - tables deleted after compaction
+
+Updates are accumulated in-memory before being flushed:
+
+  - incrementally during compaction, or
+  - in their entirety during checkpoint.
+
+The manifest log is periodically compacted to remove older entries that have been superseded by
+newer entries. For example, if a table is created and later deleted, manifest log compaction
+will eventually remove any reference to the table from the log blocks.
+
+All manifest log blocks are tracked in the superblock manifest.
+
+### Manifest Level
+
+A `ManifestLevel` is an in-memory collection of the table metadata for a single level of a tree.
+
+For a given level and snapshot, there may be gaps in the key ranges of the visible tables,
+but the key ranges are disjoint.
+
+Manifest levels are queried for tables at a target snapshot and within a key range.
+
+#### Example
+
+Given the `ManifestLevel` tables (with values chosen for visualization, not realism):
+
+           label   A   B   C   D   E   F   G   H   I   J   K   L   M
+         key_min   0   4  12  16   4   8  12  26   4  25   4  16  24
+         key_max   3  11  15  19   7  11  15  27   7  27  11  19  27
+    snapshot_min   1   1   1   1   3   3   3   3   5   5   7   7   7
+    snapshot_max   9   3   3   7   5   7   9   5   7   7   9   9   9
+
+A level's tables can be visualized in 2D as a partitioned rectangle:
+
+      0         1         2
+      0   4   8   2   6   0   4   8
+    9┌───┬───────┬───┬───┬───┬───┐
+     │   │   K   │   │ L │###│ M │
+    7│   ├───┬───┤   ├───┤###└┬──┤
+     │   │ I │   │ G │   │####│ J│
+    5│ A ├───┤ F │   │   │####└┬─┤
+     │   │ E │   │   │ D │#####│H│
+    3│   ├───┴───┼───┤   │#####└─┤
+     │   │   B   │ C │   │#######│
+    1└───┴───────┴───┴───┴───────┘
+
+Example iterations:
+
+    visibility  snapshots   direction  key_min  key_max  tables
+       visible          2   ascending        0       28  A, B, C, D
+       visible          4   ascending        0       28  A, E, F, G, D, H
+       visible          6  descending       12       28  J, D, G
+       visible          8   ascending        0       28  A, K, G, L, M
+     invisible    2, 4, 6   ascending        0       28  K, L, M
+
+Legend:
+
+  - `#` represents a gap — no tables cover these keys during the snapshot.
+  - The horizontal axis represents the key range.
+  - The vertical axis represents the snapshot range.
+  - Each rectangle is a table within the manifest level.
+  - The sides of each rectangle depict:
+    - left:   `table.key_min` (the diagram is inclusive, and the `table.key_min` is inclusive)
+    - right:  `table.key_max` (the diagram is EXCLUSIVE, but the `table.key_max` is INCLUSIVE)
+    - bottom: `table.snapshot_min` (inclusive)
+    - top:    `table.snapshot_max` (inclusive)
+  - (Not depicted: tables may have `table.key_min == table.key_max`.)
+  - (Not depicted: the newest set of tables would have `table.snapshot_max == maxInt(u64)`.)

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

@@ -85,7 +85,7 @@ pub fn CompactionType(
         );
 
         const MergeStreamSelector = struct {
-            fn peek(compaction: *const Compaction, stream_id: u32) error{Empty, Drained}!Key {
+            fn peek(compaction: *const Compaction, stream_id: u32) error{ Empty, Drained }!Key {
                 return switch (stream_id) {
                     0 => compaction.iterator_a.peek(),
                     1 => compaction.iterator_b.peek(),
@@ -121,6 +121,7 @@ pub fn CompactionType(
         };
 
         grid: *Grid,
+        grid_reservation: Grid.Reservation,
         range: Manifest.CompactionRange,
 
         /// `op_min` is the first op/beat of this compaction's half-bar.
@@ -152,6 +153,8 @@ pub fn CompactionType(
         level_b: u8,
         level_a_input: ?TableInfo,
 
+        tables_output_count: usize = 0,
+
         pub fn init(allocator: mem.Allocator) !Compaction {
             var iterator_a = try IteratorA.init(allocator);
             errdefer iterator_a.deinit(allocator);
@@ -165,6 +168,7 @@ pub fn CompactionType(
             return Compaction{
                 // Assigned by start()
                 .grid = undefined,
+                .grid_reservation = undefined,
                 .range = undefined,
                 .op_min = undefined,
                 .drop_tombstones = undefined,
@@ -227,6 +231,20 @@ pub fn CompactionType(
 
             compaction.* = .{
                 .grid = grid,
+                // Reserve enough blocks to write our output tables in the worst case, where:
+                // - no tombstones are dropped,
+                // - no values are overwritten,
+                // - and all tables are full.
+                //
+                // We must reserve before doing any async work so that the block acquisition order
+                // is deterministic (relative to other concurrent compactions).
+                // TODO The replica must stop accepting requests if it runs out of blocks/capacity,
+                // rather than panicking here.
+                // TODO(Compaction Pacing): Reserve smaller increments, at the start of each beat.
+                // (And likewise release the reservation at the end of each beat, instead of at the
+                // end of each half-bar).
+                // TODO(Move Table) Don't reserve these when we just move the table to the next level.
+                .grid_reservation = grid.reserve(range.table_count * Table.block_count_max).?,
                 .range = range,
                 .op_min = op_min,
                 .drop_tombstones = drop_tombstones,
@@ -303,12 +321,12 @@ pub fn CompactionType(
             // This is safe; iterator_b makes a copy of the block before calling us.
             const grid = compaction.grid;
             for (Table.index_data_addresses_used(index_block)) |address| {
-                grid.release_at_checkpoint(address);
+                grid.release(address);
             }
             for (Table.index_filter_addresses_used(index_block)) |address| {
-                grid.release_at_checkpoint(address);
+                grid.release(address);
             }
-            grid.release_at_checkpoint(Table.index_block_address(index_block));
+            grid.release(Table.index_block_address(index_block));
         }
 
         pub fn compact_tick(compaction: *Compaction, callback: Callback) void {
@@ -441,7 +459,7 @@ pub fn CompactionType(
             {
                 compaction.table_builder.data_block_finish(.{
                     .cluster = compaction.grid.superblock.working.cluster,
-                    .address = compaction.grid.acquire(),
+                    .address = compaction.grid.acquire(compaction.grid_reservation),
                 });
 
                 // Mark the finished data block as writable for the next compact_tick() call.
@@ -457,7 +475,7 @@ pub fn CompactionType(
             {
                 compaction.table_builder.filter_block_finish(.{
                     .cluster = compaction.grid.superblock.working.cluster,
-                    .address = compaction.grid.acquire(),
+                    .address = compaction.grid.acquire(compaction.grid_reservation),
                 });
 
                 // Mark the finished filter block as writable for the next compact_tick() call.
@@ -473,7 +491,7 @@ pub fn CompactionType(
             {
                 const table = compaction.table_builder.index_block_finish(.{
                     .cluster = compaction.grid.superblock.working.cluster,
-                    .address = compaction.grid.acquire(),
+                    .address = compaction.grid.acquire(compaction.grid_reservation),
                     .snapshot_min = snapshot_min_for_table_output(compaction.op_min),
                     // TODO(Persistent Snapshots) set snapshot_max to the minimum snapshot_max of
                     // all the (original) input tables.
@@ -484,6 +502,9 @@ pub fn CompactionType(
                 compaction.index.block = compaction.table_builder.index_block;
                 assert(!compaction.index.writable);
                 compaction.index.writable = true;
+
+                compaction.tables_output_count += 1;
+                assert(compaction.tables_output_count <= compaction.range.table_count);
             }
         }
 
@@ -540,6 +561,10 @@ pub fn CompactionType(
             assert(compaction.io_pending == 0);
             assert(compaction.merge_done);
 
+            // TODO(Beat Pacing) This should really be where the compaction callback is invoked,
+            // but currently that can occur multiple times per beat.
+            compaction.grid.forfeit(compaction.grid_reservation);
+
             compaction.status = .idle;
             compaction.merge_done = false;
         }

package/src/tigerbeetle/src/{eytzinger_benchmark.zig → lsm/eytzinger_benchmark.zig}

@@ -2,9 +2,9 @@ const std = @import("std");
 const assert = std.debug.assert;
 const math = std.math;
 
-const binary_search = @import("./binary_search.zig").binary_search;
+const binary_search_keys_raw = @import("./binary_search.zig").binary_search_keys_raw;
+const binary_search_values_raw = @import("./binary_search.zig").binary_search_values_raw;
 const eytzinger = @import("./eytzinger.zig").eytzinger;
-const perf = @import("./benchmarks/perf.zig");
 
 const GiB = 1 << 30;
 const searches = 500_000;
@@ -53,7 +53,7 @@ pub fn main() !void {
     defer arena.deinit();
 
     const blob_size = GiB;
-    var blob = try arena.allocator.alloc(u8, blob_size);
+    var blob = try arena.allocator().alloc(u8, blob_size);
 
     inline for (kv_types) |kv| {
         inline for (values_per_page) |values_count, v| {
@@ -65,13 +65,13 @@ pub fn main() !void {
                     .keys_count = keys_count,
                     .values_count = values_count,
                     .searches = searches,
-                }, blob, &prng.random);
+                }, blob, prng.random());
             }
         }
     }
 }
 
-fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random) !void {
+fn run_benchmark(comptime layout: Layout, blob: []u8, random: std.rand.Random) !void {
     assert(blob.len == layout.blob_size);
     const Eytzinger = eytzinger(layout.keys_count - 1, layout.values_count);
     const V = Value(layout);
@@ -88,7 +88,7 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
 
     // Generate 1GiB worth of 24KiB pages.
     var blob_alloc = std.heap.FixedBufferAllocator.init(blob);
-    var pages = try blob_alloc.allocator.alloc(Page, page_count);
+    var pages = try blob_alloc.allocator().alloc(Page, page_count);
     random.bytes(std.mem.sliceAsBytes(pages));
     for (pages) |*page| {
         for (page.values) |*value, i| value.key = i;
@@ -105,7 +105,17 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_index];
             const bounds = Eytzinger.search_values(K, V, V.key_compare, &page.keys, &page.values, target);
-            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target, .{})];
+            const hit = bounds[
+                binary_search_values_raw(
+                    K,
+                    V,
+                    V.key_from_value,
+                    V.key_compare,
+                    bounds,
+                    target,
+                    .{},
+                )
+            ];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -136,7 +146,17 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
         while (i < layout.searches) : (i += 1) {
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_picker[i % page_picker.len]];
-            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target, .{})];
+            const hit = page.values[
+                binary_search_values_raw(
+                    K,
+                    V,
+                    V.key_from_value,
+                    V.key_compare,
+                    page.values[0..],
+                    target,
+                    .{},
+                )
+            ];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -182,14 +202,10 @@ fn Value(comptime layout: Layout) type {
             assert(@sizeOf(Self) == layout.value_size);
         }
 
-        inline fn key_from_value(self: Self) Key {
+        inline fn key_from_value(self: *const Self) Key {
             return self.key;
         }
 
-        inline fn key_from_key(x: Key) Key {
-            return x;
-        }
-
         inline fn key_compare(a: Key, b: Key) math.Order {
             return math.order(a, b);
         }
@@ -206,9 +222,7 @@ const BenchmarkResult = struct {
     branch_misses: usize,
 };
 
-const PERF = perf.PERF;
-const perf_event_attr = perf.perf_event_attr;
-const perf_event_open = perf.perf_event_open;
+const PERF = std.os.linux.PERF;
 const perf_counters = [_]PERF.COUNT.HW{
     PERF.COUNT.HW.CPU_CYCLES,
     PERF.COUNT.HW.INSTRUCTIONS,
@@ -223,10 +237,9 @@ const Benchmark = struct {
     perf_fds: [perf_counters.len]std.os.fd_t,
 
     fn begin() !Benchmark {
-        const flags = PERF.FLAG.FD_NO_GROUP;
         var perf_fds = [1]std.os.fd_t{-1} ** perf_counters.len;
         for (perf_counters) |counter, i| {
-            var attr: perf_event_attr = .{
+            var attr: std.os.linux.perf_event_attr = .{
                 .type = PERF.TYPE.HARDWARE,
                 .config = @enumToInt(counter),
                 .flags = .{
@@ -235,7 +248,7 @@ const Benchmark = struct {
                     .exclude_hv = true,
                 },
             };
-            perf_fds[i] = try perf_event_open(&attr, 0, -1, perf_fds[0], PERF.FLAG.FD_CLOEXEC);
+            perf_fds[i] = try std.os.perf_event_open(&attr, 0, -1, perf_fds[0], PERF.FLAG.FD_CLOEXEC);
         }
         const err = std.os.linux.ioctl(perf_fds[0], PERF.EVENT_IOC.ENABLE, PERF.IOC_FLAG_GROUP);
         if (err == -1) return error.Unexpected;
@@ -274,7 +287,7 @@ const Benchmark = struct {
 };
 
 // shuffle([0,1,…,n-1])
-fn shuffled_index(comptime n: usize, rand: *std.rand.Random) [n]usize {
+fn shuffled_index(comptime n: usize, rand: std.rand.Random) [n]usize {
     var indices: [n]usize = undefined;
     for (indices) |*i, j| i.* = j;
     rand.shuffle(usize, indices[0..]);
@@ -307,7 +320,7 @@ fn binary_search_keys(
     assert(keys.len == layout.keys_count);
     assert(values.len == layout.values_count);
 
-    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key, .{});
+    const key_index = binary_search_keys_raw(Key, compare_keys, keys, key, .{});
     const key_stride = layout.values_count / layout.keys_count;
     const high = key_index * key_stride;
     if (key_index < keys.len and keys[key_index] == key) {

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

@@ -38,7 +38,10 @@ const Environment = struct {
     const cluster = 32;
     const replica = 4;
     // TODO Is this appropriate for the number of fuzz_ops we want to run?
-    const size_max = vsr.Zone.superblock.size().? + vsr.Zone.wal.size().? + 1024 * 1024 * 1024;
+    const size_max = vsr.Zone.superblock.size().? +
+        vsr.Zone.wal_headers.size().? +
+        vsr.Zone.wal_prepares.size().? +
+        1024 * 1024 * 1024;
 
     const node_count = 1024;
     // This is the smallest size that set_associative_cache will allow us.
@@ -80,6 +83,7 @@ const Environment = struct {
     forest: Forest,
     // We need @fieldParentPtr() of forest, so we can't use an optional Forest.
     forest_exists: bool,
+    checkpoint_op: ?u64 = null,
 
     fn init(env: *Environment, storage: *Storage) !void {
         env.state = .uninit;
@@ -184,7 +188,8 @@ const Environment = struct {
         env.change_state(.forest_compacting, .forest_open);
     }
 
-    pub fn checkpoint(env: *Environment) void {
+    pub fn checkpoint(env: *Environment, op: u64) void {
+        env.checkpoint_op = op - config.lsm_batch_multiple;
         env.change_state(.forest_open, .forest_checkpointing);
         env.forest.checkpoint(forest_checkpoint_callback);
         env.tick_until_state_change(.forest_checkpointing, .superblock_checkpointing);
@@ -194,7 +199,14 @@ const Environment = struct {
     fn forest_checkpoint_callback(forest: *Forest) void {
         const env = @fieldParentPtr(@This(), "forest", forest);
         env.change_state(.forest_checkpointing, .superblock_checkpointing);
-        env.superblock.checkpoint(superblock_checkpoint_callback, &env.superblock_context);
+        env.superblock.checkpoint(superblock_checkpoint_callback, &env.superblock_context, .{
+            .commit_min_checksum = env.superblock.working.vsr_state.commit_min_checksum + 1,
+            .commit_min = env.checkpoint_op.?,
+            .commit_max = env.checkpoint_op.? + 1,
+            .view_normal = 0,
+            .view = 0,
+        });
+        env.checkpoint_op = null;
     }
 
     fn superblock_checkpoint_callback(superblock_context: *SuperBlock.Context) void {
@@ -236,17 +248,17 @@ const Environment = struct {
 
         for (fuzz_ops) |fuzz_op, fuzz_op_index| {
             log.debug("Running fuzz_ops[{}/{}] == {}", .{ fuzz_op_index, fuzz_ops.len, fuzz_op });
-            //TODO(@djg) Restore these when dj-vopr-workload merges.
-            //const storage_size_used = storage.size_used();
-            //log.debug("storage.size_used = {}/{}", .{ storage_size_used, storage.size });
-            //const model_size = model.count() * @sizeOf(Account);
-            //log.debug("space_amplification = {d:.2}", .{@intToFloat(f64, storage_size_used) / @intToFloat(f64, model_size)});
+            const storage_size_used = storage.size_used();
+            log.debug("storage.size_used = {}/{}", .{ storage_size_used, storage.size });
+            const model_size = model.count() * @sizeOf(Account);
+            log.debug("space_amplification = {d:.2}", .{
+                @intToFloat(f64, storage_size_used) / @intToFloat(f64, model_size),
+            });
             // Apply fuzz_op to the forest and the model.
             switch (fuzz_op) {
                 .compact => |compact| {
                     env.compact(compact.op);
-                    if (compact.checkpoint)
-                        env.checkpoint();
+                    if (compact.checkpoint) env.checkpoint(compact.op);
                 },
                 .put_account => |account| {
                     env.forest.grooves.accounts.put(&account);
@@ -274,27 +286,9 @@ const Environment = struct {
     }
 };
 
-pub fn run_fuzz_ops(fuzz_ops: []const FuzzOp) !void {
+pub fn run_fuzz_ops(storage_options: Storage.Options, fuzz_ops: []const FuzzOp) !void {
     // Init mocked storage.
-    var storage = try Storage.init(
-        allocator,
-        Environment.size_max,
-        Storage.Options{
-            // We don't apply storage faults yet, so this seed doesn't matter.
-            .seed = 0xdeadbeef,
-            .read_latency_min = 0,
-            .read_latency_mean = 0,
-            .write_latency_min = 0,
-            .write_latency_mean = 0,
-            .read_fault_probability = 0,
-            .write_fault_probability = 0,
-        },
-        0,
-        .{
-            .first_offset = 0,
-            .period = 0,
-        },
-    );
+    var storage = try Storage.init(allocator, Environment.size_max, storage_options);
     defer storage.deinit(allocator);
 
     try Environment.format(&storage);
@@ -354,6 +348,7 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
                 const checkpoint =
                     // Can only checkpoint on the last beat of the bar.
                     compact_op % config.lsm_batch_multiple == config.lsm_batch_multiple - 1 and
+                    compact_op > config.lsm_batch_multiple and
                     // Checkpoint at roughly the same rate as log wraparound.
                     random.uintLessThan(usize, Environment.compacts_per_checkpoint) == 0;
                 break :compact FuzzOp{
@@ -402,11 +397,18 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 pub fn main() !void {
     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(rng.random());
+    const fuzz_ops = try generate_fuzz_ops(random);
     defer allocator.free(fuzz_ops);
 
-    try run_fuzz_ops(fuzz_ops);
+    try run_fuzz_ops(Storage.Options{
+        .seed = random.int(u64),
+        .read_latency_min = 0,
+        .read_latency_mean = 0 + fuzz.random_int_exponential(random, u64, 20),
+        .write_latency_min = 0,
+        .write_latency_mean = 0 + fuzz.random_int_exponential(random, u64, 20),
+    }, fuzz_ops);
 
     log.info("Passed!", .{});
 }