diff options
Diffstat (limited to 'anim/src/heap.zig')
| -rw-r--r-- | anim/src/heap.zig | 105 |
1 files changed, 0 insertions, 105 deletions
diff --git a/anim/src/heap.zig b/anim/src/heap.zig deleted file mode 100644 index e9a0dcf..0000000 --- a/anim/src/heap.zig +++ /dev/null @@ -1,105 +0,0 @@ -//! The heap, to scale: a strip along the addresses malloc handed out, each -//! live allocation a green block with the name of what points at it, each -//! freed one hollow and dashed, the allocator's own bytes between them -//! filled, and the bytes this step wrote in vermilion where they are. -//! Reads `Moment.heap`, and the recording's index of every allocation made. -const std = @import("std"); -const sk = @import("sketch"); -const anim = @import("anim"); -const ui = @import("ui.zig"); -const cursors = @import("cursor.zig"); -const Cursor = cursors.Cursor; -const Recording = @import("Recording.zig"); -const objects = @import("objects.zig"); -const theme = ui.theme; -const Rect = ui.Rect; -const t = theme.color.text; - -pub const Heap = struct { - cursor: Cursor, - box: Rect, - /// Variables each with a pigment (by its place here), as elsewhere. - track: []const []const u8 = &.{}, - focus: bool = false, - - pub fn draw(h: *const Heap, f: *sk.Frame, at: anim.Placed) void { - const u: ui.Ui = .{ .f = f, .at = at }; - const now = h.cursor.now(at); - const rec = h.cursor.rec; - // The heap is memory: what a step did to it shows when memory strikes. - const moment = now.shown(.memory); - const at_moment = now.stop(.memory); - // Not "heap": a grid of the same bytes beside it has that name. - const body = u.panel(h.box.w, h.box.h, "heap map", .{ .focus = h.focus, .note = "to scale ยท low addresses on the left" }); - if (rec.allocations.len == 0) return; - // The whole run's span, so nothing moves as chunks come and go. - var lo: u64 = std.math.maxInt(u64); - var hi: u64 = 0; - for (rec.allocations) |a| { - lo = @min(lo, a.ptr); - hi = @max(hi, a.ptr + a.size); - } - lo -|= 16; - const pad = theme.metric.panel.pad_x + 8; - const scale = @min(theme.metric.heap.units_per_byte, (body.w - 2 * pad - 60) / @as(f32, @floatFromInt(hi - lo))); - const strip_h: f32 = if (body.h < 220) theme.metric.heap.strip_h_stacked else theme.metric.heap.strip_h; - const y = body.y + (body.h - strip_h) / 2 - 6; - const live = moment.heap(f.scratch) catch return; - - // Never used: a rule frame. The allocator's own bytes, filled: - // whatever lies between what it has handed out so far. - var used = lo; - for (rec.allocations) |a| { - if (a.moment <= at_moment) used = @max(used, a.ptr + a.size); - } - u.frame(.{ .x = pad, .y = y, .w = @as(f32, @floatFromInt(hi - lo)) * scale, .h = strip_h }, theme.color.rule, theme.stroke.rule); - u.fill(.{ .x = pad, .y = y, .w = @as(f32, @floatFromInt(used - lo)) * scale, .h = strip_h }, theme.color.rule); - // Where it goes on. - for (0..3) |i| u.fill(.{ .x = pad + @as(f32, @floatFromInt(hi - lo)) * scale + 16 + @as(f32, @floatFromInt(i)) * 14, .y = y + strip_h / 2 - 3, .w = 6, .h = 6 }, t.faint); - - for (rec.allocations, 0..) |a, i| { - if (a.moment > at_moment) continue; - // The newest allocation at this address is the one to draw. - const newest = for (rec.allocations[i + 1 ..]) |later| { - if (later.ptr == a.ptr and later.moment <= at_moment) break false; - } else true; - if (!newest) continue; - const r: Rect = .{ .x = pad + @as(f32, @floatFromInt(a.ptr - lo)) * scale, .y = y, .w = @as(f32, @floatFromInt(a.size)) * scale - 2, .h = strip_h }; - const is_live = for (live) |l| { - if (l.ptr == a.ptr and l.born == a.event) break true; - } else false; - u.fill(r, theme.color.page); - if (is_live) { - const mark = theme.mark(.allocated); - const fresh = a.moment > now.stops[1]; - const p = if (fresh) now.moving(.memory, 0, theme.time.quick) else 1; - u.faded(p).fill(r, mark.ember); - u.faded(p).frame(r, mark.solid, theme.stroke.line); - // The bytes this step wrote, where they are. - var b: u64 = 0; - while (b < a.size) : (b += 8) { - // The same strike as the words beside it, at scale: no arm, no pulse. - var heat = now.written(a.ptr + b, @min(8, a.size - b), .memory, 0); - heat.arm = 0; - heat.out = 0; - if (heat.level > 0) _ = u.written(.{ .x = r.x + @as(f32, @floatFromInt(b)) * scale + 3, .y = y + 3, .w = @as(f32, @floatFromInt(@min(8, a.size - b))) * scale - 4, .h = strip_h - 6 }, heat, null); - } - // Who points at it. - var x = r.x + 6; - for (objects.pointing(f.scratch, rec, moment, a.ptr)) |v| { - const name = rec.name(v.name); - const w = u.width(.mono, theme.size.mono.small, name); - if (x + w > r.x + r.w - 4) break; - const tracked = for (h.track, 0..) |want, k| { - if (std.mem.eql(u8, want, name)) break k; - } else null; - if (tracked) |k| u.fill(.{ .x = x - 4, .y = y + strip_h - 36, .w = w + 8, .h = 30 }, theme.color.pigment[k % theme.color.pigment.len]); - u.text(.mono, theme.size.mono.small, x, y + strip_h - 12, name, t.primary); - x += w + 12; - } - } else u.dashedFrame(r, theme.mark(.freed).solid, theme.stroke.line); - // Its address under it: the end that tells chunks apart. - u.text(.mono, theme.size.mono.small, r.x, y + strip_h + 30, u.print("{x:0>4}", .{a.ptr & 0xffff}), t.faint); - } - } -}; |
