<feed xmlns='http://www.w3.org/2005/Atom'>
<title>computeranim.git/build.zig, branch main</title>
<subtitle>Tracing debugger and animations of running programs (ztrace, canim)</subtitle>
<id>https://git.0x4200.cafe/computeranim.git/atom?h=main</id>
<link rel='self' href='https://git.0x4200.cafe/computeranim.git/atom?h=main'/>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/'/>
<updated>2026-11-11T02:25:40Z</updated>
<entry>
<title>trace: glibc's heap, read from a recording at any moment</title>
<updated>2026-11-11T02:25:40Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T02:04:17Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=58643dab07a803dbb579d84f68419911f5a2a16d'/>
<id>urn:sha1:58643dab07a803dbb579d84f68419911f5a2a16d</id>
<content type='text'>
record --heap keeps the arena, the tcache and, of every chunk, its size
word and the links of those on a list: free chunks stay readable, which
--alloc dropped at the free. zt.heap.glibc gives the chunks in address
order, the tcache's and the bins' chains (safe-linking as the stored
value and the pointer it protects), the top; each with the address of
the word it was read from, each chain saying how it ended. ztrace show
prints it. Layouts for glibc 2.44 (no fastbins; a tcache made at the
first free, counting the slots left) and 2.40; the arena found by symbol
or by the struct whose next points at itself. Against pwndbg on 2.40:
the same at every stop. Three bytes a moment and a sixth slower on the
list by instruction.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>trace: what the context draws is in the recording; SQLite on the ladder</title>
<updated>2026-11-10T19:05:20Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T19:03:43Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=66a2a7cf733f6abc1f79561c52d901ce67019fb1'/>
<id>urn:sha1:66a2a7cf733f6abc1f79561c52d901ce67019fb1</id>
<content type='text'>
An instruction's string carries its source line and, for a direct call,
how many parameters the callee takes (DWARF); telescope.frames gives each
frame's extent on the stack; with --alloc the debugger watches each live
allocation and the allocator's header before it, changes only, 256 KiB a
stop at most. C++ names are shown and found as the source has them (the
command links the C++ runtime for its demangler).

SQLite 3.50.4 through every backend, measured (README, bench/sqlite.sh).
It found two faults: a file compiled by its full path was recorded under
a path joined onto the compile directory, and ztrace run noticed a
target's exit up to 10 ms late.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
<entry>
<title>context: disassembly, telescopes and names in every stop; strings as one table</title>
<updated>2026-11-10T17:12:08Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T16:36:32Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=02aa51a6f54235cf18e627dbbfe21f21e502eb0b'/>
<id>urn:sha1:02aa51a6f54235cf18e627dbbfe21f21e502eb0b</id>
<content type='text'>
For a viewer to show what pwndbg's context shows, the debugger records it
while the memory is there: each register and the top of the stack followed
as pointers three deep (--telescope), every code address met named, eight
instructions from the pc disassembled by capstone (built from source for
x86, into the command only; pinned as in 03-codenomicom). zt.telescope
reads a chain back with the kind of memory each link points into, and
ztrace show prints the context, coloured on a terminal as pwndbg colours.

The thirty thousand strings of a small run showed that a string map in
each keyframe costs 700 bytes of tree a string: strings are now one table
for the recording, appended a batch and read whole at open. fib(12) by
instruction with everything on: 9 MB, 71 000 moments/s.
</content>
</entry>
<entry>
<title>ztrace perf takes the target's own ring: allocations among the page faults</title>
<updated>2026-11-10T15:28:33Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T15:15:20Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=952af9711cc6a4de987a9d9d45e1e36721c5b470'/>
<id>urn:sha1:952af9711cc6a4de987a9d9d45e1e36721c5b470</id>
<content type='text'>
--preload and --alloc on ztrace perf: what the agent says and what the
kernel sees are merged by time into one recording (perf.Sorted, as probe
merges BPF and perf). test-together runs a list under both.
</content>
</entry>
<entry>
<title>the backends together: a ring under the debugger, strings that do not collide</title>
<updated>2026-11-10T15:15:20Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T15:09:27Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=a7504c6bb2ec9e906891e42bc3df28b276e67143'/>
<id>urn:sha1:a7504c6bb2ec9e906891e42bc3df28b276e67143</id>
<content type='text'>
ztrace record and dbg take --ring, --preload and --alloc: the target gets
the ring ztrace run gives it, and the debugger drains it while the target
runs (polling for the stop, so a full ring cannot hold both) and before it
reports a stop. A program compiled by ztrace cc, with the agent preloaded,
stopped at breakpoints, is one recording in order; test-together checks it.

Recording such a program showed the debugger's file names and the pass's
strings both counted from 1: event.stringId (a hash, top bit set) is now
what every producer without a table of its own uses.
</content>
</entry>
<entry>
<title>build: C targets without UBSan, whose checks would be traced too</title>
<updated>2026-11-10T15:01:16Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T14:47:39Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=a0ca9a0bfa76cd2d04502b7f341cba5153f51899'/>
<id>urn:sha1:a0ca9a0bfa76cd2d04502b7f341cba5153f51899</id>
<content type='text'>
</content>
</entry>
<entry>
<title>canim is a package of its own, anim/: ztrace builds without sketchbook and pardes</title>
<updated>2026-11-10T14:47:39Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T14:47:26Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=f15f4670991110829dcf123625c049224eba9838'/>
<id>urn:sha1:f15f4670991110829dcf123625c049224eba9838</id>
<content type='text'>
</content>
</entry>
<entry>
<title>recorder: a moment is its events, state is at keyframes</title>
<updated>2026-11-10T14:47:26Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T14:46:18Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=5f1f95098611b077bd7e0ca27283fa0e02d1adbc'/>
<id>urn:sha1:5f1f95098611b077bd7e0ca27283fa0e02d1adbc</id>
<content type='text'>
Folding every event into persistent state at every moment cost 750 bytes a
step and 2 KB a scattered 8-byte write: the tree's path copied each time.
Now a moment stores its events alone, in a compact code (a flags byte,
varints, time as a difference, registers as the ones that changed), and the
state (threads, memory, heap, variables, mappings, strings) is written at a
keyframe a batch, sharing with the one before. A reader replays at most a
batch over a keyframe, and keeps four positions replayed, so playing
forward reads one moment a step.

Of a memory write the recorder keeps the spans that differ from what it
holds, so a region read again costs what changed in it. It stops at
max_bytes (1 GiB).

A step with registers: 749 bytes to 57. fib(12) by instruction, 142 000
moments: 111 MB to 8 MB, 197 000 moments/s. bench-store measures the rest.
</content>
</entry>
<entry>
<title>ztrace: the event, the ring, the recording, a ptrace loop</title>
<updated>2026-11-10T14:08:49Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T14:08:49Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=0b29354e1ddf6cf75ac4c426a00dd3435ace5069'/>
<id>urn:sha1:0b29354e1ddf6cf75ac4c426a00dd3435ace5069</id>
<content type='text'>
One 64-byte Event for every backend; a shared-memory ring from target to
tracer with stop/resume; a Recorder that folds events into xitdb moments
(registers, memory in 64-byte chunks with known-byte masks, strings) and a
Trace that reads any moment back; a minimal ptrace Process; ztrace record,
run and dump. Per-area build files so the areas grow apart.
</content>
</entry>
</feed>
