From cdef61d6dc0907fed81f025972804443136b7ac0 Mon Sep 17 00:00:00 2001 From: Mike Date: Sat, 13 Jun 2020 21:08:00 -0700 Subject: [PATCH] Schedular working --- zig-ecs/src/process/process.zig | 12 +++- zig-ecs/src/process/scheduler.zig | 109 ++++++++++++++++++++++-------- 2 files changed, 90 insertions(+), 31 deletions(-) diff --git a/zig-ecs/src/process/process.zig b/zig-ecs/src/process/process.zig index 104d3b1..42379e6 100644 --- a/zig-ecs/src/process/process.zig +++ b/zig-ecs/src/process/process.zig @@ -1,10 +1,12 @@ +/// 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 { const State = enum(u8) { uninitialized, running, paused, succeeded, failed, aborted, finished }; updateFn: fn (self: *Process) void, - initFn: ?fn (self: *Process) void = null, + startFn: ?fn (self: *Process) void = null, abortedFn: ?fn (self: *Process) void = null, failedFn: ?fn (self: *Process) void = null, succeededFn: ?fn (self: *Process) void = null, @@ -12,6 +14,10 @@ pub const Process = struct { state: State = .uninitialized, stopped: bool = false, + pub fn getParent(self: *Process, comptime T: type) *T { + return @fieldParentPtr(T, "process", self); + } + /// Terminates a process with success if it's still alive pub fn succeed(self: *Process) void { if (self.alive()) self.state = .succeeded; @@ -57,11 +63,11 @@ pub const Process = struct { return self.stopped; } - /// Updates a process and its internal state if required + /// Updates a process and its internal state pub fn tick(self: *Process) void { switch (self.state) { .uninitialized => { - if (self.initFn) |func| func(self); + if (self.startFn) |func| func(self); self.state = .running; }, .running => { diff --git a/zig-ecs/src/process/scheduler.zig b/zig-ecs/src/process/scheduler.zig index 7a2e3a4..05fcbcf 100644 --- a/zig-ecs/src/process/scheduler.zig +++ b/zig-ecs/src/process/scheduler.zig @@ -1,13 +1,23 @@ const std = @import("std"); const Process = @import("process.zig").Process; +/// Cooperative scheduler for processes. Each process is invoked once per tick. If a process terminates, it's +/// removed automatically from the scheduler and it's never invoked again. A process can also have a child. In +/// this case, the process is replaced with its child when it terminates if it returns with success. In case of errors, +/// both the process and its child are discarded. In order to invoke all scheduled processes, call the `update` member function +/// Processes add themselves by calling `attach` and must satisfy the following conditions: +/// - have a field `process: Process` +/// - have a method `initialize(self: *@This(), data: var) void` that initializes all fields and takes in a the data passed to `attach` +/// - 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), allocator: *std.mem.Allocator, - fn createProcessHandler(comptime T: type) ProcessHandler { + /// helper to create and prepare a process and wrap it in a ProcessHandler + fn createProcessHandler(comptime T: type, data: var) ProcessHandler { var proc = std.testing.allocator.create(T) catch unreachable; - proc.initialize(); + proc.initialize(data); // get a closure so that we can safely deinit this later var handlerDeinitFn = struct { @@ -26,13 +36,13 @@ pub const Scheduler = struct { handler: *ProcessHandler, pub fn init(handler: *ProcessHandler) Continuation { - return .{.handler = handler}; + return .{ .handler = handler }; } - // TODO: fix and return when ProcessHandler can have next be a ProcessHandler - pub fn next(self: *@This(), comptime T: type) void { // *@This() - var next_handler = createProcessHandler(T); - self.handler.next = .{.deinitChild = next_handler.deinitChild, .process = next_handler.process}; + // 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 }; } }; @@ -42,7 +52,7 @@ pub const Scheduler = struct { process: *Process, pub fn asProcessHandler(self: @This()) ProcessHandler { - return .{.deinitChild = self.deinitChild, .process = self.process}; + return .{ .deinitChild = self.deinitChild, .process = self.process }; } }; @@ -87,19 +97,17 @@ pub const Scheduler = struct { }; } - pub fn deinit(self: Scheduler) void { - for (self.handlers.items) |handler| { - handler.deinit(self.allocator); - } + pub fn deinit(self: *Scheduler) void { + self.clear(); self.handlers.deinit(); } /// Schedules a process for the next tick - pub fn attach(self: *Scheduler, comptime T: type) Continuation { + pub fn attach(self: *Scheduler, comptime T: type, data: var) Continuation { std.debug.assert(@hasDecl(T, "initialize")); std.debug.assert(@hasField(T, "process")); - var handler = createProcessHandler(T); + var handler = createProcessHandler(T, data); handler.process.tick(); self.handlers.append(handler) catch unreachable; @@ -129,7 +137,7 @@ pub const Scheduler = struct { /// 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(handler.process, self.allocator); + handler.deinit(self.allocator); } self.handlers.items.len = 0; } @@ -142,8 +150,6 @@ pub const Scheduler = struct { } }; -var fart: usize = 666; - test "" { std.debug.warn("\n", .{}); @@ -151,41 +157,40 @@ test "" { process: Process, fart: usize, - pub fn initialize(self: *@This()) void { + pub fn initialize(self: *@This(), data: var) void { self.process = .{ - .initFn = init, + .startFn = start, .updateFn = update, .abortedFn = aborted, .failedFn = failed, .succeededFn = succeeded, }; - self.fart = fart; - fart += 111; + self.fart = data; } - fn init(process: *Process) void { + fn start(process: *Process) void { const self = @fieldParentPtr(@This(), "process", process); - std.debug.warn("init {}\n", .{self.fart}); + // std.debug.warn("start {}\n", .{self.fart}); } fn aborted(process: *Process) void { const self = @fieldParentPtr(@This(), "process", process); - std.debug.warn("aborted {}\n", .{self.fart}); + // std.debug.warn("aborted {}\n", .{self.fart}); } fn failed(process: *Process) void { const self = @fieldParentPtr(@This(), "process", process); - std.debug.warn("failed {}\n", .{self.fart}); + // std.debug.warn("failed {}\n", .{self.fart}); } fn succeeded(process: *Process) void { const self = @fieldParentPtr(@This(), "process", process); - std.debug.warn("succeeded {}\n", .{self.fart}); + // std.debug.warn("succeeded {}\n", .{self.fart}); } fn update(process: *Process) void { const self = @fieldParentPtr(@This(), "process", process); - std.debug.warn("update {}\n", .{self.fart}); + // std.debug.warn("update {}\n", .{self.fart}); process.succeed(); } }; @@ -193,8 +198,56 @@ test "" { var scheduler = Scheduler.init(std.testing.allocator); defer scheduler.deinit(); - _ = scheduler.attach(Tester).next(Tester); + _ = scheduler.attach(Tester, 33).next(Tester, 66); scheduler.update(); scheduler.update(); scheduler.update(); } + +test "scheduler.clear" { + const Tester = struct { + process: Process, + + pub fn initialize(self: *@This(), data: var) void { + self.process = .{ .updateFn = update }; + } + + fn update(process: *Process) void { + std.debug.assert(false); + } + }; + + var scheduler = Scheduler.init(std.testing.allocator); + defer scheduler.deinit(); + + _ = scheduler.attach(Tester, {}).next(Tester, {}); + scheduler.clear(); + scheduler.update(); +} + +test "scheduler.attach.next" { + const Tester = struct { + process: Process, + counter: *usize, + + pub fn initialize(self: *@This(), data: var) void { + self.process = .{ .updateFn = update }; + self.counter = data; + } + + fn update(process: *Process) void { + const self = process.getParent(@This()); + self.counter.* += 1; + process.succeed(); + } + }; + + var scheduler = Scheduler.init(std.testing.allocator); + defer scheduler.deinit(); + + var counter: usize = 0; + _ = scheduler.attach(Tester, &counter).next(Tester, &counter); + scheduler.update(); + scheduler.update(); + std.testing.expectEqual(counter, 2); +}