tigerbeetle-node 0.11.0 → 0.11.1

package/src/tigerbeetle/src/c/test.zig

@@ -1 +1,371 @@
-// TODO
+const std = @import("std");
+const assert = std.debug.assert;
+
+const testing = std.testing;
+
+const c = @cImport(@cInclude("tb_client.h"));
+
+const util = @import("../util.zig");
+const config = @import("../config.zig");
+const Packet = @import("tb_client/packet.zig").Packet;
+
+const Mutex = std.Thread.Mutex;
+const Condition = std.Thread.Condition;
+
+fn RequestContextType(comptime request_size_max: comptime_int) type {
+    return struct {
+        const Self = @This();
+
+        completion: *Completion,
+        sent_data: [request_size_max]u8 = undefined,
+        sent_data_size: u32,
+        packet: *Packet = undefined,
+        reply: ?struct {
+            tb_context: usize,
+            tb_client: c.tb_client_t,
+            tb_packet: *c.tb_packet_t,
+            result: ?[request_size_max]u8,
+            result_len: u32,
+        } = null,
+
+        pub fn on_complete(
+            tb_context: usize,
+            tb_client: c.tb_client_t,
+            tb_packet: [*c]c.tb_packet_t,
+            result_ptr: [*c]const u8,
+            result_len: u32,
+        ) callconv(.C) void {
+            var self = @ptrCast(*Self, @alignCast(@alignOf(*Self), tb_packet.*.user_data.?));
+            defer self.completion.complete();
+
+            self.reply = .{
+                .tb_context = tb_context,
+                .tb_client = tb_client,
+                .tb_packet = tb_packet,
+                .result = if (result_ptr != null and result_len > 0) blk: {
+                    // Copy the message's body to the context buffer:
+                    assert(result_len <= request_size_max);
+                    var writable: [request_size_max]u8 = undefined;
+                    const readable = @ptrCast([*]const u8, result_ptr.?);
+                    util.copy_disjoint(.inexact, u8, &writable, readable[0..result_len]);
+                    break :blk writable;
+                } else null,
+                .result_len = result_len,
+            };
+        }
+    };
+}
+
+// Notifies the main thread when all pending requests are completed.
+const Completion = struct {
+    const Self = @This();
+
+    pending: usize,
+    mutex: Mutex = .{},
+    cond: Condition = .{},
+
+    pub fn complete(self: *Self) void {
+        self.mutex.lock();
+        defer self.mutex.unlock();
+
+        assert(self.pending > 0);
+        self.pending -= 1;
+        self.cond.signal();
+    }
+
+    pub fn wait_pending(self: *Self) void {
+        self.mutex.lock();
+        defer self.mutex.unlock();
+
+        while (self.pending > 0)
+            self.cond.wait(&self.mutex);
+    }
+};
+
+// When initialized with tb_client_init_echo, the c_client uses a test context that echoes
+// the data back without creating an actual client or connecting to a cluster.
+//
+// This same test should be implemented by all the target programming languages, asserting that:
+// 1. the c_client api was initialized correctly.
+// 2. the application can submit messages and receive replies through the completion callback.
+// 3. the data marshaling is correct, and exactly the same data sent was received back.
+test "c_client echo" {
+    // Using the create_accounts operation for this test.
+    const RequestContext = RequestContextType(config.message_body_size_max);
+    const create_accounts_operation: u8 = c.TB_OP_CREATE_ACCOUNTS;
+    const event_size = @sizeOf(c.tb_account_t);
+    const event_request_max = @divFloor(config.message_body_size_max, event_size);
+
+    // Initializing an echo client for testing purposes.
+    // We ensure that the retry mechanism is being tested
+    // by allowing more simultaneous packets than "client_request_queue_max".
+    var tb_client: c.tb_client_t = undefined;
+    var tb_packet_list: c.tb_packet_list_t = undefined;
+    const cluster_id = 0;
+    const address = "3000";
+    const packets_count: u32 = config.client_request_queue_max * 2;
+    const tb_context: usize = 42;
+    const result = c.tb_client_init_echo(
+        &tb_client,
+        &tb_packet_list,
+        cluster_id,
+        address,
+        @intCast(u32, address.len),
+        packets_count,
+        tb_context,
+        RequestContext.on_complete,
+    );
+
+    try testing.expectEqual(@as(c_uint, c.TB_STATUS_SUCCESS), result);
+    defer c.tb_client_deinit(tb_client);
+
+    var packet_list = @bitCast(Packet.List, tb_packet_list);
+    var prng = std.rand.DefaultPrng.init(tb_context);
+
+    var requests: []RequestContext = try testing.allocator.alloc(RequestContext, packets_count);
+    defer testing.allocator.free(requests);
+
+    // Repeating the same test multiple times to stress the
+    // cycle of message exhaustion followed by completions.
+    const repetitions_max = 100;
+    var repetition: u32 = 0;
+    while (repetition < repetitions_max) : (repetition += 1) {
+        var completion = Completion{ .pending = packets_count };
+
+        // Submitting some random data to be echoed back:
+        for (requests) |*request| {
+            request.* = .{
+                .completion = &completion,
+                .sent_data_size = prng.random().intRangeAtMost(u32, 1, event_request_max) * event_size,
+            };
+            prng.random().bytes(request.sent_data[0..request.sent_data_size]);
+
+            request.packet = blk: {
+                var packet = packet_list.pop().?;
+                packet.operation = create_accounts_operation;
+                packet.user_data = request;
+                packet.data = &request.sent_data;
+                packet.data_size = request.sent_data_size;
+                packet.next = null;
+                packet.status = .ok;
+                break :blk packet;
+            };
+
+            var list = @bitCast(c.tb_packet_list_t, Packet.List.from(request.packet));
+            c.tb_client_submit(tb_client, &list);
+        }
+
+        // Waiting until the c_client thread has processed all submitted requests:
+        completion.wait_pending();
+
+        // Checking if the received echo matches the data we sent:
+        for (requests) |*request| {
+            defer packet_list.push(Packet.List.from(request.packet));
+
+            try testing.expect(request.reply != null);
+            try testing.expectEqual(tb_context, request.reply.?.tb_context);
+            try testing.expectEqual(tb_client, request.reply.?.tb_client);
+            try testing.expectEqual(c.TB_PACKET_OK, @enumToInt(request.packet.status));
+            try testing.expectEqual(@ptrToInt(request.packet), @ptrToInt(request.reply.?.tb_packet));
+            try testing.expect(request.reply.?.result != null);
+            try testing.expectEqual(request.sent_data_size, request.reply.?.result_len);
+
+            const sent_data = request.sent_data[0..request.sent_data_size];
+            const reply = request.reply.?.result.?[0..request.reply.?.result_len];
+            try testing.expectEqualSlices(u8, sent_data, reply);
+        }
+    }
+}
+
+// Asserts the validation rules associated with the "TB_STATUS" enum.
+test "c_client tb_status" {
+    const assert_status = struct {
+        pub fn action(
+            packets_count: u32,
+            addresses: []const u8,
+            expected_status: c_uint,
+        ) !void {
+            var tb_client: c.tb_client_t = undefined;
+            var tb_packet_list: c.tb_packet_list_t = undefined;
+            const cluster_id = 0;
+            const tb_context: usize = 0;
+            const result = c.tb_client_init_echo(
+                &tb_client,
+                &tb_packet_list,
+                cluster_id,
+                addresses.ptr,
+                @intCast(u32, addresses.len),
+                packets_count,
+                tb_context,
+                RequestContextType(0).on_complete,
+            );
+            defer if (result == c.TB_STATUS_SUCCESS) c.tb_client_deinit(tb_client);
+
+            try testing.expectEqual(expected_status, result);
+        }
+    }.action;
+
+    // Valid addresses and packets count should return TB_STATUS_SUCCESS:
+    try assert_status(0, "3000", c.TB_STATUS_SUCCESS);
+    try assert_status(1, "3000", c.TB_STATUS_SUCCESS);
+    try assert_status(32, "127.0.0.1", c.TB_STATUS_SUCCESS);
+    try assert_status(128, "127.0.0.1:3000", c.TB_STATUS_SUCCESS);
+    try assert_status(512, "3000,3001,3002", c.TB_STATUS_SUCCESS);
+    try assert_status(1024, "127.0.0.1,127.0.0.2,172.0.0.3", c.TB_STATUS_SUCCESS);
+    try assert_status(4096, "127.0.0.1:3000,127.0.0.1:3002,127.0.0.1:3003", c.TB_STATUS_SUCCESS);
+
+    // Invalid or empty address should return "TB_STATUS_ADDRESS_INVALID":
+    try assert_status(1, "invalid", c.TB_STATUS_ADDRESS_INVALID);
+    try assert_status(1, "", c.TB_STATUS_ADDRESS_INVALID);
+
+    // More addresses thant "replicas_max" should return "TB_STATUS_ADDRESS_LIMIT_EXCEEDED":
+    try assert_status(
+        1,
+        ("3000," ** config.replicas_max) ++ "3001",
+        c.TB_STATUS_ADDRESS_LIMIT_EXCEEDED,
+    );
+
+    // Packets count greater than 4096 should return "TB_STATUS_INVALID_PACKETS_COUNT":
+    try assert_status(4097, "3000", c.TB_STATUS_PACKETS_COUNT_INVALID);
+    try assert_status(std.math.maxInt(u32), "3000", c.TB_STATUS_PACKETS_COUNT_INVALID);
+
+    // All other status are not testable.
+}
+
+// Asserts the validation rules associated with the "TB_PACKET_STATUS" enum.
+test "c_client tb_packet_status" {
+    const RequestContext = RequestContextType(config.message_body_size_max);
+
+    var tb_client: c.tb_client_t = undefined;
+    var tb_packet_list: c.tb_packet_list_t = undefined;
+    const cluster_id = 0;
+    const address = "3000";
+    const packets_count = 1;
+    const tb_context: usize = 42;
+    const result = c.tb_client_init_echo(
+        &tb_client,
+        &tb_packet_list,
+        cluster_id,
+        address,
+        @intCast(u32, address.len),
+        packets_count,
+        tb_context,
+        RequestContext.on_complete,
+    );
+
+    try testing.expectEqual(@as(c_uint, c.TB_STATUS_SUCCESS), result);
+    defer c.tb_client_deinit(tb_client);
+
+    const assert_result = struct {
+        // Asserts if the packet's status matches the expected status
+        // for a given operation and request_size.
+        pub fn action(
+            client: c.tb_client_t,
+            packet_list: *Packet.List,
+            operation: u8,
+            request_size: u32,
+            tb_packet_status_expected: c_int,
+        ) !void {
+            var completion = Completion{ .pending = 1 };
+            var request = RequestContext{
+                .completion = &completion,
+                .sent_data_size = request_size,
+            };
+
+            request.packet = blk: {
+                var packet = packet_list.pop().?;
+                packet.operation = operation;
+                packet.user_data = &request;
+                packet.data = &request.sent_data;
+                packet.data_size = request_size;
+                packet.next = null;
+                packet.status = .ok;
+                break :blk packet;
+            };
+            defer packet_list.push(Packet.List.from(request.packet));
+
+            var list = @bitCast(c.tb_packet_list_t, Packet.List.from(request.packet));
+            c.tb_client_submit(client, &list);
+
+            completion.wait_pending();
+
+            try testing.expect(request.reply != null);
+            try testing.expectEqual(tb_context, request.reply.?.tb_context);
+            try testing.expectEqual(client, request.reply.?.tb_client);
+            try testing.expectEqual(@ptrToInt(request.packet), @ptrToInt(request.reply.?.tb_packet));
+            try testing.expectEqual(tb_packet_status_expected, @enumToInt(request.packet.status));
+        }
+    }.action;
+
+    var packet_list = @ptrCast(*Packet.List, &tb_packet_list);
+
+    // Messages larger than config.message_body_size_max should return "too_much_data":
+    try assert_result(
+        tb_client,
+        packet_list,
+        c.TB_OP_CREATE_TRANSFERS,
+        config.message_body_size_max + @sizeOf(c.tb_transfer_t),
+        c.TB_PACKET_TOO_MUCH_DATA,
+    );
+
+    // All reserved and unknown operations should return "invalid_operation":
+    try assert_result(
+        tb_client,
+        packet_list,
+        0,
+        @sizeOf(u128),
+        c.TB_PACKET_INVALID_OPERATION,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        1,
+        @sizeOf(u128),
+        c.TB_PACKET_INVALID_OPERATION,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        2,
+        @sizeOf(u128),
+        c.TB_PACKET_INVALID_OPERATION,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        99,
+        @sizeOf(u128),
+        c.TB_PACKET_INVALID_OPERATION,
+    );
+
+    // Messages length 0 or not a multiple of the event size
+    // should return "invalid_data_size":
+    try assert_result(
+        tb_client,
+        packet_list,
+        c.TB_OP_CREATE_ACCOUNTS,
+        0,
+        c.TB_PACKET_INVALID_DATA_SIZE,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        c.TB_OP_CREATE_TRANSFERS,
+        @sizeOf(c.tb_transfer_t) - 1,
+        c.TB_PACKET_INVALID_DATA_SIZE,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        c.TB_OP_LOOKUP_TRANSFERS,
+        @sizeOf(u128) + 1,
+        c.TB_PACKET_INVALID_DATA_SIZE,
+    );
+    try assert_result(
+        tb_client,
+        packet_list,
+        c.TB_OP_LOOKUP_ACCOUNTS,
+        @sizeOf(u128) * 2.5,
+        c.TB_PACKET_INVALID_DATA_SIZE,
+    );
+}

