tigerbeetle-node 0.11.0 → 0.11.1

package/src/tigerbeetle/src/lsm/segmented_array.zig

@@ -4,6 +4,7 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
+const util = @import("../util.zig");
 const div_ceil = @import("../util.zig").div_ceil;
 const binary_search_values_raw = @import("binary_search.zig").binary_search_values_raw;
 const binary_search_keys = @import("binary_search.zig").binary_search_keys;
@@ -279,12 +280,13 @@ fn SegmentedArrayType(
 
             const total = array.count(a) + @intCast(u32, elements.len);
             if (total <= node_capacity) {
-                mem.copyBackwards(
+                util.copy_right(
+                    .inexact,
                     T,
                     a_pointer[cursor.relative_index + elements.len ..],
                     a_pointer[cursor.relative_index..array.count(a)],
                 );
-                mem.copy(T, a_pointer[cursor.relative_index..], elements);
+                util.copy_disjoint(.inexact, T, a_pointer[cursor.relative_index..], elements);
 
                 array.increment_indexes_after(a, @intCast(u32, elements.len));
                 return;
@@ -346,7 +348,8 @@ fn SegmentedArrayType(
 
             if (a_half < cursor.relative_index) {
                 // Move the part of `a` that is past the half-way point into `b`.
-                mem.copyBackwards(
+                util.copy_right(
+                    .inexact,
                     T,
                     b_half_pointer,
                     a_pointer[a_half..cursor.relative_index],
@@ -380,10 +383,10 @@ fn SegmentedArrayType(
             const source_a = source[0..target_a.len];
             const source_b = source[target_a.len..];
             if (target_b.ptr != source_b.ptr) {
-                mem.copyBackwards(T, target_b, source_b);
+                util.copy_right(.exact, T, target_b, source_b);
             }
             if (target_a.ptr != source_a.ptr) {
-                mem.copyBackwards(T, target_a, source_a);
+                util.copy_right(.exact, T, target_a, source_a);
             }
         }
 
@@ -392,12 +395,14 @@ fn SegmentedArrayType(
             assert(node <= array.node_count);
             assert(array.node_count + 1 <= node_count_max);
 
-            mem.copyBackwards(
+            util.copy_right(
+                .exact,
                 ?*[node_capacity]T,
                 array.nodes[node + 1 .. array.node_count + 1],
                 array.nodes[node..array.node_count],
             );
-            mem.copyBackwards(
+            util.copy_right(
+                .exact,
                 u32,
                 array.indexes[node + 1 .. array.node_count + 2],
                 array.indexes[node .. array.node_count + 1],
@@ -465,7 +470,8 @@ fn SegmentedArrayType(
 
             // Remove elements from exactly one node:
             if (a_remaining + remove_count <= array.count(a)) {
-                mem.copy(
+                util.copy_left(
+                    .inexact,
                     T,
                     a_pointer[a_remaining..],
                     a_pointer[a_remaining + remove_count .. array.count(a)],
@@ -491,7 +497,7 @@ fn SegmentedArrayType(
             assert(a_remaining > 0 or b_remaining.len > 0);
 
             if (a_remaining >= half) {
-                mem.copy(T, b_pointer, b_remaining);
+                util.copy_left(.inexact, T, b_pointer, b_remaining);
 
                 array.indexes[b] = array.indexes[a] + a_remaining;
                 array.decrement_indexes_after(b, remove_count);
@@ -508,7 +514,7 @@ fn SegmentedArrayType(
                 assert(a_remaining < half and b_remaining.len < half);
                 assert(a_remaining + b_remaining.len <= node_capacity);
 
-                mem.copy(T, a_pointer[a_remaining..], b_remaining);
+                util.copy_disjoint(.inexact, T, a_pointer[a_remaining..], b_remaining);
 
                 array.indexes[b] = array.indexes[a] + a_remaining + @intCast(u32, b_remaining.len);
                 array.decrement_indexes_after(b, remove_count);
@@ -570,7 +576,7 @@ fn SegmentedArrayType(
 
             const total = array.count(a) + @intCast(u32, b_elements.len);
             if (total <= node_capacity) {
-                mem.copy(T, a_pointer[array.count(a)..], b_elements);
+                util.copy_disjoint(.inexact, T, a_pointer[array.count(a)..], b_elements);
 
                 array.indexes[b] = array.indexes[b + 1];
                 array.remove_empty_node_at(node_pool, b);
@@ -582,12 +588,13 @@ fn SegmentedArrayType(
                 assert(a_half >= b_half);
                 assert(a_half + b_half == total);
 
-                mem.copy(
+                util.copy_disjoint(
+                    .exact,
                     T,
                     a_pointer[array.count(a)..a_half],
                     b_elements[0 .. a_half - array.count(a)],
                 );
-                mem.copy(T, b_pointer, b_elements[a_half - array.count(a) ..]);
+                util.copy_left(.inexact, T, b_pointer, b_elements[a_half - array.count(a) ..]);
 
                 array.indexes[b] = array.indexes[a] + a_half;
 
@@ -609,12 +616,14 @@ fn SegmentedArrayType(
                 @ptrCast(NodePool.Node, @alignCast(NodePool.node_alignment, array.nodes[node].?)),
             );
 
-            mem.copy(
+            util.copy_left(
+                .exact,
                 ?*[node_capacity]T,
                 array.nodes[node .. array.node_count - 1],
                 array.nodes[node + 1 .. array.node_count],
             );
-            mem.copy(
+            util.copy_left(
+                .exact,
                 u32,
                 array.indexes[node..array.node_count],
                 array.indexes[node + 1 .. array.node_count + 1],

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

@@ -8,7 +8,8 @@ const vsr = @import("../vsr.zig");
 const binary_search = @import("binary_search.zig");
 const bloom_filter = @import("bloom_filter.zig");
 
-const div_ceil = @import("../util.zig").div_ceil;
+const util = @import("../util.zig");
+const div_ceil = util.div_ceil;
 const eytzinger = @import("eytzinger.zig").eytzinger;
 const snapshot_latest = @import("tree.zig").snapshot_latest;
 
@@ -125,6 +126,8 @@ pub fn TableType(
         const block_body_size = block_size - @sizeOf(vsr.Header);
 
         pub const layout = layout: {
+            @setEvalBranchQuota(10_000);
+
             assert(block_size % config.sector_size == 0);
             assert(math.isPowerOfTwo(table_size_max));
             assert(math.isPowerOfTwo(block_size));
@@ -181,7 +184,8 @@ pub fn TableType(
             assert((block_keys_layout_count * key_size) % config.cache_line_size == 0);
 
             const block_key_layout_size = block_keys_layout_count * key_size;
-            const block_key_count = block_keys_layout_count - 1;
+            const block_key_count =
+                if (block_keys_layout_count == 0) 0 else block_keys_layout_count - 1;
 
             const block_value_count_max = @divFloor(
                 block_body_size - block_key_layout_size,
@@ -199,6 +203,7 @@ pub fn TableType(
             );
 
             // Compute the number of data and filter blocks by solving the constraints:
+            // * the cumulative table size must not exceed lsm_table_size_max
             // * the filter and data blocks' metadata must fix in the index block
             // * the filter blocks must index all data blocks
             // * minimize the number of filter blocks
@@ -233,13 +238,18 @@ pub fn TableType(
                 .filter_block_count_max = filter_blocks,
 
                 // The number of data blocks covered by a single filter block.
-                .filter_data_block_count_max = filter_data_block_count_max,
+                .filter_data_block_count_max = std.math.min(
+                    filter_data_block_count_max,
+                    data_blocks,
+                ),
             };
         };
 
         const index_block_count = 1;
-        const filter_block_count_max = layout.filter_block_count_max;
+        pub const filter_block_count_max = layout.filter_block_count_max;
         pub const data_block_count_max = layout.data_block_count_max;
+        pub const block_count_max =
+            index_block_count + filter_block_count_max + data_block_count_max;
 
         const index = struct {
             const size = @sizeOf(vsr.Header) + filter_checksums_size + data_checksums_size +
@@ -504,7 +514,7 @@ pub fn TableType(
                 const values_max = data_block_values(builder.data_block);
                 assert(values_max.len == data.value_count_max);
 
-                mem.copy(Value, values_max[builder.value..], values);
+                util.copy_disjoint(.inexact, Value, values_max[builder.value..], values);
                 builder.value += @intCast(u32, values.len);
 
                 for (values) |*value| {
@@ -552,21 +562,23 @@ pub fn TableType(
                 }
 
                 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],
-                );
-                const key_layout = mem.bytesAsValue([data.key_count + 1]Key, key_layout_bytes);
-
-                const e = eytzinger(data.key_count, data.value_count_max);
-                e.layout_from_keys_or_values(
-                    Key,
-                    Value,
-                    key_from_value,
-                    sentinel_key,
-                    values,
-                    key_layout,
-                );
+                if (data.key_count > 0) {
+                    const key_layout_bytes = @alignCast(
+                        @alignOf(Key),
+                        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);
+                    e.layout_from_keys_or_values(
+                        Key,
+                        Value,
+                        key_from_value,
+                        sentinel_key,
+                        values,
+                        key_layout,
+                    );
+                }
 
                 const values_padding = mem.sliceAsBytes(values_max[builder.value..]);
                 const block_padding = block[data.padding_offset..][0..data.padding_size];

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

@@ -187,7 +187,7 @@ pub fn TableImmutableIteratorType(comptime Table: type, comptime Storage: type)
             return true; // All values are "buffered" in memory.
         }
 
-        pub fn peek(it: *const TableImmutableIterator) error{Empty, Drained}!Table.Key {
+        pub fn peek(it: *const TableImmutableIterator) error{ Empty, Drained }!Table.Key {
             // NOTE: This iterator is never Drained as all values are in memory (tick is a no-op).
             assert(!it.table.free);
             if (it.values_index == it.table.values.len) return error.Empty;

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

@@ -5,6 +5,7 @@ const assert = std.debug.assert;
 
 const config = @import("../config.zig");
 
+const util = @import("../util.zig");
 const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
 const ManifestType = @import("manifest.zig").ManifestType;
 const GridType = @import("grid.zig").GridType;
@@ -90,8 +91,6 @@ pub fn TableIteratorType(comptime Table: type, comptime Storage: type) type {
         }
 
         pub fn deinit(it: *TableIterator, allocator: mem.Allocator) void {
-            assert(!it.read_pending);
-
             allocator.free(it.index_block);
             it.values.deinit(allocator);
             for (it.data_blocks.buffer) |block| allocator.free(block);
@@ -186,7 +185,7 @@ pub fn TableIteratorType(comptime Table: type, comptime Storage: type) type {
 
             // Copy the bytes read into a buffer owned by the iterator since the Grid
             // only guarantees the provided pointer to be valid in this callback.
-            mem.copy(u8, it.index_block, block);
+            util.copy_disjoint(.exact, u8, it.index_block, block);
 
             if (it.index_block_callback) |callback| {
                 it.index_block_callback = null;
@@ -218,7 +217,7 @@ pub fn TableIteratorType(comptime Table: type, comptime Storage: type) type {
 
             // Copy the bytes read into a buffer owned by the iterator since the Grid
             // only guarantees the provided pointer to be valid in this callback.
-            mem.copy(u8, it.data_blocks.next_tail().?, block);
+            util.copy_disjoint(.exact, u8, it.data_blocks.next_tail().?, block);
 
             it.data_blocks.advance_tail();
             it.data_block_index += 1;
@@ -264,7 +263,7 @@ pub fn TableIteratorType(comptime Table: type, comptime Storage: type) type {
         /// - error.Empty when there are no values remaining to iterate.
         /// - error.Drained when the iterator isn't empty, but some values 
         ///   still need to be buffered into memory via tick().
-        pub fn peek(it: TableIterator) error{Empty, Drained}!Table.Key {
+        pub fn peek(it: TableIterator) error{ Empty, Drained }!Table.Key {
             assert(!it.read_pending);
             assert(!it.read_table_index);
 

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

@@ -27,7 +27,10 @@ const SuperBlock = vsr.SuperBlockType(Storage);
 const Environment = struct {
     const cluster = 32;
     const replica = 4;
-    const size_max = vsr.Zone.superblock.size().? + vsr.Zone.wal.size().? + (512 + 64) * 1024 * 1024;
+    const size_max = vsr.Zone.superblock.size().? +
+        vsr.Zone.wal_headers.size().? +
+        vsr.Zone.wal_prepares.size().? +
+        (512 + 64) * 1024 * 1024;
 
     const node_count = 1024;
     const cache_entries_max = 2 * 1024 * 1024;
@@ -196,8 +199,16 @@ const Environment = struct {
 
         log.debug("forest checkpointing completed!", .{});
 
+        var vsr_state = env.superblock.staging.vsr_state;
+        vsr_state.commit_min += 1;
+        vsr_state.commit_min_checkpoint += 1;
+
         env.state = .superblock_checkpointing;
-        env.superblock.checkpoint(superblock_checkpoint_callback, &env.superblock_context);
+        env.superblock.checkpoint(
+            superblock_checkpoint_callback,
+            &env.superblock_context,
+            vsr_state,
+        );
     }
 
     fn superblock_checkpoint_callback(superblock_context: *SuperBlock.Context) void {

package/src/tigerbeetle/src/lsm/tree.zig

@@ -51,6 +51,21 @@ const half_bar_beat_count = @divExact(config.lsm_batch_multiple, 2);
 /// The maximum number of tables for a single tree.
 pub const table_count_max = table_count_max_for_tree(config.lsm_growth_factor, config.lsm_levels);
 
+/// The upper-bound count of input tables to a single tree's compaction.
+///
+/// - +1 from level A.
+/// - +lsm_growth_factor from level B. The A-input table cannot overlap with an extra B-input table
+///   because input table selection is least-overlap. If the input table overlaps on one or both
+///   edges, there must be another table with less overlap to select.
+pub const compaction_tables_input_max = 1 + config.lsm_growth_factor;
+
+/// The upper-bound count of output tables from a single tree's compaction.
+/// In the "worst" case, no keys are overwritten/merged, and no tombstones are dropped.
+pub const compaction_tables_output_max = compaction_tables_input_max;
+
+/// The maximum number of concurrent compactions (per tree).
+pub const compactions_max = div_ceil(config.lsm_levels, 2);
+
 pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_name: []const u8) type {
     const Key = TreeTable.Key;
     const Value = TreeTable.Value;
@@ -490,6 +505,21 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
 
             tree.compaction_op = op;
 
+            if (op < config.lsm_batch_multiple) {
+                // There is nothing to compact for the first measure.
+                // We skip the main compaction code path first compaction bar entirely because it
+                // is a special case — its first beat is 1, not 0.
+
+                tree.lookup_snapshot_max = op + 1;
+                if (op + 1 == config.lsm_batch_multiple) {
+                    tree.compact_mutable_table_into_immutable();
+                }
+
+                // TODO Defer this callback until tick() to avoid stack growth.
+                callback(tree);
+                return;
+            }
+
             if (tree.grid.superblock.working.vsr_state.op_compacted(op)) {
                 // We recovered from a checkpoint, and must avoid replaying one bar of
                 // compactions that were applied before the checkpoint. Repeating these ops'
@@ -497,7 +527,7 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
                 // causing the storage state of the replica to diverge from the cluster.
                 // See also: lookup_snapshot_max_for_checkpoint().
 
-                if (tree.compaction_op + 1 == tree.lookup_snapshot_max) {
+                if (op + 1 == tree.lookup_snapshot_max) {
                     // This is the last op of the skipped compaction bar.
                     // Prepare the immutable table for the next bar — since this state is
                     // in-memory, it cannot be skipped.
@@ -535,6 +565,8 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
                 config.lsm_batch_multiple,
             });
 
+            if (start) tree.manifest.reserve();
+
             // Try to start compacting the immutable table.
             const even_levels = compaction_beat < half_bar_beat_count;
             if (even_levels) {
@@ -571,6 +603,7 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             );
 
             assert(range.table_count >= 1);
+            assert(range.table_count <= compaction_tables_input_max);
             assert(compare_keys(range.key_min, tree.table_immutable.key_min()) != .gt);
             assert(compare_keys(range.key_max, tree.table_immutable.key_max()) != .lt);
 
@@ -595,6 +628,9 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         }
 
         fn compact_start_table(tree: *Tree, op_min: u64, context: CompactionTableContext) void {
+            const compaction_beat = tree.compaction_op % half_bar_beat_count;
+            assert(compaction_beat == 0);
+
             assert(context.level_a < config.lsm_levels);
             assert(context.level_b < config.lsm_levels);
             assert(context.level_a + 1 == context.level_b);
@@ -602,15 +638,15 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             // Do not start compaction if level A does not require compaction.
             const table_range = tree.manifest.compaction_table(context.level_a) orelse return;
             const table = table_range.table;
-            const range = table_range.range;
 
-            assert(range.table_count >= 1);
+            assert(table_range.range.table_count >= 1);
+            assert(table_range.range.table_count <= compaction_tables_input_max);
             assert(compare_keys(table.key_min, table.key_max) != .gt);
-            assert(compare_keys(range.key_min, table.key_min) != .gt);
-            assert(compare_keys(range.key_max, table.key_max) != .lt);
+            assert(compare_keys(table_range.range.key_min, table.key_min) != .gt);
+            assert(compare_keys(table_range.range.key_max, table.key_max) != .lt);
 
             log.debug(tree_name ++ ": compacting {d} tables from level {d} to level {d}", .{
-                range.table_count,
+                table_range.range.table_count,
                 context.level_a,
                 context.level_b,
             });
@@ -888,11 +924,13 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         }
 
         pub fn checkpoint(tree: *Tree, callback: fn (*Tree) void) void {
-            // Assert no outstanding compact_tick() work..
+            // Assert no outstanding compact_tick() work.
             assert(tree.compaction_io_pending == 0);
             assert(tree.compaction_callback == null);
             assert(tree.compaction_op > 0);
             assert(tree.compaction_op + 1 == tree.lookup_snapshot_max);
+            // Don't re-run the checkpoint we recovered from.
+            assert(!tree.grid.superblock.working.vsr_state.op_compacted(tree.compaction_op));
 
             // Assert that this is the last beat in the compaction bar.
             const compaction_beat = tree.compaction_op % config.lsm_batch_multiple;

package/src/tigerbeetle/src/lsm/tree_fuzz.zig

@@ -82,7 +82,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.
@@ -126,6 +129,7 @@ const Environment = struct {
     tree_exists: bool,
     lookup_context: Tree.LookupContext = undefined,
     lookup_value: ?*const Key.Value = null,
+    checkpoint_op: ?u64 = null,
 
     fn init(env: *Environment, storage: *Storage) !void {
         env.state = .uninit;
@@ -238,7 +242,8 @@ const Environment = struct {
         env.change_state(.tree_compacting, .tree_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(.tree_open, .tree_checkpointing);
         env.tree.checkpoint(tree_checkpoint_callback);
         env.tick_until_state_change(.tree_checkpointing, .superblock_checkpointing);
@@ -248,7 +253,14 @@ const Environment = struct {
     fn tree_checkpoint_callback(tree: *Tree) void {
         const env = @fieldParentPtr(@This(), "tree", tree);
         env.change_state(.tree_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 {
@@ -292,17 +304,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(Key.Value);
-            //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(Key.Value);
+            log.debug("space_amplification = {d:.2}", .{
+                @intToFloat(f64, storage_size_used) / @intToFloat(f64, model_size),
+            });
             // Apply fuzz_op to the tree 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 => |value| {
                     env.tree.put(&value);
@@ -333,27 +345,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);
@@ -412,6 +406,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{
@@ -447,11 +442,20 @@ 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);
+    const 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),
+    };
+
+    try run_fuzz_ops(storage_options, fuzz_ops);
 
     log.info("Passed!", .{});
 }

package/src/tigerbeetle/src/main.zig

@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const std = @import("std");
 const assert = std.debug.assert;
 const fmt = std.fmt;
@@ -5,6 +6,7 @@ const mem = std.mem;
 const os = std.os;
 const log = std.log.scoped(.main);
 
+const build_options = @import("tigerbeetle_build_options");
 const config = @import("config.zig");
 pub const log_level: std.log.Level = @intToEnum(std.log.Level, config.log_level);
 
@@ -45,6 +47,7 @@ pub fn main() !void {
     switch (parse_args) {
         .format => |*args| try Command.format(allocator, args.cluster, args.replica, args.path),
         .start => |*args| try Command.start(&arena, args.addresses, args.memory, args.path),
+        .version => |*args| try Command.version(allocator, args.verbose),
     }
 }
 
@@ -123,7 +126,7 @@ const Command = struct {
         defer command.deinit(allocator);
 
         var replica: Replica = undefined;
-        try replica.open(allocator, .{
+        replica.open(allocator, .{
             .replica_count = @intCast(u8, addresses.len),
             .storage = &command.storage,
             .message_pool = &command.message_pool,
@@ -141,7 +144,7 @@ const Command = struct {
             },
         }) catch |err| switch (err) {
             error.NoAddress => fatal("all --addresses must be provided", .{}),
-            else => err,
+            else => |e| return e,
         };
 
         // Calculate how many bytes are allocated inside `arena`.
@@ -173,4 +176,54 @@ const Command = struct {
             try command.io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
         }
     }
+
+    pub fn version(allocator: mem.Allocator, verbose: bool) !void {
+        _ = allocator;
+
+        var stdout_buffer = std.io.bufferedWriter(std.io.getStdOut().writer());
+        const stdout = stdout_buffer.writer();
+        // TODO Pass an actual version number in on build, instead of just saying "experimental".
+        try stdout.writeAll("TigerBeetle version experimental\n");
+
+        if (verbose) {
+            try std.fmt.format(
+                stdout,
+                \\
+                \\git_commit="{s}"
+                \\
+            ,
+                .{build_options.git_commit orelse "?"},
+            );
+
+            try stdout.writeAll("\n");
+            inline for (.{ "zig_version", "mode" }) |declaration| {
+                try print_value(stdout, declaration, @field(builtin, declaration));
+            }
+
+            try stdout.writeAll("\n");
+            inline for (std.meta.declarations(config)) |declaration| {
+                if (!declaration.is_pub) continue;
+                try print_value(stdout, declaration.name, @field(config, declaration.name));
+            }
+        }
+        try stdout_buffer.flush();
+    }
 };
+
+fn print_value(
+    writer: anytype,
+    comptime field: []const u8,
+    comptime value: anytype,
+) !void {
+    if (@typeInfo(@TypeOf(value)) == .Pointer) {
+        try std.fmt.format(writer, "{s}=\"{s}\"\n", .{
+            field,
+            std.fmt.fmtSliceEscapeLower(value),
+        });
+    } else {
+        try std.fmt.format(writer, "{s}={}\n", .{
+            field,
+            value,
+        });
+    }
+}