diff options
Diffstat (limited to 'anim/scenes/fib.zig')
| -rw-r--r-- | anim/scenes/fib.zig | 59 |
1 files changed, 59 insertions, 0 deletions
diff --git a/anim/scenes/fib.zig b/anim/scenes/fib.zig new file mode 100644 index 0000000..e98727d --- /dev/null +++ b/anim/scenes/fib.zig @@ -0,0 +1,59 @@ +//! Recursion: fib(5), a call at a time. The debugger's whole context, from +//! one recording of every instruction, and beside it the lens: every call +//! of fib as a tree. +//! +//! How it moves (design/motion.md): the picture is established, then one +//! call is walked in full (the line fires, `rdi` and `rsp` strike, the +//! stack's words, then the backtrace's row and the tree's node; last the +//! marks move on); the way down the first branch is hurried, a run that +//! ramps in and out; the first return is walked (the answer in `rax`, the +//! frame leaving); the rest of the tree is a sprint with the context +//! veiled; and the last return, `fib(5)` itself, is walked again. +const anim = @import("anim"); +const canim = @import("canim"); +const recordings = @import("recordings"); + +pub const background = canim.background; +pub const scene = anim.Live(frame, struct {}); + +fn frame(s: *anim.Frame) void { + const rec = canim.open(recordings.steps); + // The calls of fib, in the order they are made: fib(5), fib(4), fib(3), fib(2), fib(1), fib(0), ... + const call = struct { + fn of(r: *canim.Recording, nth: usize) canim.Recording.Call { + return r.call("fib", nth); + } + }.of; + const split = canim.layout.split.beside; + // From main's line, about to call fib(5), to where fib(5) has returned to it. + var at = canim.cursor(s, rec, rec.lineMoment(10, rec.call("main", 0).enter)); + at.levels = .{ .idea = .calls, .source_rows = 8 }; + at.journey(.line, call(rec, 0).exit.?); + const ctx = canim.context(s, at, .{ .split = split }); + // The lens: every call of fib as a tree, beside the frames they are on the stack. + const tree = canim.callTree(s, .{ .cursor = at, .box = split.lens, .function = "fib", .focus = true }); + var says: canim.Narrator = .{}; + + // Staging: the whole picture, still, before a word; the words, before a step. + const joins = canim.ties(s, .{ .cursor = at }); + canim.establish(s, .{ ctx.clock, ctx.source, ctx.disasm, ctx.registers, ctx.stack, ctx.backtrace, tree, joins }); + says.line(s, "`fib` calls itself. A call is a frame on the stack and a node\nin the tree; its argument arrives in `rdi`."); + // The call, once, in full; and the two lines that lead to the next one. + at.walk(s, .line, rec.lineMoment(6, call(rec, 0).enter)); + s.wait(canim.theme.time.beat); + + // Pacing: the same three lines three times more. Seen once, so + // hurried: down the first branch at a run, to the call that does not call. + at.hurry(s, .line, rec.lineMoment(5, call(rec, 4).enter), .{}); + + says.line(s, "`fib(1)` needs no other call. Its answer leaves in `rax`,\nand its frame goes."); + // The return, in full: what recursion is for. + at.walk(s, .line, call(rec, 4).exit.?); + + says.line(s, "And so on through every branch: fifteen calls,\nto add up `fib(5)`."); + // The pattern is known: the rest of the tree at a sprint, the tree its + // subject, slowing into the last answers. + at.hurry(s, .line, call(rec, 10).exit.?, .{ .pace = canim.theme.time.sprint }); + at.walk(s, .line, call(rec, 0).exit.?); + s.wait(canim.theme.time.before_cut); +} |
