initial commit

Author: eugene-dash

.gitignore

@@ -0,0 +1,2 @@
+.zig-cache/*
+zig-out/*

build.zig

@@ -0,0 +1,39 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    //
+    const kernelmaster_zig = b.createModule(.{
+        .root_source_file = b.path("./src/kernelmaster.zig"),
+    });
+    //
+    const exe = b.addExecutable(.{
+        .name = "kernelmaster",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    exe.linkLibC();
+    exe.root_module.addImport("kernelmaster", kernelmaster_zig);
+    b.installArtifact(exe);
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+    //
+    const exe_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    exe_unit_tests.linkLibC();
+    exe_unit_tests.root_module.addImport("kernelmaster", kernelmaster_zig);
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+    run_exe_unit_tests.has_side_effects = true;
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

build.zig.zon

@@ -0,0 +1,13 @@
+.{
+    .name = "kernelmaster",
+    .version = "0.0.0",
+    .minimum_zig_version = "0.13.0",
+    .dependencies = .{},
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "LICENSE",
+        "README.md",
+    },
+}

src/capsules/error_sets/error_sets.zig

@@ -0,0 +1,4 @@
+pub const kernelmaster_error = error {
+    kernelmaster_internal_error,
+    kernelmaster_thread_error,
+};

src/capsules/operation/operation.zig

@@ -0,0 +1,88 @@
+const std = @import("std");
+const return_value = @import("../return_value/return_value.zig").return_value;
+const thread_info = @import("../thread_info/thread_info.zig").thread_info;
+const error_sets = @import("../error_sets/error_sets.zig");
+
+pub const operation = struct {
+    thread: std.Thread,
+    result: *return_value,
+    allocator: std.mem.Allocator,
+
+    fn primary_thread(allocator: std.mem.Allocator, result: *return_value,nthreads: usize, nkernels: u128, comptime kernel: anytype, args: anytype) void {
+        result.* = return_value.success;
+        if (nthreads == 0) {
+            result.* = return_value.internal_error;
+            return;
+        }
+        const threads =
+            allocator.alloc(std.Thread, nthreads)
+                catch {
+                    result.* = return_value.internal_error;
+                    return;
+                };
+        defer allocator.free(threads);
+        const thread_returns =
+            allocator.alloc(return_value, nthreads)
+                catch {
+                    result.* = return_value.internal_error;
+                    return;
+                };
+        defer allocator.free(thread_returns);
+
+        const thread_info_gen = thread_info.generator.init(nthreads, nkernels, thread_returns);
+        for (0.., thread_returns, threads) |nthreads_launched, *this_thread_return, *this_thread| {
+            this_thread_return.* = return_value.success;
+            this_thread.* =
+                std.Thread.spawn(.{}, kernel, .{thread_info_gen.gen(nthreads_launched)} ++ args)
+                    catch {
+                        for (threads[0..nthreads_launched]) |thread| {
+                            thread.join();
+                        }
+                        result.* = return_value.internal_error;
+                        return;
+                    };
+        }
+
+        for (0.., thread_returns, threads) |i, thread_returned, thread| {
+            thread.join();
+            if (thread_returned != return_value.success) {
+                result.* = return_value.thread_error;
+                for (threads[i..]) |thread_quickjoin| {
+                    thread_quickjoin.join();
+                }
+                return;
+            }
+        }
+        return;
+    }
+    pub fn launch(allocator: std.mem.Allocator, nthreads: usize, nkernels: u128, comptime kernel: anytype, args: anytype) error_sets.kernelmaster_error!operation {
+        const result: *return_value = allocator.create(return_value) catch return error.kernelmaster_internal_error;
+        errdefer allocator.destroy(result);
+        return .{
+            .thread = std.Thread.spawn(
+                .{},
+                primary_thread,
+                .{
+                    allocator,
+                    result,
+                    nthreads,
+                    nkernels,
+                    kernel,
+                    args,
+                }
+            ) catch return error.kernelmaster_internal_error,
+            .result = result,
+            .allocator = allocator,
+        };
+    }
+    pub fn sync(op: operation) !void {
+        std.Thread.join(op.thread);
+        const r: return_value = op.result.*;
+        op.allocator.destroy(op.result);
+        switch (r) {
+            return_value.success => return,
+            return_value.thread_error => return error.kernelmaster_thread_error,
+            else => return error.kernelmaster_internal_error,
+        }
+    }
+};

src/capsules/return_value/return_value.zig

@@ -0,0 +1,5 @@
+pub const return_value = enum(u8) {
+    success = 0,
+    internal_error = 15,
+    thread_error = 255,
+};

src/capsules/thread_info/thread_info.zig

@@ -0,0 +1,51 @@
+const return_value = @import("../return_value/return_value.zig").return_value;
+
+pub const thread_info = struct {
+    thread_return: *return_value,
+    thread_id: usize,
+    nthreads: usize,
+    kernel_begin: u128,
+    kernel_end: u128,
+
+    pub const generator = struct {
+        remainder: usize,
+        remainder_end: u128,
+        perthread: u128,
+        nthreads: usize,
+        nkernels: u128,
+        thread_returns: []return_value,
+        pub fn init(nthreads: usize, nkernels: u128, thread_returns: []return_value) thread_info.generator {
+            var r: thread_info.generator = .{
+                .remainder = @intCast(nkernels % nthreads),
+                .remainder_end = undefined,
+                .perthread = nkernels / nthreads,
+                .nthreads = nthreads,
+                .nkernels = nkernels,
+                .thread_returns = thread_returns[0..nthreads],
+            };
+            r.remainder_end = r.remainder * (1 + r.perthread);
+            return r;
+        }
+        pub fn gen(self: thread_info.generator, i: usize) thread_info {
+            if (i < self.remainder) {
+                const kernel_begin: u128 = (1 + self.perthread) * i;
+                return .{
+                    .thread_return = @ptrCast(self.thread_returns.ptr+i),
+                    .thread_id = i,
+                    .nthreads = self.nthreads,
+                    .kernel_begin = kernel_begin,
+                    .kernel_end = kernel_begin + @as(usize, 1) + self.perthread,
+                };
+            } else {
+                const kernel_begin: u128 = self.remainder_end + (self.perthread * (i - self.remainder));
+                return .{
+                    .thread_return = @ptrCast(self.thread_returns.ptr+i),
+                    .thread_id = i,
+                    .nthreads = self.nthreads,
+                    .kernel_begin = kernel_begin,
+                    .kernel_end = kernel_begin + self.perthread,
+                };
+            }
+        }
+    };
+};

src/kernelmaster.zig

@@ -0,0 +1,14 @@
+const std = @import("std");
+const testing = std.testing;
+
+pub const thread_info = @import("./capsules/thread_info/thread_info.zig").thread_info;
+pub const operation = @import("./capsules/operation/operation.zig").operation;
+
+pub const error_sets = @import("./capsules/error_sets/error_sets.zig");
+
+pub const return_value = @import("./capsules/return_value/return_value.zig").return_value;
+// bellow consts are defined to make it simpler to set a thread's return variable
+pub const thread_success = return_value.success;
+pub const thread_error = return_value.thread_error;
+
+pub const launch = operation.launch;

src/main.zig

@@ -0,0 +1,29 @@
+const std = @import("std");
+const kernelmaster = @import("kernelmaster");
+
+fn example_kernel(thread_info: kernelmaster.thread_info, comptime debug: bool) void {
+    std.time.sleep(1_000_000_00 * @as(u64, thread_info.thread_id));
+    if (!debug)
+        return;
+    std.debug.print("_ {}_id :: {} --> {}\n", .{thread_info.thread_id, thread_info.kernel_begin, thread_info.kernel_end});
+    var k: u128 = thread_info.kernel_begin;
+    while (k < thread_info.kernel_end) : (k += 1) {
+        std.debug.print("|-{}\n", .{k});
+    }
+    std.debug.print("^\n", .{});
+    return;
+}
+
+fn kernelmaster_example(comptime debug: bool) !void {
+    const op = try kernelmaster.operation.launch(std.heap.c_allocator, 7, 12, example_kernel, .{debug});
+    try op.sync();
+    return;
+}
+test "basic kernelmaster functionality" {
+    try kernelmaster_example(false);
+}
+
+pub fn main() void {
+    kernelmaster_example(true) catch return;
+    return;
+}