tigerbeetle-node 0.8.0 → 0.10.0

package/src/tigerbeetle/src/iops.zig

@@ -0,0 +1,101 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+/// Take a u6 to limit to 64 items max (2^6 = 64)
+pub fn IOPS(comptime T: type, comptime size: u6) type {
+    const Map = std.StaticBitSet(size);
+    return struct {
+        const Self = @This();
+
+        items: [size]T = undefined,
+        /// 1 bits are free items.
+        free: Map = Map.initFull(),
+
+        pub fn acquire(self: *Self) ?*T {
+            const i = self.free.findFirstSet() orelse return null;
+            self.free.unset(i);
+            return &self.items[i];
+        }
+
+        pub fn release(self: *Self, item: *T) void {
+            item.* = undefined;
+            const i = (@ptrToInt(item) - @ptrToInt(&self.items)) / @sizeOf(T);
+            assert(!self.free.isSet(i));
+            self.free.set(i);
+        }
+
+        /// Returns the count of IOPs available.
+        pub fn available(self: *const Self) usize {
+            return self.free.count();
+        }
+
+        /// Returns the count of IOPs in use.
+        pub fn executing(self: *const Self) usize {
+            return size - self.available();
+        }
+
+        pub const Iterator = struct {
+            iops: *Self,
+            bitset_iterator: Map.Iterator(.{ .kind = .unset }),
+
+            pub fn next(iterator: *@This()) ?*T {
+                const i = iterator.bitset_iterator.next() orelse return null;
+                return &iterator.iops.items[i];
+            }
+        };
+
+        pub fn iterate(self: *Self) Iterator {
+            return .{
+                .iops = self,
+                .bitset_iterator = self.free.iterator(.{ .kind = .unset }),
+            };
+        }
+    };
+}
+
+test "IOPS" {
+    const testing = std.testing;
+    var iops = IOPS(u32, 4){};
+
+    try testing.expectEqual(@as(usize, 4), iops.available());
+    try testing.expectEqual(@as(usize, 0), iops.executing());
+
+    var one = iops.acquire().?;
+
+    try testing.expectEqual(@as(usize, 3), iops.available());
+    try testing.expectEqual(@as(usize, 1), iops.executing());
+
+    var two = iops.acquire().?;
+    var three = iops.acquire().?;
+
+    try testing.expectEqual(@as(usize, 1), iops.available());
+    try testing.expectEqual(@as(usize, 3), iops.executing());
+
+    var four = iops.acquire().?;
+    try testing.expectEqual(@as(?*u32, null), iops.acquire());
+
+    try testing.expectEqual(@as(usize, 0), iops.available());
+    try testing.expectEqual(@as(usize, 4), iops.executing());
+
+    iops.release(two);
+
+    try testing.expectEqual(@as(usize, 1), iops.available());
+    try testing.expectEqual(@as(usize, 3), iops.executing());
+
+    // there is only one slot free, so we will get the same pointer back.
+    try testing.expectEqual(@as(?*u32, two), iops.acquire());
+
+    iops.release(four);
+    iops.release(two);
+    iops.release(one);
+    iops.release(three);
+
+    try testing.expectEqual(@as(usize, 4), iops.available());
+    try testing.expectEqual(@as(usize, 0), iops.executing());
+
+    one = iops.acquire().?;
+    two = iops.acquire().?;
+    three = iops.acquire().?;
+    four = iops.acquire().?;
+    try testing.expectEqual(@as(?*u32, null), iops.acquire());
+}

package/src/tigerbeetle/src/lsm/binary_search.zig

