From 2beaeedb6f1b69608c4b4bdc588098dbcc7a5619 Mon Sep 17 00:00:00 2001 From: Mike Date: Sat, 13 Jun 2020 21:57:27 -0700 Subject: [PATCH] scheduler done --- zig-ecs/src/process/process.zig | 4 + zig-ecs/src/process/scheduler.zig | 140 +++++++++++++----------------- zig-ecs/src/tests.zig | 3 + 3 files changed, 67 insertions(+), 80 deletions(-) diff --git a/zig-ecs/src/process/process.zig b/zig-ecs/src/process/process.zig index 42379e6..42ddfc2 100644 --- a/zig-ecs/src/process/process.zig +++ b/zig-ecs/src/process/process.zig @@ -1,3 +1,5 @@ +const std = @import("std"); + /// Processes are run by the Scheduler. They use a similar pattern to Allocators in that they are created and /// added as fields in a parent struct, your actual process that will be run. pub const Process = struct { @@ -10,9 +12,11 @@ pub const Process = struct { abortedFn: ?fn (self: *Process) void = null, failedFn: ?fn (self: *Process) void = null, succeededFn: ?fn (self: *Process) void = null, + deinit: fn (self: *Process, allocator: *std.mem.Allocator) void = undefined, state: State = .uninitialized, stopped: bool = false, + next: ?*Process = null, pub fn getParent(self: *Process, comptime T: type) *T { return @fieldParentPtr(T, "process", self); diff --git a/zig-ecs/src/process/scheduler.zig b/zig-ecs/src/process/scheduler.zig index 6409649..1281fc4 100644 --- a/zig-ecs/src/process/scheduler.zig +++ b/zig-ecs/src/process/scheduler.zig @@ -11,96 +11,52 @@ const Process = @import("process.zig").Process; /// - when initializing the `process` field it ust be given an `updateFn`. All other callbacks are optional. /// - in any callback you can get your oiginal struct back via `process.getParent(@This())` pub const Scheduler = struct { - handlers: std.ArrayList(ProcessHandler), + processes: std.ArrayList(*Process), allocator: *std.mem.Allocator, /// helper to create and prepare a process and wrap it in a ProcessHandler - fn createProcessHandler(comptime T: type, data: var) ProcessHandler { + fn createProcessHandler(comptime T: type, data: var) *Process { var proc = std.testing.allocator.create(T) catch unreachable; proc.initialize(data); // get a closure so that we can safely deinit this later - var handlerDeinitFn = struct { + proc.process.deinit = struct { fn deinit(process: *Process, allocator: *std.mem.Allocator) void { + if (process.next) |next_process| { + next_process.deinit(next_process, allocator); + } allocator.destroy(@fieldParentPtr(T, "process", process)); } }.deinit; - return .{ - .process = &proc.process, - .deinitChild = handlerDeinitFn, - }; + return &proc.process; } + /// returned when appending a process so that sub-processes can be added to the process const Continuation = struct { - handler: *ProcessHandler, - - pub fn init(handler: *ProcessHandler) Continuation { - return .{ .handler = handler }; - } - - // TODO: fix and return this when ProcessHandler can have next be a ProcessHandler - pub fn next(self: *@This(), comptime T: type, data: var) void { // *@This() - var next_handler = createProcessHandler(T, data); - self.handler.next = .{ .deinitChild = next_handler.deinitChild, .process = next_handler.process }; - } - }; - - /// TODO: remove this when ProcessHandler can have `next` be a ProcessHandler. For now this acts as a data store - /// holding the data ProcessHandler requires. - const NextProcessHandler = struct { - deinitChild: fn (process: *Process, allocator: *std.mem.Allocator) void, process: *Process, - pub fn asProcessHandler(self: @This()) ProcessHandler { - return .{ .deinitChild = self.deinitChild, .process = self.process }; + pub fn init(process: *Process) Continuation { + return .{ .process = process }; } - }; - const ProcessHandler = struct { - deinitChild: fn (process: *Process, allocator: *std.mem.Allocator) void, - process: *Process, - next: ?NextProcessHandler = null, - - pub fn update(self: *ProcessHandler, allocator: *std.mem.Allocator) bool { - self.process.tick(); - - if (self.process.dead()) { - if (!self.process.rejected() and self.next != null) { - // kill the old Process parent - self.deinitChild(self.process, allocator); - - // overwrite our fields and kick off the next process - self.deinitChild = self.next.?.deinitChild; - self.process = self.next.?.process; - self.next = null; // TODO: when ProcessHandler can have next be a ProcessHandler - return self.update(allocator); - } else { - return true; - } - } - - return false; - } - - pub fn deinit(self: @This(), allocator: *std.mem.Allocator) void { - if (self.next) |next_handler| { - next_handler.asProcessHandler().deinit(allocator); - } - self.deinitChild(self.process, allocator); + pub fn next(self: *@This(), comptime T: type, data: var) *@This() { + self.process.next = createProcessHandler(T, data); + self.process = self.process.next.?; + return self; } }; pub fn init(allocator: *std.mem.Allocator) Scheduler { return .{ - .handlers = std.ArrayList(ProcessHandler).init(allocator), + .processes = std.ArrayList(*Process).init(allocator), .allocator = allocator, }; } pub fn deinit(self: *Scheduler) void { self.clear(); - self.handlers.deinit(); + self.processes.deinit(); } /// Schedules a process for the next tick @@ -108,22 +64,44 @@ pub const Scheduler = struct { std.debug.assert(@hasDecl(T, "initialize")); std.debug.assert(@hasField(T, "process")); - var handler = createProcessHandler(T, data); - handler.process.tick(); + var process = createProcessHandler(T, data); + process.tick(); + + self.processes.append(process) catch unreachable; + return Continuation.init(process); + } + + fn updateProcess(process: **Process, allocator: *std.mem.Allocator) bool { + const current_process = process.*; + current_process.tick(); + + if (current_process.dead()) { + if (!current_process.rejected() and current_process.next != null) { + // grab the next process and null it out so we dont double-free it later + const next_process = current_process.next.?; + current_process.next = null; + process.* = next_process; + + // kill the old Process parent + current_process.deinit(current_process, allocator); + return updateProcess(process, allocator); + } else { + return true; + } + } - self.handlers.append(handler) catch unreachable; - return Continuation.init(&self.handlers.items[self.handlers.items.len - 1]); + return false; } /// Updates all scheduled processes pub fn update(self: *Scheduler) void { - if (self.handlers.items.len == 0) return; + if (self.processes.items.len == 0) return; - var i: usize = self.handlers.items.len - 1; + var i: usize = self.processes.items.len - 1; while (true) : (i -= 1) { - if (self.handlers.items[i].update(self.allocator)) { - var dead_handler = self.handlers.swapRemove(i); - dead_handler.deinit(self.allocator); + if (updateProcess(&self.processes.items[i], self.allocator)) { + var dead_process = self.processes.swapRemove(i); + dead_process.deinit(dead_process, self.allocator); } if (i == 0) break; @@ -132,20 +110,20 @@ pub const Scheduler = struct { /// gets the number of processes still running pub fn len(self: Scheduler) usize { - return self.handlers.items.len; + return self.processes.items.len; } /// resets the scheduler to its initial state and discards all the processes pub fn clear(self: *Scheduler) void { - for (self.handlers.items) |handler| { - handler.deinit(self.allocator); + for (self.processes.items) |process| { + process.deinit(process, self.allocator); } - self.handlers.items.len = 0; + self.processes.items.len = 0; } /// Aborts all scheduled processes. Unless an immediate operation is requested, the abort is scheduled for the next tick pub fn abort(self: *Scheduler, immediately: bool) void { - for (self.handlers.items) |handler| { + for (self.processes.items) |handler| { handler.process.abort(immediately); } } @@ -170,27 +148,27 @@ test "" { } fn start(process: *Process) void { - const self = @fieldParentPtr(@This(), "process", process); + const self = process.getParent(@This()); // std.debug.warn("start {}\n", .{self.fart}); } fn aborted(process: *Process) void { - const self = @fieldParentPtr(@This(), "process", process); + const self = process.getParent(@This()); // std.debug.warn("aborted {}\n", .{self.fart}); } fn failed(process: *Process) void { - const self = @fieldParentPtr(@This(), "process", process); + const self = process.getParent(@This()); // std.debug.warn("failed {}\n", .{self.fart}); } fn succeeded(process: *Process) void { - const self = @fieldParentPtr(@This(), "process", process); + const self = process.getParent(@This()); // std.debug.warn("succeeded {}\n", .{self.fart}); } fn update(process: *Process) void { - const self = @fieldParentPtr(@This(), "process", process); + const self = process.getParent(@This()); // std.debug.warn("update {}\n", .{self.fart}); process.succeed(); } @@ -199,7 +177,9 @@ test "" { var scheduler = Scheduler.init(std.testing.allocator); defer scheduler.deinit(); - _ = scheduler.attach(Tester, 33).next(Tester, 66); + _ = scheduler.attach(Tester, 33).next(Tester, 66).next(Tester, 88).next(Tester, 99); + scheduler.update(); + scheduler.update(); scheduler.update(); scheduler.update(); scheduler.update(); diff --git a/zig-ecs/src/tests.zig b/zig-ecs/src/tests.zig index 5d91e6d..70d69f1 100644 --- a/zig-ecs/src/tests.zig +++ b/zig-ecs/src/tests.zig @@ -17,4 +17,7 @@ comptime { // resources _ = @import("resources/cache.zig"); _ = @import("resources/assets.zig"); + + // process + _ = @import("process/scheduler.zig"); }