tigerbeetle-node 0.10.0 → 0.11.1

package/src/tigerbeetle/src/vsr/superblock_client_table.zig

@@ -4,6 +4,7 @@ const mem = std.mem;
 
 const config = @import("../config.zig");
 const vsr = @import("../vsr.zig");
+const util = @import("../util.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 
@@ -45,7 +46,7 @@ pub const ClientTable = struct {
         try entries.ensureTotalCapacity(allocator, @intCast(u32, config.clients_max));
         assert(entries.capacity() >= config.clients_max);
 
-        const sorted = try allocator.alloc(*const Entry, entries.capacity());
+        const sorted = try allocator.alloc(*const Entry, config.clients_max);
         errdefer allocator.free(sorted);
 
         return ClientTable{
@@ -111,7 +112,6 @@ pub const ClientTable = struct {
                 assert(entries_count < client_table.sorted.len);
                 assert(entry.reply.header.command == .reply);
                 client_table.sorted[entries_count] = entry;
-                entries_count += 1;
             }
         }
 
@@ -128,7 +128,7 @@ pub const ClientTable = struct {
         size = new_size;
 
         for (entries) |entry| {
-            mem.copy(u8, target[size..], mem.asBytes(entry.reply.header));
+            util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(entry.reply.header));
             size += @sizeOf(vsr.Header);
         }
 
@@ -138,7 +138,7 @@ pub const ClientTable = struct {
         size = new_size;
 
         for (entries) |entry| {
-            mem.copy(u8, target[size..], mem.asBytes(&entry.session));
+            util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entry.session));
             size += @sizeOf(u64);
         }
 
@@ -150,7 +150,7 @@ pub const ClientTable = struct {
         for (entries) |entry| {
             const body = entry.reply.body();
             assert(body.len == (entry.reply.header.size - @sizeOf(vsr.Header)));
-            mem.copy(u8, target[size..], body);
+            util.copy_disjoint(.inexact, u8, target[size..], body);
             size += body.len;
         }
 
@@ -159,7 +159,7 @@ pub const ClientTable = struct {
         std.mem.set(u8, target[size..new_size], 0);
         size = new_size;
 
-        mem.copy(u8, target[size..], mem.asBytes(&entries_count));
+        util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entries_count));
         size += @sizeOf(u32);
 
         assert(size <= encode_size_max);
@@ -169,7 +169,7 @@ pub const ClientTable = struct {
     pub fn decode(client_table: *ClientTable, source: []align(@alignOf(vsr.Header)) const u8) void {
         // Read the entry count at the end of the buffer to determine how many there are.
         var entries_count: u32 = undefined;
-        mem.copy(u8, mem.asBytes(&entries_count), source[source.len - @sizeOf(u32) ..]);
+        util.copy_disjoint(.exact, u8, mem.asBytes(&entries_count), source[source.len - @sizeOf(u32) ..]);
         assert(entries_count <= client_table.sorted.len);
 
         assert(client_table.count() == 0);
@@ -185,27 +185,25 @@ pub const ClientTable = struct {
         size = std.mem.alignForward(size, @alignOf(vsr.Header));
         const headers = mem.bytesAsSlice(
             vsr.Header,
-            source[size .. entries_count * @sizeOf(vsr.Header)],
+            source[size..][0 .. entries_count * @sizeOf(vsr.Header)],
         );
         size += mem.sliceAsBytes(headers).len;
 
         size = std.mem.alignForward(size, @alignOf(u64));
-        const sessions = mem.bytesAsSlice(u64, source[size .. entries_count * @sizeOf(u64)]);
+        const sessions = mem.bytesAsSlice(u64, source[size..][0 .. entries_count * @sizeOf(u64)]);
         size += mem.sliceAsBytes(sessions).len;
 
         size = std.mem.alignForward(size, @alignOf(u8));
-        var bodies = source[size..];
-        assert(bodies.len > 0);
+        var bodies = source[size .. source.len - @sizeOf(u32)];
 
-        var i: u32 = 0;
-        while (i < entries_count) : (i += 1) {
+        for (headers) |header, i| {
             // Prepare the entry with a message.
             var entry: Entry = undefined;
             entry.reply = client_table.message_pool.get_message();
 
             // Read the header and session for the entry.
             entry.session = sessions[i];
-            entry.reply.header.* = headers[i];
+            entry.reply.header.* = header;
             assert(entry.reply.header.valid_checksum());
             assert(entry.reply.header.command == .reply);
             assert(entry.reply.header.commit >= entry.session);
@@ -216,7 +214,7 @@ pub const ClientTable = struct {
 
             // Read the message body for the entry.
             assert(bodies.len >= body_size);
-            mem.copy(u8, body, bodies[0..body_size]);
+            util.copy_disjoint(.exact, u8, body, bodies[0..body_size]);
             bodies = bodies[body_size..];
             assert(entry.reply.header.valid_checksum_body(body));
 
@@ -230,7 +228,7 @@ pub const ClientTable = struct {
     }
 
     pub fn capacity(client_table: *const ClientTable) usize {
-        return client_table.entries.capacity();
+        return client_table.sorted.len;
     }
 
     pub fn get(client_table: *ClientTable, client: u128) ?*Entry {