Swtich to swift_lib

build.zig

@@ -5,7 +5,7 @@ var target: std.Target = undefined;
 var optimize: std.builtin.OptimizeMode = undefined;
 var resolved_target: std.Build.ResolvedTarget = undefined;
 
-var global_deps: [2]Dependency = undefined;
+var global_deps: [3]Dependency = undefined;
 const Dependency = struct {
     name: []const u8,
     module: *std.Build.Module,
@@ -29,11 +29,15 @@ const Dependency = struct {
         comptime name: []const u8,
         comptime source: []const u8,
         comptime n: comptime_int,
+        comptime link_module_to: ?comptime_int,
     ) void {
         global_deps[n] = .{
             .name = name,
             .module = b.createModule(.{ .root_source_file = .{ .path = source } }),
         };
+        if (link_module_to) |link_module| {
+            global_deps[n].module.addImport(global_deps[link_module].name, global_deps[link_module].module);
+        }
     }
 };
 
@@ -142,8 +146,9 @@ pub fn build(b: *std.Build) !void {
     const tag = @tagName(target.os.tag);
 
     // Declares dependencies
-    Dependency.addInternal(b, "Kivi", "src/core/Kivi.zig", 0);
-    Dependency.addInternal(b, "core", "src/core/main.zig", 1);
+    Dependency.addExternal(b, "swift_lib", 0);
+    Dependency.addInternal(b, "Kivi", "src/core/Kivi.zig", 1, 0);
+    Dependency.addInternal(b, "core", "src/core/main.zig", 2, 0);
 
     // Executes codegens
     const codegen_step = b.step("codegen", "Generates bindings");

build.zig.zon

@@ -3,5 +3,10 @@
     .version = "0.0.0",
     .minimum_zig_version = "0.11.0",
     .paths = .{ "src", "build.zig", "build.zig.zon" },
-    .dependencies = .{},
+    .dependencies = .{
+        .swift_lib = .{
+            .url = "https://github.com/devraymondsh/swift_lib/archive/refs/tags/v0.2.1.tar.gz",
+            .hash = "1220c061e19c7a2315d009adc63c44657fe47f043aaa4cae3cade745095de4cf0488",
+        },
+    },
 }

src/core/ByteMap.zig

@@ -1,8 +1,7 @@
 /// This is Byte(u8) hashmap implementation that relies on the caller to handle allocations and lifetimes.
 const builtin = @import("builtin");
 const Wyhash = @import("./Wyhash.zig");
-const Math = @import("Math.zig");
-const Mmap = @import("./Mmap.zig");
+const swift_lib = @import("swift_lib");
 
 const Entry = struct {
     key: []u8,
@@ -71,8 +70,8 @@ table_size: usize,
 
 var hasher = Wyhash.init(0);
 
-pub fn init(self: *ByteMap, allocator: *Mmap, size: usize) !void {
-    self.table_size = @intCast(Math.ceilPowerOfTwo(@intCast(size)));
+pub fn init(self: *ByteMap, allocator: swift_lib.heap.Allocator, size: usize) !void {
+    self.table_size = swift_lib.math.ceilPowerOfTwo(size);
     self.table_metadata = try allocator.alloc(GroupMetadata, self.table_size);
     self.table = try allocator.alloc(Group, self.table_size);
 
@@ -87,7 +86,7 @@ fn hash(key: []const u8) usize {
     return hasher.reset_hash(@intCast(key.len), key);
 }
 fn hash_to_groupidx(self: *ByteMap, hashed: usize) usize {
-    return (hashed >> 7) & (self.table_size - 1);
+    return (hashed >> 7) % self.table_size;
 }
 fn hash_to_elemidx(hashed: usize) usize {
     return (hashed & 0x7F) % 7;
@@ -104,7 +103,7 @@ fn find_index(self: *ByteMap, key: []const u8, comptime lookup: bool) ?FoundEnti
     const elemidx = hash_to_elemidx(hashed);
 
     var searching_second_time = false;
-    while (true) : (groupidx += 1) {
+    while (true) : (groupidx = (groupidx + 1) % self.table_size) {
         const group = &self.table[groupidx];
         const metadata = self.table_metadata[groupidx];
         const metadata_vec: @Vector(16, u8) = metadata.elements;
@@ -184,7 +183,7 @@ pub fn get(self: *ByteMap, key: []const u8) ?[]u8 {
     }
     return null;
 }
-pub fn del(self: *ByteMap, allocator: *Mmap, key: []const u8) ?[]u8 {
+pub fn del(self: *ByteMap, allocator: swift_lib.heap.Allocator, key: []const u8) ?[]u8 {
     const found_entity = self.find_index(key, true);
     if (found_entity) |entity| {
         const entry = &self.table[entity.group_idx].elements[entity.elem_idx];

src/core/Kivi.zig

@@ -1,14 +1,15 @@
-const MMap = @import("Mmap.zig");
 const ByteMap = @import("ByteMap.zig");
+const swift_lib = @import("swift_lib");
 
 pub const Config = extern struct {
     // (2 ** 18) * 16 = 4194304
     group_size: usize = 262144,
     mem_size: usize = 1 * 1024 * 1024 * 1024,
 };
 
-mem: MMap,
 map: ByteMap,
+allocator: swift_lib.heap.Allocator,
+freelist: swift_lib.heap.FreelistAllocator,
 
 const Kivi = @This();
 
@@ -20,18 +21,21 @@ fn stringcpy(dest: []u8, src: []const u8) !void {
 }
 
 pub fn init(self: *Kivi, config: *const Config) !usize {
-    self.mem = try MMap.init(config.mem_size);
+    const pages = try swift_lib.heap.PageAllocator.init(config.mem_size / swift_lib.os.page_size);
 
-    try self.map.init(&self.mem, config.group_size);
+    self.freelist = swift_lib.heap.FreelistAllocator.init(pages.mem);
+    self.allocator = self.freelist.allocator();
+
+    try self.map.init(self.allocator, config.group_size);
 
     return @sizeOf(Kivi);
 }
 
 pub fn reserve_key(self: *Kivi, size: usize) ![]u8 {
-    return self.mem.alloc(u8, size);
+    return self.allocator.alloc(u8, size);
 }
 pub fn reserve_value(self: *Kivi, size: usize) ![]u8 {
-    return try self.mem.alloc(u8, size);
+    return try self.allocator.alloc(u8, size);
 }
 pub fn put_entry(self: *Kivi, key: []u8, value: []u8) !void {
     return self.map.put(key, value);
@@ -65,7 +69,7 @@ pub fn get_copy(self: *Kivi, key: []const u8, value: ?[]u8) !usize {
 }
 
 pub fn del(self: *Kivi, key: []const u8) ![]u8 {
-    if (self.map.del(&self.mem, key)) |value| {
+    if (self.map.del(self.allocator, key)) |value| {
         return value;
     } else {
         return error.NotFound;
@@ -79,17 +83,19 @@ pub fn del_copy(self: *Kivi, key: []const u8, value: ?[]u8) !usize {
         try stringcpy(value.?, value_slice);
     }
 
-    self.mem.free(value_slice);
+    self.allocator.free(value_slice);
 
     return value_slice_len;
 }
 
 pub fn rm(self: *Kivi, key: []const u8) !void {
     const value_slice = try self.del(key);
-    self.mem.free(value_slice);
+    self.allocator.free(value_slice);
 }
 
 pub fn deinit(self: *Kivi) void {
+    var pages: swift_lib.heap.PageAllocator = .{ .mem = @alignCast(self.freelist.mem) };
+
     self.map.deinit();
-    self.mem.deinit();
+    pages.deinit();
 }