initial commit

theseyan · theseyan · commit 36a593fd6f78 · 2024-12-17T20:31:57.000+05:30
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,3 @@
+.vscode/
+.zig-cache/
+zig-out/
diff --git a/LICENSE.md b/LICENSE.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 Sayan Jyoti Das
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
@@ -0,0 +1,12 @@
+# mimalloc.zig
+
+A simple implementation of Zig's `std.mem.Allocator` interface over the excellent [mimalloc](https://github.com/microsoft/mimalloc) by Microsoft.
+
+## Usage
+
+```
+const mimalloc = @import("mimalloc").Allocator{};
+const allocator = mimalloc.allocator();
+
+// Use `allocator` here...
+```
diff --git a/build.zig b/build.zig
@@ -0,0 +1,79 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const lib = b.addModule("mimalloc", .{
+        .root_source_file = b.path("src/mimalloc.zig"),
+        .link_libc = true
+    });
+    
+    // mimalloc C library
+    const mimalloc = b.dependency("mimalloc_c", .{});
+
+    lib.addIncludePath(mimalloc.path("include"));
+
+    // macOS SDK for cross-compilation
+    const macos_sdk = b.dependency("macos_sdk", .{});
+
+    // Add macOS SDK headers if applicable
+    if (target.result.os.tag == .macos) {
+        lib.addSystemIncludePath(macos_sdk.path("include"));
+    }
+
+    var c_flags = std.ArrayList([]const u8).init(b.allocator);
+    if (optimize != .Debug) {
+        c_flags.append("-DNDEBUG=1") catch unreachable;
+        c_flags.append("-DMI_SECURE=0") catch unreachable;
+        c_flags.append("-DMI_STAT=0") catch unreachable;
+    }
+
+    var sources = std.ArrayList([]const u8).init(b.allocator);
+    sources.appendSlice(&.{
+        "src/alloc.c",
+        "src/alloc-aligned.c",
+        "src/page.c",
+        "src/heap.c",
+        "src/random.c",
+        "src/options.c",
+        "src/bitmap.c",
+        "src/os.c",
+        "src/init.c",
+        "src/segment.c",
+        "src/segment-map.c",
+        "src/arena.c",
+        "src/stats.c",
+        "src/prim/prim.c",
+        "src/libc.c",
+    }) catch unreachable;
+
+    for (sources.items) |src| {
+        lib.addCSourceFile(.{
+            .file = mimalloc.path(src),
+            .flags = c_flags.items,
+        });
+    }
+
+    if (target.result.os.tag != .windows) {
+        lib.addCSourceFile(.{
+            .file = mimalloc.path("src/alloc-posix.c"),
+            .flags = c_flags.items,
+        });
+    }
+
+    // Tests
+    const lib_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/test.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib_unit_tests.root_module.addImport("mimalloc", lib);
+    lib_unit_tests.linkLibC();
+
+    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_unit_tests.step);
+}
diff --git a/build.zig.zon b/build.zig.zon
@@ -0,0 +1,22 @@
+.{
+    .name = "mimalloc.zig",
+    .version = "0.1.0",
+    .minimum_zig_version = "0.13.0",
+
+    .dependencies = .{
+        .macos_sdk = .{
+            .url = "https://github.com/mitchellh/zig-build-macos-sdk/archive/refs/heads/main.tar.gz",
+            .hash = "12209cc9ee372456eda52b71cf9ae77dcc707fa42c9f9d68996b5bf7495b53229c2e"
+        },
+        .mimalloc_c = . {
+            .url = "https://github.com/microsoft/mimalloc/archive/refs/tags/v2.1.7.tar.gz",
+            .hash = "12209bba1fc4faac01d1ee247a38bdb9f340ce60e457d194fa9da4f7c22b96986521"
+        }
+    },
+
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+    },
+}
diff --git a/src/mimalloc.zig b/src/mimalloc.zig
@@ -0,0 +1,71 @@
+const std = @import("std");
+const log = std.log.scoped(.mimalloc);
+
+const c = @cImport({
+    @cInclude("mimalloc.h");
+});
+
+pub usingnamespace c;
+
+pub fn collect(force: bool) void {
+    c.mi_collect(force);
+}
+
+pub const Allocator = struct {
+    const vtable = std.mem.Allocator.VTable{
+        .alloc = alloc,
+        .resize = resize,
+        .free = free,
+    };
+    
+    pub fn allocator(self: *Allocator) std.mem.Allocator {
+        return std.mem.Allocator{
+            .ptr = self,
+            .vtable = &vtable,
+        };
+    }
+
+    fn alloc(
+        ptr: *anyopaque,
+        len: usize,
+        log2_align: u8,
+        ret_addr: usize,
+    ) ?[*]u8 {
+        _ = ptr;
+        _ = ret_addr;
+        const alignment = @as(usize, 1) << @intCast(log2_align);
+        return @ptrCast(c.mi_malloc_aligned(len, alignment));
+    }
+
+    fn resize(
+        ptr: *anyopaque,
+        buf: []u8,
+        log2_align: u8,
+        new_len: usize,
+        ret_addr: usize,
+    ) bool {
+        _ = ptr;
+        _ = log2_align;
+        _ = ret_addr;
+        if (new_len > buf.len) {
+            if (c.mi_expand(buf.ptr, new_len)) |_| {
+                return true;
+            }
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    fn free(
+        ptr: *anyopaque,
+        buf: []u8,
+        log2_align: u8,
+        ret_addr: usize,
+    ) void {
+        _ = ptr;
+        _ = ret_addr;
+        _ = log2_align;
+        c.mi_free(buf.ptr);
+    }
+};
diff --git a/src/test.zig b/src/test.zig
@@ -0,0 +1,90 @@
+const std = @import("std");
+const testing = std.testing;
+const mimalloc = @import("mimalloc").Allocator{};
+const allocator = mimalloc.allocator();
+
+test "basic allocation and deallocation" {
+    // Test simple allocation
+    const slice = try allocator.alloc(u8, 100);
+    defer allocator.free(slice);
+    try testing.expectEqual(@as(usize, 100), slice.len);
+
+    // Fill with data to ensure memory is writable
+    @memset(slice, 0xAA);
+    for (slice) |byte| {
+        try testing.expectEqual(@as(u8, 0xAA), byte);
+    }
+}
+
+test "zero-sized allocation" {
+    // Test allocation of zero bytes
+    const empty = try allocator.alloc(u8, 0);
+    defer allocator.free(empty);
+    try testing.expectEqual(@as(usize, 0), empty.len);
+}
+
+test "realloc behavior" {
+    // Initial allocation
+    var slice = try allocator.alloc(u8, 50);
+    defer allocator.free(slice);
+
+    // Fill with pattern
+    @memset(slice, 0xBB);
+
+    // Grow
+    slice = try allocator.realloc(slice, 100);
+    try testing.expectEqual(@as(usize, 100), slice.len);
+
+    // Verify original data is preserved
+    for (slice[0..50]) |byte| {
+        try testing.expectEqual(@as(u8, 0xBB), byte);
+    }
+
+    // Shrink
+    slice = try allocator.realloc(slice, 25);
+    try testing.expectEqual(@as(usize, 25), slice.len);
+
+    // Verify data is still preserved
+    for (slice) |byte| {
+        try testing.expectEqual(@as(u8, 0xBB), byte);
+    }
+}
+
+test "multiple allocations" {
+    var slices = std.ArrayList([]u8).init(testing.allocator);
+    defer {
+        for (slices.items) |slice| {
+            allocator.free(slice);
+        }
+        slices.deinit();
+    }
+
+    // Perform multiple allocations of varying sizes
+    const sizes = [_]usize{ 8, 16, 32, 64, 128, 256, 512, 1024 };
+    for (sizes) |size| {
+        const slice = try allocator.alloc(u8, size);
+        try slices.append(slice);
+        @memset(slice, @as(u8, @truncate(size % 256)));
+    }
+
+    // Verify all allocations
+    for (slices.items, 0..) |slice, i| {
+        try testing.expectEqual(sizes[i], slice.len);
+        for (slice) |byte| {
+            try testing.expectEqual(@as(u8, @truncate(sizes[i] % 256)), byte);
+        }
+    }
+}
+
+test "alignment requirements" {
+    const AlignedStruct = struct {
+        a: u32 align(16),
+        b: u64,
+    };
+
+    var slice = try allocator.alloc(AlignedStruct, 1);
+    defer allocator.free(slice);
+
+    // Verify alignment
+    try testing.expectEqual(@as(usize, 0), @intFromPtr(&slice[0]) & 15);
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+.vscode/`
	`2`	`+.zig-cache/`
	`3`	`+zig-out/`