@@ -0,0 +1,214 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const math = std.math;
+
+// TODO Add prefeching when @prefetch is available: https://github.com/ziglang/zig/issues/3600.
+//
+// TODO The Zig self hosted compiler will implement inlining itself before passing the IR to llvm,
+// which should eliminate the current poor codegen of key_from_value/compare_keys.
+
+/// Returns the index of the key either exactly equal to the target key or, if there is no exact
+/// match, the next greatest key.
+/// Doesn't preform the extra key comparison to determine if the match is exact
+pub fn binary_search_values_raw(
+    comptime Key: type,
+    comptime Value: type,
+    comptime key_from_value: fn (*const Value) callconv(.Inline) Key,
+    comptime compare_keys: fn (Key, Key) callconv(.Inline) math.Order,
+    values: []const Value,
+    key: Key,
+) u32 {
+    assert(values.len > 0);
+
+    var offset: usize = 0;
+    var length: usize = values.len;
+    while (length > 1) {
+        const half = length / 2;
+        const mid = offset + half;
+
+        // This trick seems to be what's needed to get llvm to emit branchless code for this,
+        // a ternay-style if expression was generated as a jump here for whatever reason.
+        const next_offsets = [_]usize{ offset, mid };
+        offset = next_offsets[@boolToInt(compare_keys(key_from_value(&values[mid]), key) == .lt)];
+
+        length -= half;
+    }
+
+    return @intCast(u32, offset + @boolToInt(compare_keys(key_from_value(&values[offset]), key) == .lt));
+}
+
+pub inline fn binary_search_keys_raw(
+    comptime Key: type,
+    comptime compare_keys: fn (Key, Key) callconv(.Inline) math.Order,
+    keys: []const Key,
+    key: Key,
+) u32 {
+    return binary_search_values_raw(
+        Key,
+        Key,
+        struct {
+            inline fn key_from_key(k: *const Key) Key {
+                return k.*;
+            }
+        }.key_from_key,
+        compare_keys,
+        keys,
+        key,
+    );
+}
+
+const BinarySearchResult = struct {
+    index: u32,
+    exact: bool,
+};
+
+pub inline fn binary_search_values(
+    comptime Key: type,
+    comptime Value: type,
+    comptime key_from_value: fn (*const Value) callconv(.Inline) Key,
+    comptime compare_keys: fn (Key, Key) callconv(.Inline) math.Order,
+    values: []const Value,
+    key: Key,
+) BinarySearchResult {
+    const index = binary_search_values_raw(Key, Value, key_from_value, compare_keys, values, key);
+    return .{
+        .index = index,
+        .exact = index < values.len and compare_keys(key_from_value(&values[index]), key) == .eq,
+    };
+}
+
+pub inline fn binary_search_keys(
+    comptime Key: type,
+    comptime compare_keys: fn (Key, Key) callconv(.Inline) math.Order,
+    keys: []const Key,
+    key: Key,
+) BinarySearchResult {
+    const index = binary_search_keys_raw(Key, compare_keys, keys, key);
+    return .{
+        .index = index,
+        .exact = index < keys.len and compare_keys(keys[index], key) == .eq,
+    };
+}
+
+const test_binary_search = struct {
+    const log = false;
+
+    const gpa = std.testing.allocator;
+
+    inline fn compare_keys(a: u32, b: u32) math.Order {
+        return math.order(a, b);
+    }
+
+    fn exhaustive_search(keys_count: u32) !void {
+        const keys = try gpa.alloc(u32, keys_count);
+        defer gpa.free(keys);
+
+        for (keys) |*key, i| key.* = @intCast(u32, 7 * i + 3);
+
+        var target_key: u32 = 0;
+        while (target_key < keys_count + 13) : (target_key += 1) {
+            var expect: BinarySearchResult = .{ .index = 0, .exact = false };
+            for (keys) |key, i| {
+                switch (compare_keys(key, target_key)) {
+                    .lt => expect.index = @intCast(u32, i) + 1,
+                    .eq => {
+                        expect.exact = true;
+                        break;
+                    },
+                    .gt => break,
+                }
+            }
+
+            if (log) {
+                std.debug.print("keys:", .{});
+                for (keys) |k| std.debug.print("{},", .{k});
+                std.debug.print("\n", .{});
+                std.debug.print("target key: {}\n", .{target_key});
+            }
+
+            const actual = binary_search_keys(
+                u32,
+                compare_keys,
+                keys,
+                target_key,
+            );
+
+            if (log) std.debug.print("expected: {}, actual: {}\n", .{ expect, actual });
+            try std.testing.expectEqual(expect.index, actual.index);
+            try std.testing.expectEqual(expect.exact, actual.exact);
+        }
+    }
+
+    fn explicit_search(
+        keys: []const u32,
+        target_keys: []const u32,
+        expected_results: []const BinarySearchResult,
+    ) !void {
+        assert(target_keys.len == expected_results.len);
+
+        for (target_keys) |target_key, i| {
+            if (log) {
+                std.debug.print("keys:", .{});
+                for (keys) |k| std.debug.print("{},", .{k});
+                std.debug.print("\n", .{});
+                std.debug.print("target key: {}\n", .{target_key});
+            }
+            const expect = expected_results[i];
+            const actual = binary_search_keys(
+                u32,
+                compare_keys,
+                keys,
+                target_key,
+            );
+            try std.testing.expectEqual(expect.index, actual.index);
+            try std.testing.expectEqual(expect.exact, actual.exact);
+        }
+    }
+};
+
+// TODO test search on empty slice
+test "binary search: exhaustive" {
+    if (test_binary_search.log) std.debug.print("\n", .{});
+    var i: u32 = 1;
+    while (i < 300) : (i += 1) {
+        try test_binary_search.exhaustive_search(i);
+    }
+}
+
+test "binary search: explicit" {
+    if (test_binary_search.log) std.debug.print("\n", .{});
+    try test_binary_search.explicit_search(
+        &[_]u32{ 0, 3, 5, 8, 9, 11 },
+        &[_]u32{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 },
+        &[_]BinarySearchResult{
+            .{ .index = 0, .exact = true },
+            .{ .index = 1, .exact = false },
+            .{ .index = 1, .exact = false },
+            .{ .index = 1, .exact = true },
+            .{ .index = 2, .exact = false },
+            .{ .index = 2, .exact = true },
+            .{ .index = 3, .exact = false },
+            .{ .index = 3, .exact = false },
+            .{ .index = 3, .exact = true },
+            .{ .index = 4, .exact = true },
+            .{ .index = 5, .exact = false },
+            .{ .index = 5, .exact = true },
+            .{ .index = 6, .exact = false },
+            .{ .index = 6, .exact = false },
+        },
+    );
+}
+
+test "binary search: duplicates" {
+    if (test_binary_search.log) std.debug.print("\n", .{});
+    try test_binary_search.explicit_search(
+        &[_]u32{ 0, 0, 3, 3, 3, 5, 5, 5, 5 },
+        &[_]u32{ 1, 2, 4, 6 },
+        &[_]BinarySearchResult{
+            .{ .index = 2, .exact = false },
+            .{ .index = 2, .exact = false },
+            .{ .index = 5, .exact = false },
+            .{ .index = 9, .exact = false },
+        },
+    );
+}

