diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-16 18:04:21 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-16 18:04:21 -0300 |
| commit | e77b01d4b5504cea08a3f88cf8502897d868a1d3 (patch) | |
| tree | c8e643d234dd26d920cbc563bfa7f740febf1fc7 /src/host/control.zig | |
| parent | d3074636fff0fbcd5fd9b71c0c3b1c1f5c0c1285 (diff) | |
| download | sketchbook-e77b01d4b5504cea08a3f88cf8502897d868a1d3.tar.gz sketchbook-e77b01d4b5504cea08a3f88cf8502897d868a1d3.zip | |
Add glTF scene rendering, resource setup and 9P controls
Diffstat (limited to 'src/host/control.zig')
| -rw-r--r-- | src/host/control.zig | 368 |
1 files changed, 368 insertions, 0 deletions
diff --git a/src/host/control.zig b/src/host/control.zig new file mode 100644 index 0000000..58b41b3 --- /dev/null +++ b/src/host/control.zig @@ -0,0 +1,368 @@ +//! Local 9P controls, serviced on the frame thread: no SDL or state races. +const std = @import("std"); +const c9 = @import("cloud9"); +const c = @import("c"); +const Host = @import("Host.zig"); +const fs = c9.fs; +const transport = c9.transport; +const Backend = struct { + pub const Req = fs.Req; + pub const Reply = fs.Reply; +}; +const Server = fs.Server(Backend, .{ .fid_capacity = 32, .slot_capacity = 4 }); +const msize = 16384; +const names = [_][]const u8{ "/", "ctl", "status", "log", "screen.png", "profile", "profile-trace" }; + +const Connection = struct { + fd: c_int = -1, + server: Server = undefined, + input: [msize]u8 = undefined, + output: [msize * 2]u8 = undefined, + incoming: [msize]u8 = undefined, + used: usize = 0, + snapshots: [32]?[]u8 = @splat(null), + + fn close(self: *Connection, a: std.mem.Allocator) void { + if (self.fd < 0) return; + transport.close(self.fd); + for (&self.snapshots) |*snapshot| if (snapshot.*) |bytes| { + a.free(bytes); + snapshot.* = null; + }; + self.fd = -1; + } +}; + +pub const Control = struct { + allocator: std.mem.Allocator, + path: [:0]u8, + listener: c_int, + connections: [4]Connection = @splat(.{}), + png: []u8 = &.{}, + capture_pending: bool = false, + generation: u64 = 0, + capture_error: ?anyerror = null, + + pub fn init(a: std.mem.Allocator, path: []const u8) !*Control { + const self = try a.create(Control); + errdefer a.destroy(self); + const z = try a.dupeSentinel(u8, path, 0); + errdefer a.free(z); + // Refuse an existing path; never unlink another process's socket. + const fd = try transport.listenFd(.{ .unix = z }, 4); + errdefer { + transport.close(fd); + _ = std.c.unlink(z); + } + if (std.c.chmod(z, 0o600) != 0) return error.SocketPermissions; + self.* = .{ .allocator = a, .path = z, .listener = fd }; + return self; + } + + pub fn deinit(self: *Control) void { + for (&self.connections) |*conn| conn.close(self.allocator); + transport.close(self.listener); + _ = std.c.unlink(self.path); + self.allocator.free(self.path); + self.allocator.free(self.png); + self.allocator.destroy(self); + } + + pub fn poll(self: *Control, host: *Host) void { + if (transport.acceptFd(self.listener, false) catch null) |fd| { + var accepted = false; + for (&self.connections) |*conn| if (conn.fd < 0) { + conn.fd = fd; + conn.used = 0; + conn.server = .init(.{ .in = &conn.input, .out = &conn.output, .root = 1 }); + accepted = true; + break; + }; + if (!accepted) transport.close(fd); + } + for (&self.connections) |*conn| { + if (conn.fd < 0) continue; + self.service(host, conn) catch conn.close(self.allocator); + } + } + + fn service(self: *Control, host: *Host, conn: *Connection) !void { + // Bound work per frame, including clients which continually write. + for (0..32) |_| { + var progressed = false; + if (conn.used != 0) { + const consumed = conn.server.push(conn.incoming[0..conn.used]); + std.mem.copyForwards(u8, &conn.incoming, conn.incoming[consumed..conn.used]); + conn.used -= consumed; + progressed = consumed != 0; + } + while (conn.server.next()) |req| self.answer(host, conn, req); + if (conn.server.protocol.dead) return error.Closed; + if (conn.server.output().len > 0) { + if (try transport.write(conn.fd, conn.server.output())) |n| { + if (n == 0) return error.Closed; + conn.server.wrote(n); + progressed = true; + } + } + if (conn.used < conn.incoming.len) { + if (try transport.read(conn.fd, conn.incoming[conn.used..])) |n| { + if (n == 0) return error.Closed; + conn.used += n; + progressed = true; + } + } + if (!progressed) break; + } + } + + fn answer(self: *Control, host: *Host, conn: *Connection, req: fs.Req) void { + var reply: fs.Reply = .{ .tag = req.tag }; + var buffer: [msize]u8 = undefined; + const bytes = self.respond(host, conn, req, &reply, &buffer) catch |err| blk: { + reply = .{ .tag = req.tag, .status = .err, .errno = fs.E.INVAL, .ename = @errorName(err) }; + break :blk &.{}; + }; + conn.server.reply(&reply, bytes); + } + + fn respond(self: *Control, host: *Host, conn: *Connection, req: fs.Req, reply: *fs.Reply, buffer: []u8) ![]const u8 { + if (req.node < 1 or req.node > names.len) return error.UnknownFile; + switch (req.op) { + .lookup => { + if (req.node != 1) return error.NotDirectory; + for (names[1..], 2..) |name, node| if (std.mem.eql(u8, name, req.data)) { + reply.attr = self.attr(node); + return &.{}; + }; + return error.UnknownFile; + }, + .getattr => reply.attr = self.attr(req.node), + .open => { + if (req.node == 5 or req.node == 7) { + if (req.node == 5) { + if (self.capture_pending) return error.CapturePending; + if (self.capture_error) |err| return err; + if (self.png.len == 0) return error.CaptureScreenshotFirst; + } + for (&conn.snapshots, 1..) |*slot, handle| if (slot.* == null) { + slot.* = if (req.node == 5) try self.allocator.dupe(u8, self.png) else try self.trace(host); + reply.handle = @intCast(handle); + return &.{}; + }; + return error.TooManySnapshots; + } + }, + .release => if (req.opened and req.handle > 0 and req.handle <= conn.snapshots.len) { + const slot = &conn.snapshots[req.handle - 1]; + if (slot.*) |bytes| self.allocator.free(bytes); + slot.* = null; + }, + .readdir => { + if (req.node != 1) return error.NotDirectory; + var used: usize = 0; + for (names[1..], 0..) |name, index| { + if (index < req.off) continue; + std.mem.writeInt(u64, buffer[used..][0..8], index + 2, .little); + buffer[used + 8] = 0; + buffer[used + 9] = @intCast(name.len); + @memcpy(buffer[used + 10 ..][0..name.len], name); + used += 10 + name.len; + } + return buffer[0..used]; + }, + .read => { + var writer: std.Io.Writer = .fixed(buffer); + const bytes: []const u8 = switch (req.node) { + 2 => "Write one console command per line. screenshot captures the next frame.\n", + 3 => blk: { + try writer.print("name {s}\nsize {d} {d}\nmode {t}\ngpu {s}\nscreenshot_pending {}\nscreenshot_generation {d}\nscreenshot_error {s}\n", .{ host.name, host.canvas[0], host.canvas[1], host.timeline.mode, if (host.gpu != null) "yes" else "no", self.capture_pending, self.generation, if (self.capture_error) |err| @errorName(err) else "none" }); + break :blk writer.buffered(); + }, + 4 => blk: { + for (host.console.lines) |line| { + try writer.writeAll(line.bytes[0..line.len]); + try writer.writeByte('\n'); + } + break :blk writer.buffered(); + }, + 5, 7 => if (req.handle > 0 and req.handle <= conn.snapshots.len) conn.snapshots[req.handle - 1] orelse return error.InvalidHandle else return error.InvalidHandle, + 6 => blk: { + const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled; + const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled; + try writer.print("# CPU wall milliseconds including GPU submission and fence wait; not hardware timestamps\n# frames {d}\nlabel\tcount\tmean_ms\tworst_ms\tp95_ms\tp99_ms\n", .{gpu.frame - profile.start_frame}); + var entries = profile.entries.iterator(); + while (entries.next()) |entry| { + const value = entry.value_ptr; + const percentiles = value.percentiles(); + const count: f64 = @floatFromInt(@max(value.count, 1)); + try writer.print("{s}\t{d}\t{d:.6}\t{d:.6}\t{d:.6}\t{d:.6}\n", .{ entry.key_ptr.*, value.count, @as(f64, @floatFromInt(value.total)) / count / std.time.ns_per_ms, @as(f64, @floatFromInt(value.worst)) / std.time.ns_per_ms, @as(f64, @floatFromInt(percentiles[0])) / std.time.ns_per_ms, @as(f64, @floatFromInt(percentiles[1])) / std.time.ns_per_ms }); + } + break :blk writer.buffered(); + }, + else => return error.NotFile, + }; + return window(bytes, req.off, req.size); + }, + .write => { + if (req.node != 2) return error.ReadOnly; + if (req.data.len > 4096 or std.mem.indexOfScalar(u8, req.data, 0) != null) return error.InvalidCommand; + var lines = std.mem.tokenizeScalar(u8, req.data, '\n'); + while (lines.next()) |raw| { + const line = std.mem.trim(u8, raw, " \t\r"); + if (std.mem.eql(u8, line, "screenshot")) { + self.capture_pending = true; + self.capture_error = null; + } else if (std.mem.eql(u8, line, "profile-reset")) { + const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled; + const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled; + for (profile.entries.values()) |*entry| entry.* = .{}; + profile.start_frame = gpu.frame; + } else try host.runLine(line, c.SDL_GetTicksNS()); + } + reply.written = @intCast(req.data.len); + }, + .setattr => { + if (req.node != 2 or !req.truncate) return error.ReadOnly; + reply.attr = self.attr(req.node); + }, + } + return &.{}; + } + + fn trace(self: *Control, host: *Host) ![]u8 { + const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled; + const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled; + const buffer = try self.allocator.alloc(u8, 256 << 10); + defer self.allocator.free(buffer); + var writer: std.Io.Writer = .fixed(buffer); + try writer.writeAll("label,sample,ns\n"); + var entries = profile.entries.iterator(); + while (entries.next()) |entry| { + const value = entry.value_ptr; + for (0..value.retained()) |i| { + try writer.writeByte('"'); + for (entry.key_ptr.*) |ch| { + if (ch == '"') try writer.writeByte('"'); + try writer.writeByte(ch); + } + try writer.print("\",{d},{d}\n", .{ value.count - value.retained() + i + 1, value.sample(i) }); + } + } + return self.allocator.dupe(u8, writer.buffered()); + } + + fn attr(self: *Control, node: u64) fs.Attr { + return .{ .name = names[@intCast(node - 1)], .node = node, .dir = node == 1, .mode = if (node == 1) 0o700 else if (node == 2) 0o600 else 0o400, .size = if (node == 5) self.png.len else 0, .version = if (node == 5) @truncate(self.generation) else 0 }; + } + + pub fn capture(self: *Control, surface: *c.SDL_Surface) void { + self.capture_pending = false; + self.save(surface) catch |err| { + self.capture_error = err; + }; + } + + fn save(self: *Control, surface: *c.SDL_Surface) !void { + const stream = c.SDL_IOFromDynamicMem() orelse return error.CaptureStream; + defer _ = c.SDL_CloseIO(stream); + if (!c.SDL_SavePNG_IO(surface, stream, false)) return error.EncodePng; + const size = c.SDL_GetIOSize(stream); + if (size <= 0) return error.EncodePng; + const pointer = c.SDL_GetPointerProperty(c.SDL_GetIOProperties(stream), c.SDL_PROP_IOSTREAM_DYNAMIC_MEMORY_POINTER, null) orelse return error.EncodePng; + const png = try self.allocator.dupe(u8, @as([*]const u8, @ptrCast(pointer))[0..@intCast(size)]); + self.allocator.free(self.png); + self.png = png; + self.generation += 1; + } +}; + +fn window(bytes: []const u8, offset: u64, count: u32) []const u8 { + if (offset >= bytes.len) return &.{}; + const start: usize = @intCast(offset); + return bytes[start..][0..@min(count, bytes.len - start)]; +} + +test "9P reads respect offsets, counts and EOF" { + try std.testing.expectEqualStrings("cd", window("abcdef", 2, 2)); + try std.testing.expectEqualStrings("ef", window("abcdef", 4, 200)); + try std.testing.expectEqualStrings("", window("abcdef", std.math.maxInt(u64), 10)); +} + +test "control writes validate and screenshot opens pin an immutable snapshot" { + const a = std.testing.allocator; + var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 }; + var host: Host = undefined; // These backend operations do not access the host. + var conn: Connection = .{}; + var reply: fs.Reply = .{ .tag = 1 }; + var buf: [256]u8 = undefined; + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .setattr, .node = 2, .truncate = true }, &reply, &buf); + try std.testing.expectError(error.ReadOnly, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 3, .data = "screenshot" }, &reply, &buf)); + try std.testing.expectError(error.InvalidCommand, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "screenshot\x00" }, &reply, &buf)); + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "screenshot\n" }, &reply, &buf); + try std.testing.expect(control.capture_pending); + try std.testing.expectError(error.CapturePending, control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 5 }, &reply, &buf)); + control.capture_pending = false; + control.png = try a.dupe(u8, "first image"); + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 5 }, &reply, &buf); + const handle = reply.handle; + a.free(control.png); + control.png = try a.dupe(u8, "second image"); + defer a.free(control.png); + const bytes = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 5, .handle = handle, .size = 100 }, &reply, &buf); + try std.testing.expectEqualStrings("first image", bytes); + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 5, .handle = handle, .opened = true }, &reply, &buf); + try std.testing.expect(conn.snapshots[handle - 1] == null); +} + +test "control writes reset profiling counters while retaining labels" { + const a = std.testing.allocator; + var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 }; + var host: Host = undefined; + host.passes = null; + var conn: Connection = .{}; + var reply: fs.Reply = .{ .tag = 1 }; + var buf: [512]u8 = undefined; + const reset: fs.Req = .{ .tag = 1, .op = .write, .node = 2, .data = "profile-reset\n" }; + try std.testing.expectError(error.ProfilingDisabled, control.respond(&host, &conn, reset, &reply, &buf)); + host.passes = @as(@import("gpu"), undefined); + const gpu = &host.passes.?; + gpu.profile = .init(a); + defer gpu.profile.?.deinit(); + const profile = &gpu.profile.?; + try profile.entries.put(profile.arena.allocator(), "scene", .{}); + profile.entries.values()[0].add(400_000); + profile.entries.values()[0].add(600_000); + gpu.frame = 420; + const read: fs.Req = .{ .tag = 1, .op = .read, .node = 6, .size = buf.len }; + const before = try control.respond(&host, &conn, read, &reply, &buf); + try std.testing.expect(std.mem.indexOf(u8, before, "scene\t2\t0.500000\t0.600000") != null); + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 7 }, &reply, &buf); + const trace_handle = reply.handle; + _ = try control.respond(&host, &conn, reset, &reply, &buf); + const trace = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 7, .handle = trace_handle, .size = 100 }, &reply, &buf); + try std.testing.expectEqualStrings("label,sample,ns\n\"scene\",1,400000\n\"scene\",2,600000\n", trace); + _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 7, .handle = trace_handle, .opened = true }, &reply, &buf); + try std.testing.expect(conn.snapshots[trace_handle - 1] == null); + try std.testing.expectEqual(@as(usize, 1), profile.entries.count()); + try std.testing.expectEqual(@as(u64, 0), profile.entries.values()[0].total); + try std.testing.expectEqual(@as(u64, 420), profile.start_frame); + const after = try control.respond(&host, &conn, read, &reply, &buf); + try std.testing.expect(std.mem.indexOf(u8, after, "# frames 0") != null); + try std.testing.expect(std.mem.indexOf(u8, after, "scene\t0\t0.000000\t0.000000") != null); +} + +test "control writes profiling ring retains latest samples and nearest rank percentiles" { + var entry: @import("gpu").Profile.Entry = .{}; + for (1..4100) |ns| entry.add(ns); + try std.testing.expectEqual(@as(u64, 4099), entry.count); + try std.testing.expectEqual(@as(usize, 2048), entry.retained()); + try std.testing.expectEqual(@as(u64, 2052), entry.sample(0)); + try std.testing.expectEqual(@as(u64, 4099), entry.sample(2047)); + try std.testing.expectEqual([2]u64{ 3997, 4079 }, entry.percentiles()); + entry = .{}; + try std.testing.expectEqual(@as(usize, 0), entry.retained()); + try std.testing.expectEqual([2]u64{ 0, 0 }, entry.percentiles()); + entry.add(20); + try std.testing.expectEqual([2]u64{ 20, 20 }, entry.percentiles()); +} |
