tigerbeetle-node 0.11.5 → 0.11.7

package/src/tigerbeetle/src/vsr/replica_format.zig

@@ -28,8 +28,6 @@ pub fn format(
         .{
             .cluster = cluster,
             .replica = replica,
-            // TODO Convert this to a runtime arg, to cap storage.
-            .size_max = constants.size_max,
         },
     );
 
@@ -151,6 +149,7 @@ fn ReplicaFormatType(comptime Storage: type) type {
 
 test "format" {
     const superblock_zone_size = @import("./superblock.zig").superblock_zone_size;
+    const data_file_size_min = @import("./superblock.zig").data_file_size_min;
     const MessagePool = @import("../message_pool.zig").MessagePool;
     const Storage = @import("../test/storage.zig").Storage;
     const SuperBlock = vsr.SuperBlockType(Storage);
@@ -173,7 +172,11 @@ test "format" {
     var message_pool = try MessagePool.init(allocator, .replica);
     defer message_pool.deinit(allocator);
 
-    var superblock = try SuperBlock.init(allocator, &storage, &message_pool);
+    var superblock = try SuperBlock.init(allocator, .{
+        .storage = &storage,
+        .storage_size_limit = data_file_size_min,
+        .message_pool = &message_pool,
+    });
     defer superblock.deinit(allocator);
 
     try format(Storage, allocator, cluster, replica, &storage, &superblock);
@@ -186,7 +189,7 @@ test "format" {
         try std.testing.expectEqual(sector.copy, copy);
         try std.testing.expectEqual(sector.replica, replica);
         try std.testing.expectEqual(sector.cluster, cluster);
-        try std.testing.expectEqual(sector.size, storage.size);
+        try std.testing.expectEqual(sector.storage_size, storage.size);
         try std.testing.expectEqual(sector.sequence, 1);
         try std.testing.expectEqual(sector.vsr_state.commit_min, 0);
         try std.testing.expectEqual(sector.vsr_state.commit_max, 0);

package/src/tigerbeetle/src/vsr/superblock.zig

@@ -52,11 +52,12 @@ pub const SuperBlockSector = extern struct {
     cluster: u32,
 
     /// The current size of the data file.
-    size: u64,
+    storage_size: u64,
 
-    /// The maximum size of the data file.
-    // TODO Actually limit the file to this size.
-    size_max: u64,
+    /// The maximum possible size of the data file.
+    /// The maximum allowed runtime storage_size_limit.
+    /// The FreeSet's on-disk size is a function of storage_size_max.
+    storage_size_max: u64,
 
     /// A monotonically increasing counter to locate the latest superblock at startup.
     sequence: u64,
@@ -245,8 +246,8 @@ pub const SuperBlockSector = extern struct {
         if (a.version != b.version) return false;
         if (a.replica != b.replica) return false;
         if (a.cluster != b.cluster) return false;
-        if (a.size != b.size) return false;
-        if (a.size_max != b.size_max) return false;
+        if (a.storage_size != b.storage_size) return false;
+        if (a.storage_size_max != b.storage_size_max) return false;
         if (a.sequence != b.sequence) return false;
         if (a.parent != b.parent) return false;
         if (a.manifest_checksum != b.manifest_checksum) return false;
@@ -321,25 +322,50 @@ pub const superblock_trailer_manifest_size_max = blk: {
 };
 
 pub const superblock_trailer_free_set_size_max = blk: {
-    const encode_size_max = SuperBlockFreeSet.encode_size_max(constants.block_count_max);
+    const encode_size_max = SuperBlockFreeSet.encode_size_max(block_count_max);
     assert(encode_size_max > 0);
 
-    // Round up to the nearest sector:
-    break :blk div_ceil(encode_size_max, constants.sector_size) * constants.sector_size;
+    break :blk vsr.sector_ceil(encode_size_max);
 };
 
 pub const superblock_trailer_client_table_size_max = blk: {
     const encode_size_max = SuperBlockClientTable.encode_size_max;
     assert(encode_size_max > 0);
 
-    // Round up to the nearest sector:
-    break :blk div_ceil(encode_size_max, constants.sector_size) * constants.sector_size;
+    break :blk vsr.sector_ceil(encode_size_max);
 };
 
 pub const data_file_size_min = blk: {
     break :blk superblock_zone_size + constants.journal_size_max;
 };
 
+/// The maximum number of blocks in the grid.
+const block_count_max = blk: {
+    var size = constants.storage_size_max;
+    size -= constants.superblock_copies * @sizeOf(SuperBlockSector);
+    size -= constants.superblock_copies * superblock_trailer_client_table_size_max;
+    size -= constants.superblock_copies * superblock_trailer_manifest_size_max;
+    size -= constants.journal_size_max;
+    // At this point, the remainder of size is split between the grid and the freeset copies.
+    // The size of a freeset is related to the number of blocks it must store.
+    // Maximize the number of grid blocks.
+
+    var shard_count = @divFloor(size, constants.block_size * SuperBlockFreeSet.shard_bits);
+    while (true) : (shard_count -= 1) {
+        const block_count = shard_count * SuperBlockFreeSet.shard_bits;
+        const grid_size = block_count * constants.block_size;
+        const free_set_size = vsr.sector_ceil(SuperBlockFreeSet.encode_size_max(block_count));
+        const free_sets_size = constants.superblock_copies * free_set_size;
+        if (free_sets_size + grid_size <= size) break;
+    }
+    break :blk shard_count * SuperBlockFreeSet.shard_bits;
+};
+
+comptime {
+    assert(block_count_max > 0);
+    assert(block_count_max * constants.block_size + data_file_size_min <= constants.storage_size_max);
+}
+
 /// This table shows the sequence number progression of the SuperBlock's sectors.
 ///
 /// action        working  staging  disk
@@ -441,6 +467,8 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
         /// Whether the superblock has been opened. An open superblock may not be formatted.
         opened: bool = false,
+        block_count_limit: usize,
+        storage_size_limit: u64,
 
         /// Beyond formatting and opening of the superblock, which are mutually exclusive of all
         /// other operations, only the following queue combinations are allowed:
@@ -452,11 +480,24 @@ pub fn SuperBlockType(comptime Storage: type) type {
         queue_head: ?*Context = null,
         queue_tail: ?*Context = null,
 
-        pub fn init(
-            allocator: mem.Allocator,
+        pub const Options = struct {
             storage: *Storage,
             message_pool: *MessagePool,
-        ) !SuperBlock {
+            storage_size_limit: u64,
+        };
+
+        pub fn init(allocator: mem.Allocator, options: Options) !SuperBlock {
+            assert(options.storage_size_limit >= data_file_size_min);
+            assert(options.storage_size_limit <= constants.storage_size_max);
+            assert(options.storage_size_limit % constants.sector_size == 0);
+
+            const shard_count_limit = @intCast(usize, @divFloor(
+                options.storage_size_limit - data_file_size_min,
+                constants.block_size * FreeSet.shard_bits,
+            ));
+            const block_count_limit = shard_count_limit * FreeSet.shard_bits;
+            assert(block_count_limit <= block_count_max);
+
             const a = try allocator.allocAdvanced(SuperBlockSector, constants.sector_size, 1, .exact);
             errdefer allocator.free(a);
 
@@ -481,10 +522,10 @@ pub fn SuperBlockType(comptime Storage: type) type {
             );
             errdefer manifest.deinit(allocator);
 
-            var free_set = try FreeSet.init(allocator, constants.block_count_max);
+            var free_set = try FreeSet.init(allocator, block_count_limit);
             errdefer free_set.deinit(allocator);
 
-            var client_table = try ClientTable.init(allocator, message_pool);
+            var client_table = try ClientTable.init(allocator, options.message_pool);
             errdefer client_table.deinit(allocator);
 
             const manifest_buffer = try allocator.allocAdvanced(
@@ -498,7 +539,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             const free_set_buffer = try allocator.allocAdvanced(
                 u8,
                 constants.sector_size,
-                superblock_trailer_free_set_size_max,
+                SuperBlockFreeSet.encode_size_max(block_count_limit),
                 .exact,
             );
             errdefer allocator.free(free_set_buffer);
@@ -512,7 +553,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             errdefer allocator.free(client_table_buffer);
 
             return SuperBlock{
-                .storage = storage,
+                .storage = options.storage,
                 .working = &a[0],
                 .staging = &b[0],
                 .reading = &reading[0],
@@ -522,6 +563,8 @@ pub fn SuperBlockType(comptime Storage: type) type {
                 .manifest_buffer = manifest_buffer,
                 .free_set_buffer = free_set_buffer,
                 .client_table_buffer = client_table_buffer,
+                .block_count_limit = block_count_limit,
+                .storage_size_limit = options.storage_size_limit,
             };
         }
 
@@ -542,9 +585,6 @@ pub fn SuperBlockType(comptime Storage: type) type {
         pub const FormatOptions = struct {
             cluster: u32,
             replica: u8,
-
-            /// The maximum size of the entire data file.
-            size_max: u64,
         };
 
         pub fn format(
@@ -556,8 +596,6 @@ pub fn SuperBlockType(comptime Storage: type) type {
             assert(!superblock.opened);
 
             assert(options.replica < constants.replicas_max);
-            assert(options.size_max >= data_file_size_min);
-            assert(options.size_max % constants.sector_size == 0);
 
             // This working copy provides the parent checksum, and will not be written to disk.
             // We therefore use zero values to make this parent checksum as stable as possible.
@@ -567,8 +605,8 @@ pub fn SuperBlockType(comptime Storage: type) type {
                 .sequence = 0,
                 .replica = options.replica,
                 .cluster = options.cluster,
-                .size = 0,
-                .size_max = options.size_max,
+                .storage_size = 0,
+                .storage_size_max = constants.storage_size_max,
                 .parent = 0,
                 .manifest_checksum = 0,
                 .free_set_checksum = 0,
@@ -757,7 +795,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
         fn write_staging_encode_free_set(superblock: *SuperBlock) void {
             const staging: *SuperBlockSector = superblock.staging;
-            const encode_size_max = FreeSet.encode_size_max(constants.block_count_max);
+            const encode_size_max = FreeSet.encode_size_max(superblock.block_count_limit);
             const target = superblock.free_set_buffer[0..encode_size_max];
 
             superblock.free_set.include_staging();
@@ -765,15 +803,23 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             superblock.verify_manifest_blocks_are_acquired_in_free_set();
 
-            staging.size = data_file_size_min;
+            staging.storage_size = data_file_size_min;
 
             if (superblock.free_set.highest_address_acquired()) |address| {
-                staging.size += address * constants.block_size;
+                staging.storage_size += address * constants.block_size;
+            }
+            assert(staging.storage_size >= data_file_size_min);
+            assert(staging.storage_size <= staging.storage_size_max);
+            assert(staging.storage_size <= superblock.storage_size_limit);
+
+            if (superblock.free_set.count_acquired() == 0) {
+                // EWAH encodes a zero-length bitset to an empty slice anyway, but handle this
+                // condition separately so that during formatting it doesn't depend on the choice
+                // of storage_size_limit.
+                staging.free_set_size = 0;
+            } else {
+                staging.free_set_size = @intCast(u32, superblock.free_set.encode(target));
             }
-            assert(staging.size >= data_file_size_min);
-            assert(staging.size <= staging.size_max);
-
-            staging.free_set_size = @intCast(u32, superblock.free_set.encode(target));
             staging.free_set_checksum = vsr.checksum(target[0..staging.free_set_size]);
         }
 
@@ -930,8 +976,8 @@ pub fn SuperBlockType(comptime Storage: type) type {
             assert(superblock.staging.cluster == superblock.working.cluster);
             assert(superblock.staging.replica == superblock.working.replica);
 
-            assert(superblock.staging.size >= data_file_size_min);
-            assert(superblock.staging.size <= superblock.staging.size_max);
+            assert(superblock.staging.storage_size >= data_file_size_min);
+            assert(superblock.staging.storage_size <= superblock.staging.storage_size_max);
 
             assert(context.copy.? < constants.superblock_copies);
             superblock.staging.copy = context.copy.?;
@@ -1059,6 +1105,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             if (superblock.quorums.working(superblock.reading, threshold)) |quorum| {
                 assert(quorum.valid);
                 assert(quorum.copies.count() >= threshold.count());
+                assert(quorum.sector.storage_size_max == constants.storage_size_max);
 
                 const working = quorum.sector;
                 if (threshold == .verify) {
@@ -1070,9 +1117,9 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
                 if (context.caller == .format) {
                     assert(working.sequence == 1);
-                    assert(working.size == data_file_size_min);
+                    assert(working.storage_size == data_file_size_min);
                     assert(working.manifest_size == 0);
-                    assert(working.free_set_size == 8);
+                    assert(working.free_set_size == 0);
                     assert(working.client_table_size == 4);
                     assert(working.vsr_state.commit_min_checksum ==
                         vsr.Header.root_prepare(working.cluster).checksum);
@@ -1097,7 +1144,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
                         superblock.working.sequence,
                         superblock.working.cluster,
                         superblock.working.replica,
-                        superblock.working.size,
+                        superblock.working.storage_size,
                         superblock.working.vsr_state.commit_min_checksum,
                         superblock.working.vsr_state.commit_min,
                         superblock.working.vsr_state.commit_max,
@@ -1246,9 +1293,10 @@ pub fn SuperBlockType(comptime Storage: type) type {
             if (vsr.checksum(slice) == superblock.working.free_set_checksum) {
                 superblock.free_set.decode(slice);
 
-                log.debug("open: read_free_set: acquired blocks: {}/{}", .{
+                log.debug("open: read_free_set: acquired blocks: {}/{}/{}", .{
                     superblock.free_set.count_acquired(),
-                    constants.block_count_max,
+                    superblock.block_count_limit,
+                    block_count_max,
                 });
 
                 superblock.verify_manifest_blocks_are_acquired_in_free_set();