package/src/tigerbeetle/src/lsm/bloom_filter.zig

@@ -0,0 +1,82 @@
+//! Implementation of Split block Bloom filters: https://arxiv.org/pdf/2101.01719v4.pdf
+
+const std = @import("std");
+const assert = std.debug.assert;
+const mem = std.mem;
+const meta = std.meta;
+
+pub const Fingerprint = struct {
+    /// Hash value used to map key to block.
+    hash: u32,
+    /// Mask of bits set in the block for the key.
+    mask: meta.Vector(8, u32),
+
+    pub fn create(key: []const u8) Fingerprint {
+        const hash = std.hash.Wyhash.hash(0, key);
+        const hash_lower = @truncate(u32, hash);
+        const hash_upper = @intCast(u32, hash >> 32);
+
+        // TODO These constants are from the paper and we understand them to be arbitrary odd
+        // integers. Experimentally compare the performance of these with other randomly chosen
+        // odd integers to verify/improve our understanding.
+        const odd_integers: meta.Vector(8, u32) = [8]u32{
+            0x47b6137b,
+            0x44974d91,
+            0x8824ad5b,
+            0xa2b7289d,
+            0x705495c7,
+            0x2df1424b,
+            0x9efc4947,
+            0x5c6bfb31,
+        };
+
+        // Multiply-shift hashing. This produces 8 values in the range 0 to 31 (2^5 - 1).
+        const bit_indexes = (odd_integers *% @splat(8, hash_lower)) >> @splat(8, @as(u5, 32 - 5));
+
+        return .{
+            .hash = hash_upper,
+            .mask = @splat(8, @as(u32, 1)) << @intCast(meta.Vector(8, u5), bit_indexes),
+        };
+    }
+};
+
+/// Add the key with the given fingerprint to the filter.
+/// filter.len must be a multiple of 32.
+pub fn add(fingerprint: Fingerprint, filter: []u8) void {
+    comptime assert(@sizeOf(meta.Vector(8, u32)) == 32);
+
+    assert(filter.len > 0);
+    assert(filter.len % @sizeOf(meta.Vector(8, u32)) == 0);
+
+    const blocks = mem.bytesAsSlice([8]u32, filter);
+    const index = block_index(fingerprint.hash, filter.len);
+
+    const current: meta.Vector(8, u32) = blocks[index];
+    blocks[index] = current | fingerprint.mask;
+}
+
+/// Check if the key with the given fingerprint may have been added to the filter.
+/// filter.len must be a multiple of 32.
+pub fn may_contain(fingerprint: Fingerprint, filter: []const u8) bool {
+    comptime assert(@sizeOf(meta.Vector(8, u32)) == 32);
+
+    assert(filter.len > 0);
+    assert(filter.len % @sizeOf(meta.Vector(8, u32)) == 0);
+
+    const blocks = mem.bytesAsSlice([8]u32, filter);
+    const index = block_index(fingerprint.hash, filter.len);
+
+    const current: meta.Vector(8, u32) = blocks[index];
+    return @reduce(.Or, ~current & fingerprint.mask) == 0;
+}
+
+inline fn block_index(hash: u32, size: usize) u32 {
+    assert(size > 0);
+
+    const block_count = @divExact(size, @sizeOf(meta.Vector(8, u32)));
+    return @intCast(u32, (@as(u64, hash) * block_count) >> 32);
+}
+
+test {
+    _ = std.testing.refAllDecls(@This());
+}