package/src/tigerbeetle/src/cli.zig

@@ -20,13 +20,17 @@ const usage = fmt.comptimePrint(
     \\
     \\  tigerbeetle start --addresses=<addresses> <path>
     \\
+    \\  tigerbeetle version [--version]
+    \\
     \\Commands:
     \\
-    \\  format  Create a TigerBeetle replica data file at <path>.
-    \\          The --cluster and --replica arguments are required.
-    \\          Each TigerBeetle replica must have its own data file.
+    \\  format   Create a TigerBeetle replica data file at <path>.
+    \\           The --cluster and --replica arguments are required.
+    \\           Each TigerBeetle replica must have its own data file.
+    \\
+    \\  start    Run a TigerBeetle replica from the data file at <path>.
     \\
-    \\  start   Run a TigerBeetle replica from the data file at <path>.
+    \\  version  Print the TigerBeetle build version and the compile-time config values.
     \\
     \\Options:
     \\
@@ -46,6 +50,10 @@ const usage = fmt.comptimePrint(
     \\        Either the IPv4 address or port number (but not both) may be omitted,
     \\        in which case a default of {[default_address]s} or {[default_port]d}
     \\        will be used.
+    \\        "addresses[i]" corresponds to replica "i".
+    \\
+    \\  --verbose
+    \\        Print compile-time configuration along with the build version.
     \\
     \\Examples:
     \\
@@ -59,6 +67,8 @@ const usage = fmt.comptimePrint(
     \\
     \\  tigerbeetle start --addresses=192.168.0.1,192.168.0.2,192.168.0.3 7_0.tigerbeetle
     \\
+    \\  tigerbeetle version --verbose
+    \\
 , .{
     .default_address = config.address,
     .default_port = config.port,
@@ -77,11 +87,15 @@ pub const Command = union(enum) {
         memory: u64,
         path: [:0]const u8,
     },
+    version: struct {
+        verbose: bool,
+    },
 
     pub fn deinit(command: Command, allocator: std.mem.Allocator) void {
         var args_allocated = switch (command) {
             .format => |cmd| cmd.args_allocated,
             .start => |cmd| cmd.args_allocated,
+            .version => return,
         };
 
         for (args_allocated.items) |arg| allocator.free(arg);
@@ -97,6 +111,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     var replica: ?[]const u8 = null;
     var addresses: ?[]const u8 = null;
     var memory: ?[]const u8 = null;
+    var verbose: ?bool = null;
 
     var args = try std.process.argsWithAllocator(allocator);
     defer args.deinit();
@@ -110,7 +125,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     assert(did_skip);
 
     const raw_command = try (args.next(allocator) orelse
-        fatal("no command provided, expected 'start' or 'format'", .{}));
+        fatal("no command provided, expected 'start', 'format', or 'version'", .{}));
     defer allocator.free(raw_command);
 
     if (mem.eql(u8, raw_command, "-h") or mem.eql(u8, raw_command, "--help")) {
@@ -118,7 +133,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         os.exit(0);
     }
     const command = meta.stringToEnum(meta.Tag(Command), raw_command) orelse
-        fatal("unknown command '{s}', expected 'start' or 'format'", .{raw_command});
+        fatal("unknown command '{s}', expected 'start', 'format', or 'version'", .{raw_command});
 
     while (args.next(allocator)) |parsed_arg| {
         const arg = try parsed_arg;
@@ -132,6 +147,8 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
             addresses = parse_flag("--addresses", arg);
         } else if (mem.startsWith(u8, arg, "--memory")) {
             memory = parse_flag("--memory", arg);
+        } else if (mem.eql(u8, arg, "--verbose")) {
+            verbose = true;
         } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
             std.io.getStdOut().writeAll(usage) catch os.exit(1);
             os.exit(0);
@@ -145,9 +162,21 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     }
 
     switch (command) {
+        .version => {
+            if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
+            if (memory != null) fatal("--memory: supported only by 'start' command", .{});
+            if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
+            if (replica != null) fatal("--replica: supported only by 'format' command", .{});
+            if (path != null) fatal("unexpected path", .{});
+
+            return Command{
+                .version = .{ .verbose = verbose orelse false },
+            };
+        },
         .format => {
             if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
             if (memory != null) fatal("--memory: supported only by 'start' command", .{});
+            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
 
             return Command{
                 .format = .{
@@ -161,6 +190,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         .start => {
             if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
             if (replica != null) fatal("--replica: supported only by 'format' command", .{});
+            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
 
             return Command{
                 .start = .{

package/src/tigerbeetle/src/config.zig

@@ -213,7 +213,6 @@ pub const io_depth_write = 8;
 
 /// The number of redundant copies of the superblock in the superblock storage zone.
 /// This must be either { 4, 6, 8 }, i.e. an even number, for more efficient flexible quorums.
-/// This is further multiplied by two to support copy-on-write across copy sets.
 ///
 /// The superblock contains local state for the replica and therefore cannot be replicated remotely.
 /// Loss of the superblock would represent loss of the replica and so it must be protected.
@@ -239,6 +238,9 @@ pub const superblock_copies = 4;
 pub const size_max = 16 * 1024 * 1024 * 1024 * 1024;
 
 /// The unit of read/write access to LSM manifest and LSM table blocks in the block storage zone.
+///
+/// - A lower block size increases the memory overhead of table metadata, due to smaller/more tables.
+/// - A higher block size increases space amplification due to partially-filled blocks.
 pub const block_size = 64 * 1024;
 
 pub const block_count_max = @divExact(16 * 1024 * 1024 * 1024 * 1024, block_size);
@@ -261,6 +263,8 @@ pub const lsm_growth_factor = 8;
 /// The maximum key size for an LSM tree in bytes.
 pub const lsm_key_size_max = 32;
 
+/// The maximum cumulative size of a table — computed as the sum of the size of the index block,
+/// filter blocks, and data blocks.
 pub const lsm_table_size_max = 64 * 1024 * 1024;
 
 /// Size of nodes used by the LSM tree manifest implementation.
@@ -358,8 +362,13 @@ comptime {
 
     // The WAL format requires messages to be a multiple of the sector size.
     assert(message_size_max % sector_size == 0);
+    assert(message_size_max >= @sizeOf(vsr.Header));
     assert(message_size_max >= sector_size);
 
+    assert(superblock_copies % 2 == 0);
+    assert(superblock_copies >= 4);
+    assert(superblock_copies <= 8);
+
     // ManifestLog serializes the level as a u7.
     assert(lsm_levels > 0);
     assert(lsm_levels <= std.math.maxInt(u7));

package/src/tigerbeetle/src/demo.zig

@@ -10,6 +10,7 @@ const Transfer = tb.Transfer;
 const CreateAccountsResult = tb.CreateAccountsResult;
 const CreateTransfersResult = tb.CreateTransfersResult;
 
+const util = @import("util.zig");
 const IO = @import("io.zig").IO;
 const Storage = @import("storage.zig").Storage;
 const MessagePool = @import("message_pool.zig").MessagePool;
@@ -61,7 +62,7 @@ pub fn request(
     defer client.unref(message);
 
     const body = std.mem.asBytes(&batch);
-    std.mem.copy(u8, message.buffer[@sizeOf(Header)..], body);
+    util.copy_disjoint(.inexact, u8, message.buffer[@sizeOf(Header)..], body);
 
     client.request(
         0,

package/src/tigerbeetle/src/demo_01_create_accounts.zig

@@ -15,7 +15,7 @@ pub fn main() !void {
             .debits_pending = 0,
             .debits_posted = 0,
             .credits_pending = 0,
-            .credits_posted = 10000, // Let's start with some liquidity.
+            .credits_posted = 0,
         },
         Account{
             .id = 2,

package/src/tigerbeetle/src/demo_03_create_transfers.zig

@@ -7,6 +7,19 @@ pub fn main() !void {
     const transfers = [_]Transfer{
         Transfer{
             .id = 1,
+            .debit_account_id = 2,
+            .credit_account_id = 1,
+            .user_data = 0,
+            .reserved = 0,
+            .pending_id = 0,
+            .timeout = 0,
+            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
+            .code = 1,
+            .flags = .{},
+            .amount = 10000, // Let's start with some liquidity in account 1.
+        },
+        Transfer{
+            .id = 2,
             .debit_account_id = 1,
             .credit_account_id = 2,
             .user_data = 0,

package/src/tigerbeetle/src/ewah.zig

@@ -2,7 +2,9 @@ const std = @import("std");
 const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
-const div_ceil = @import("util.zig").div_ceil;
+const util = @import("util.zig");
+const div_ceil = util.div_ceil;
+const disjoint_slices = util.disjoint_slices;
 
 /// Encode or decode a bitset using Daniel Lemire's EWAH codec.
 /// ("Histogram-Aware Sorting for Enhanced Word-Aligned Compression in Bitmap Indexes")
@@ -58,10 +60,12 @@ pub fn ewah(comptime Word: type) type {
 
         /// Decodes the compressed bitset in `source` into `target_words`.
         /// Returns the number of *words* written to `target_words`.
+        // TODO Refactor to return an error when `source` is invalid,
+        // so that we can test invalid encodings.
         pub fn decode(source: []align(@alignOf(Word)) const u8, target_words: []Word) usize {
             assert(source.len % @sizeOf(Word) == 0);
             assert(source.len >= @sizeOf(Marker));
-            assert(is_disjoint(u8, Word, source, target_words));
+            assert(disjoint_slices(u8, Word, source, target_words));
 
             const source_words = mem.bytesAsSlice(Word, source);
             var source_index: usize = 0;
@@ -75,7 +79,8 @@ pub fn ewah(comptime Word: type) type {
                     if (marker.uniform_bit == 1) ~@as(Word, 0) else 0,
                 );
                 target_index += marker.uniform_word_count;
-                std.mem.copy(
+                util.copy_disjoint(
+                    .exact,
                     Word,
                     target_words[target_index..][0..marker.literal_word_count],
                     source_words[source_index..][0..marker.literal_word_count],
@@ -92,7 +97,7 @@ pub fn ewah(comptime Word: type) type {
         pub fn encode(source_words: []const Word, target: []align(@alignOf(Word)) u8) usize {
             assert(target.len >= @sizeOf(Marker));
             assert(target.len == encode_size_max(source_words.len));
-            assert(is_disjoint(Word, u8, source_words, target));
+            assert(disjoint_slices(Word, u8, source_words, target));
 
             const target_words = mem.bytesAsSlice(Word, target);
             std.mem.set(Word, target_words, 0);
@@ -126,7 +131,8 @@ pub fn ewah(comptime Word: type) type {
                     .literal_word_count = @intCast(MarkerLiteralCount, literal_word_count),
                 });
                 target_index += 1;
-                std.mem.copy(
+                util.copy_disjoint(
+                    .exact,
                     Word,
                     target_words[target_index..][0..literal_word_count],
                     source_words[source_index..][0..literal_word_count],
@@ -154,34 +160,6 @@ pub fn ewah(comptime Word: type) type {
     };
 }
 
-fn is_disjoint(comptime A: type, comptime B: type, a: []const A, b: []const B) bool {
-    return @ptrToInt(a.ptr) + a.len * @sizeOf(A) <= @ptrToInt(b.ptr) or
-        @ptrToInt(b.ptr) + b.len * @sizeOf(B) <= @ptrToInt(a.ptr);
-}
-
-test "is_disjoint" {
-    const a = try std.testing.allocator.alignedAlloc(u8, @sizeOf(u32), 8 * @sizeOf(u32));
-    defer std.testing.allocator.free(a);
-
-    const b = try std.testing.allocator.alloc(u32, 8);
-    defer std.testing.allocator.free(b);
-
-    try std.testing.expectEqual(true, is_disjoint(u8, u32, a, b));
-    try std.testing.expectEqual(true, is_disjoint(u32, u8, b, a));
-
-    try std.testing.expectEqual(true, is_disjoint(u8, u8, a, a[0..0]));
-    try std.testing.expectEqual(true, is_disjoint(u32, u32, b, b[0..0]));
-
-    try std.testing.expectEqual(false, is_disjoint(u8, u8, a, a[0..1]));
-    try std.testing.expectEqual(false, is_disjoint(u8, u8, a, a[a.len - 1 .. a.len]));
-
-    try std.testing.expectEqual(false, is_disjoint(u32, u32, b, b[0..1]));
-    try std.testing.expectEqual(false, is_disjoint(u32, u32, b, b[b.len - 1 .. b.len]));
-
-    try std.testing.expectEqual(false, is_disjoint(u8, u32, a, std.mem.bytesAsSlice(u32, a)));
-    try std.testing.expectEqual(false, is_disjoint(u32, u8, b, std.mem.sliceAsBytes(b)));
-}
-
 test "ewah Word=u8 decode→encode→decode" {
     try test_decode_with_word(u8);