diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-05 19:17:51 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-05 22:03:21 -0300 |
| commit | 86c4f35af8505941c7472a81d8d62dca9b6e2fa9 (patch) | |
| tree | 834a7f7f27f3eeccc901341358f6d58712f91714 /src/pardes.zig | |
| parent | 9b525aca9b1fc177873bc3a581bd2a7887bee63d (diff) | |
| download | pardes-86c4f35af8505941c7472a81d8d62dca9b6e2fa9.tar.gz pardes-86c4f35af8505941c7472a81d8d62dca9b6e2fa9.zip | |
split pardes.zig by noun, Turn: the 9P turn's type, its fields, methods and the yield depth, moves whole into src/Turn.zig (a type file, its doc the turn's), and the root keeps the process's one `turn` and names the type (`pardes.Turn`); a pure move, no field of the session touched, so a dump and the wire are as they were; gates on tui: core-test 960/960, behaviour-test 238/238
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/pardes.zig')
| -rw-r--r-- | src/pardes.zig | 147 |
1 files changed, 4 insertions, 143 deletions
diff --git a/src/pardes.zig b/src/pardes.zig index 462d9481..75833e5f 100644 --- a/src/pardes.zig +++ b/src/pardes.zig @@ -82,150 +82,11 @@ pub const isolated = @import("pardes_isolation").isolated; pub const font_picker = platform == .gui or platform == .macos; -/// Whose turn it is with the core. The core is single-threaded: the editor's -/// thread has it, and lets go of it in two kinds of gap -- while it waits for -/// input (`rest`, `wake`), and while it is out in the host filesystem in the -/// middle of a step (`yield`, `back`). A 9P connection task takes the turn -/// in those gaps to answer a request (`take`, `give`), which is what lets the -/// editor read its own tree through a mount: the syscall goes out, another -/// thread answers it, the syscall comes back. A step of a connection task's -/// own -- a Look written to `look` -- goes out the same way. -/// -/// `out` counts the steps that are out. While one is, the core reads -/// consistently but that step still holds pointers into it, so nothing may -/// change it: a request that would is parked in the engine (src/9p_io.zig) -/// and retried when the turn is next given up with nothing out, which -/// `parked` remembers to arrange; and the editor's own wake waits for the -/// count to reach zero, since a step of the editor's may change anything. -/// It is never a write of its own that a step waits on out there -- writes -/// come from a shell performing a save between steps -- so a parked request -/// is never the syscall's own. -/// -/// One per process, like the editor it belongs to. A process that never -/// starts it -- a test -- has no second thread, and -/// every yield is a no-op. +/// Whose turn it is with the core (Turn.zig): one per process, like the +/// editor it belongs to. A process that never starts it -- a test -- has no +/// second thread, and every yield is a no-op. pub var turn: Turn = .{}; - -pub const Turn = struct { - mutex: std.Io.Mutex = .init, - /// Set by `start`; a process that never starts the turn has none. - io: ?std.Io = null, - /// Steps out in a host syscall, from any thread. - out: u32 = 0, - /// A request that changes a pane was parked for want of quiet. - parked: bool = false, - wake_parked: ?*const fn (?*anyopaque) void = null, - /// Answers the reads the core holds, with the turn, as it is given up. - answer_held: ?*const fn (?*anyopaque) void = null, - wake_ctx: ?*anyopaque = null, - /// Bumped each time the editor has performed what the core asked of it, - /// so a request that asked for something -- a save, a shell -- can be - /// answered once it is done rather than merely queued, the way writing - /// `put` to acme's ctl returns after the file is written. - epoch: u64 = 0, - /// Bumped each time a shell has attempted the Restore the core asked for - /// (`takeRestore`), which lives after `pump` because it swaps the core - /// out from under it; a request that asked for one waits for this. - restores: u64 = 0, - /// Bumped each time a language server's answer (or its lack) is taken - /// in (`lspResponse`): a write that asked one waits for this. - lsp_answers: u64 = 0, - /// All of the above, and `out` reaching zero. - settled: std.Io.Condition = .init, - - /// The editor's thread takes the turn for good; it has it until `stop`. - pub fn start(t: *Turn, io: std.Io) void { - t.io = io; - t.mutex.lockUncancelable(io); - } - - pub fn stop(t: *Turn) void { - const io = t.io orelse return; - t.io = null; - t.parked = false; - t.mutex.unlock(io); - } - - /// The editor is about to wait for input: anyone may have the core. - pub fn rest(t: *Turn) void { - if (t.io == null) return; - t.release(); - } - - /// The editor takes the turn back -- once every step that is out in a - /// syscall has returned, since a step of the editor's may change what - /// those still point into. - pub fn wake(t: *Turn) void { - const io = t.io orelse return; - t.mutex.lockUncancelable(io); - while (t.out != 0) t.settled.waitUncancelable(io, &t.mutex); - } - - /// Whoever has the turn is about to block in the host in the middle of - /// a step. Nests: a directory listing that resolves each entry yields - /// inside a yield, and only the outermost one lets go. - pub fn yield(t: *Turn) void { - // A replica makes no syscall: each is a site of the tape's. One that - // is none stops a speculation and diverges a replay (it joins - // again), never the process (a window client's `Term fish`, H17). - if (tape.replaying()) tape.stray(); - const io = t.io orelse return; - yield_depth += 1; - if (yield_depth != 1) return; - t.out += 1; - t.mutex.unlock(io); - } - - pub fn back(t: *Turn) void { - const io = t.io orelse return; - yield_depth -= 1; - if (yield_depth != 0) return; - t.mutex.lockUncancelable(io); - t.out -= 1; - if (t.out == 0) t.settled.broadcast(io); - } - - /// How many yields this thread is inside of. - threadlocal var yield_depth: u32 = 0; - - /// A connection task takes the turn; answers whether nothing is out - /// mid-step, which is what a request that changes a pane needs. - pub fn take(t: *Turn) bool { - t.mutex.lockUncancelable(t.io.?); - return t.out == 0; - } - - pub fn give(t: *Turn) void { - t.release(); - } - - /// One of `epoch`, `restores` or `lsp_answers` moved on: the editor - /// performed the core's effects, a shell attempted a Restore (at the - /// top of each loop step, when the previous step's attempt is over), - /// or a language server's answer was taken in. - pub fn bump(t: *Turn, counter: *u64) void { - const io = t.io orelse return; - counter.* +%= 1; - t.settled.broadcast(io); - } - - /// With the turn: waits, turn given up meanwhile, until `counter` has - /// moved past `seen`; stopping ends the wait early. - pub fn awaitPast(t: *Turn, counter: *const u64, seen: u64) void { - while (counter.* == seen) t.settled.wait(t.io.?, &t.mutex) catch return; - } - - fn release(t: *Turn) void { - // Whatever the holder just did may be what a held read waits for, - // and answering it takes the core, so before letting go. Even with - // a step out in a syscall: a read is served then, as in onServe. - if (t.answer_held) |f| f(t.wake_ctx); - const woken = t.out == 0 and t.parked; - if (woken) t.parked = false; - t.mutex.unlock(t.io.?); - if (woken) if (t.wake_parked) |f| f(t.wake_ctx); - } -}; +pub const Turn = @import("Turn.zig"); pub const can_attach = platform == .tui or platform == .gui; |
