From 3c82b8a6a5f069d638d9965e8ef80ea2ba74d07f Mon Sep 17 00:00:00 2001 From: kayomn Date: Sat, 1 Oct 2022 17:46:21 +0100 Subject: [PATCH] Implement file system worker thread in event loop --- src/main.zig | 14 ++- src/mem.zig | 2 +- src/sys.zig | 251 ++++++++++++++++++++++++++++++++++++++++----------- 3 files changed, 211 insertions(+), 56 deletions(-) diff --git a/src/main.zig b/src/main.zig index df4429f..fa46208 100644 --- a/src/main.zig +++ b/src/main.zig @@ -17,16 +17,22 @@ pub fn main() anyerror!void { fn run(event_loop: *sys.EventLoop, graphics: *sys.GraphicsContext) anyerror!void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + defer _ = gpa.deinit(); + { - const file_access = - try event_loop.open(.readonly, try sys.FileSystem.data.pathJoin(&.{"data", "ona.lua"})); + const file_access = try event_loop.open(.readonly, + try sys.FileSystem.data.joinedPath(&.{"data", "ona.lua"})); defer _ = event_loop.close(file_access); const file_size = try file_access.size(event_loop); - var buffer = try gpa.allocator().alloc(u8, file_size); + const allocator = gpa.allocator(); + const buffer = try allocator.alloc(u8, file_size); - if ((try event_loop.readFile(file_access, buffer)) != file_size) return error.ScriptLoadError; + defer allocator.free(buffer); + + if ((try event_loop.readFile(file_access, buffer)) != file_size) + return error.ScriptLoadFailure; event_loop.log(buffer); } diff --git a/src/mem.zig b/src/mem.zig index 4c489cb..d866b2c 100644 --- a/src/mem.zig +++ b/src/mem.zig @@ -34,7 +34,7 @@ pub fn Spliterator(comptime Element: type) type { while (self.hasNext()) { var cursor = @as(usize, 0); - var window = self.source[cursor .. (self.source - cursor)]; + var window = self.source[cursor .. (self.source.len - cursor)]; defer self.source = window; diff --git a/src/sys.zig b/src/sys.zig index 9cae5bf..e857989 100644 --- a/src/sys.zig +++ b/src/sys.zig @@ -11,29 +11,56 @@ const std = @import("std"); /// /// pub const EventLoop = opaque { - const Implementation = struct { - current_message: ?*Message, + /// + /// + /// + const FileSystemMessage = struct { + next: ?*FileSystemMessage = null, + frame: anyframe, + + request: union(enum) { + close: struct { + file_access: *FileAccess, + }, + + open: struct { + mode: OpenMode, + path: *const FileSystem.Path, + result: OpenError!*FileAccess = error.NotFound, + }, + + read_file: struct { + file_access: *FileAccess, + buffer: []const u8, + result: FileError!usize = error.Inaccessible, + }, + + seek_file: struct { + file_access: *FileAccess, + origin: SeekOrigin, + offset: usize, + result: FileError!void = error.Inaccessible, + }, + + tell_file: struct { + file_access: *FileAccess, + result: FileError!usize = error.Inaccessible, + }, + }, }; /// /// /// - const Message = struct { - next: ?*Message, - frame: anyframe, + const Implementation = struct { + user_prefix: []const u8, + file_system_semaphore: *ext.SDL_Semaphore, + file_system_thread: *ext.SDL_Thread, + file_system_messages: ?*FileSystemMessage = null, - request: union(enum) { - open: struct { - mode: OpenMode, - path: *const FileSystem.Path, - }, - }, - - response: union(enum) { - none, - file_access: *FileAccess, - file_error: FileError, - } = .none, + fn cast(event_loop: *EventLoop) *Implementation { + return @ptrCast(*Implementation, @alignCast(@alignOf(Implementation), event_loop)); + } }; /// @@ -41,6 +68,7 @@ pub const EventLoop = opaque { /// pub const OpenError = error { NotFound, + BadFileSystem, }; /// @@ -55,34 +83,42 @@ pub const EventLoop = opaque { /// /// /// - pub fn close(event_loop: *EventLoop, file_access: *FileAccess) void { - var message = Message{ - .frame = @frame(), + pub const SeekOrigin = enum { + head, + tail, + current, + }; - .request = .{ - .close = .{ - .file_access = file_access, - }, - }, + /// + /// + /// + pub fn close(event_loop: *EventLoop, file_access: *FileAccess) void { + var message = FileSystemMessage{ + .frame = @frame(), + .request = .{.close = .{.file_access = file_access}}, }; - suspend event_loop.enqueueMessage(&message); + suspend event_loop.enqueueFileSystemMessage(&message); } /// /// /// - fn enqueueMessage(event_loop: *EventLoop, message: *Message) void { - const implementation = - @ptrCast(*Implementation, @alignCast(@alignOf(Implementation), event_loop)); + pub fn enqueueFileSystemMessage(event_loop: *EventLoop, message: *FileSystemMessage) void { + const implementation = Implementation.cast(event_loop); - if (implementation.current_message) |current_message| { - current_message.next = message; + if (implementation.file_system_messages) |messages| { + messages.next = message; } else { - implementation.current_message = message; + implementation.file_system_messages = message; } + + // TODO: Post message to FS thread to perform task. } + /// + /// + /// pub fn log(event_loop: *EventLoop, message: []const u8) void { // TODO: Implement. _ = event_loop; @@ -95,7 +131,7 @@ pub const EventLoop = opaque { pub fn open(event_loop: *EventLoop, mode: OpenMode, path: FileSystem.Path) OpenError!*FileAccess { - var message = Message{ + var message = FileSystemMessage{ .frame = @frame(), .request = .{ @@ -106,13 +142,80 @@ pub const EventLoop = opaque { }, }; - suspend event_loop.enqueueMessage(&message); + suspend event_loop.enqueueFileSystemMessage(&message); - switch (message.response) { - .file_access => |file_access| return file_access, - .open_error => |open_error| return open_error, - else => unreachable, + return message.request.open.result; + } + + /// + /// + /// + fn processFileSystemMessages(data: ?*anyopaque) callconv(.C) c_int { + const implementation = Implementation.cast(@ptrCast(*EventLoop, data orelse unreachable)); + + while (implementation.file_system_messages) |messages| { + switch (messages.request) { + .open => |*open_request| { + switch (open_request.path.file_system) { + .data => { + // TODO: Implement + open_request.result = error.NotFound; + }, + + .user => { + var path_buffer = std.mem.zeroes([4096]u8); + var path = stack.Fixed(u8){.buffer = path_buffer[0 .. ]}; + + path.pushAll(implementation.user_prefix) catch { + open_request.result = error.BadFileSystem; + + continue; + }; + + if (!open_request.path.write(path.writer())) { + open_request.result = error.NotFound; + + continue; + } + + if (ext.SDL_RWFromFile(&path_buffer, switch (open_request.mode) { + .readonly => "rb", + .overwrite => "wb", + .append => "ab", + })) |rw_ops| { + open_request.result = @ptrCast(*FileAccess, rw_ops); + } else { + open_request.result = error.NotFound; + } + }, + } + }, + + .close => |*close_request| { + // Don't care if this doesn't work. + _ = ext.SDL_RWclose(@ptrCast(*ext.SDL_RWops, @alignCast( + @alignOf(ext.SDL_RWops), close_request.file_access))); + }, + + .read_file => |read_request| { + _ = read_request; + }, + + .seek_file => |seek_request| { + _ = seek_request; + }, + + .tell_file => |tell_request| { + _ = tell_request; + }, + } + + resume messages.frame; + + implementation.file_system_messages = messages.next; } + + return 0; } /// @@ -121,7 +224,7 @@ pub const EventLoop = opaque { pub fn readFile(event_loop: *EventLoop, file_access: *FileAccess, buffer: []const u8) FileError!usize { - var message = Message{ + var message = FileSystemMessage{ .frame = @frame(), .request = .{ @@ -132,13 +235,46 @@ pub const EventLoop = opaque { }, }; - suspend event_loop.enqueueMessage(&message); + suspend event_loop.enqueueFileSystemMessage(&message); - switch (message.response) { - .size => |size| return size, - .file_error => |file_error| return file_error, - else => unreachable, - } + return message.request.read_file.result; + } + + /// + /// + /// + pub fn seekFile(event_loop: *EventLoop, file_access: *FileAccess, + origin: SeekOrigin, offset: usize) FileError!void { + + var message = FileSystemMessage{ + .frame = @frame(), + + .request = .{ + .seek_file = .{ + .file_access = file_access, + .origin = origin, + .offset = offset, + }, + }, + }; + + suspend event_loop.enqueueFileSystemMessage(&message); + + return message.request.seek_file.result; + } + + /// + /// + /// + pub fn tellFile(event_loop: *EventLoop, file_access: *FileAccess) FileError!usize { + var message = FileSystemMessage{ + .frame = @frame(), + .request = .{.tell_file = .{.file_access = file_access}}, + }; + + suspend event_loop.enqueueFileSystemMessage(&message); + + return message.request.tell_file.result; } }; @@ -230,18 +366,18 @@ pub const FileSystem = enum { /// /// Creates and returns a [Path] value in the file system to the location specified by the - /// joining of the `component_groups` path values. + /// joining of the `sequences` path values. /// - pub fn pathJoin(file_system: FileSystem, component_groups: []const []const u8) PathError!Path { + pub fn joinedPath(file_system: FileSystem, sequences: []const []const u8) PathError!Path { var path = Path{ .file_system = file_system, .buffer = std.mem.zeroes([Path.max]u8), .length = 0, }; - for (component_groups) |component_group| if (component_group.len != 0) { + for (sequences) |sequence| if (sequence.len != 0) { var components = mem.Spliterator(u8){ - .source = component_group, + .source = sequence, .delimiter = "/", }; @@ -272,7 +408,11 @@ pub const GraphicsContext = opaque { /// /// pub const Event = struct { + keys_up: Keys = std.mem.zeroes(Keys), + keys_down: Keys = std.mem.zeroes(Keys), + keys_held: Keys = std.mem.zeroes(Keys), + const Keys = [256]bool; }; const Implementation = struct { @@ -283,7 +423,6 @@ pub const GraphicsContext = opaque { /// /// pub fn poll(graphics_context: *GraphicsContext) ?*const Event { - // TODO: Implement. _ = graphics_context; return null; @@ -355,9 +494,19 @@ pub fn runGraphics(comptime Errors: anytype, run: GraphicsRunner(Errors)) Errors defer ext.SDL_DestroyRenderer(renderer); var event_loop = EventLoop.Implementation{ - .current_message = null, + .file_system_semaphore = ext.SDL_CreateSemaphore(0) orelse return error.InitFailure, + + .file_system_thread = ext.SDL_CreateThread(EventLoop.processFileSystemMessages, + "File System Worker", &event_loop) orelse return error.InitFailure, + + .user_prefix = pref_path, }; + defer { + ext.SDL_DestroyThread(event_loop.file_system_thread); + ext.SDL_DestroySemaphore(event_loop.file_system_semaphore); + } + var graphics_context = GraphicsContext.Implementation{ .event = .{