//! What the debugger costs, measured: `zig build bench-debugger`. Steps, //! syscall stops and memory access, each from the bare ptrace calls up to a //! recording, so the differences say where the time goes. const std = @import("std"); const linux = std.os.linux; const zt = @import("ztrace"); const Debugger = zt.Debugger; const now = zt.event.now; var out: *std.Io.Writer = undefined; fn row(what: []const u8, n: u64, ns: u64, unit: []const u8) !void { const per = @as(f64, @floatFromInt(ns)) / @as(f64, @floatFromInt(@max(n, 1))); try out.print(" {s:<46} {d:>9} {s:<6} {d:>9.0}/s {d:>8.2} us each\n", .{ what, n, unit, 1e9 / per, per / 1e3 }); } /// A sink that only counts. const Count = struct { events: u64 = 0, bytes: u64 = 0, fn sink(c: *Count) zt.Sink { return .{ .ctx = c, .emitFn = emit }; } fn emit(ctx: *anyopaque, _: *const zt.Event, payload: []const u8) anyerror!void { const c: *Count = @ptrCast(@alignCast(ctx)); c.events += 1; c.bytes += payload.len; } }; const Mode = enum { stepi, step, cont }; /// Runs a target to its exit under the debugger, one way of stopping, and /// returns the stops and the time. fn drive(init: std.process.Init, argv: [:null]const ?[*:0]const u8, sink: ?zt.Sink, mode: Mode, stack: usize, syscalls: @FieldType(Debugger, "syscalls"), breakpoint: ?[]const u8) !struct { u64, u64 } { var d = try Debugger.spawn(init.gpa, init.io, argv[0].?, argv.ptr, init.minimal.environ.block.slice.ptr, sink); defer d.deinit(); d.stack_watch = stack; d.syscalls = syscalls; if (breakpoint) |where| _ = try d.breakAt(try d.resolve(where), null); var stops: u64 = 0; const start = now(); while (true) : (stops += 1) switch (try switch (mode) { .stepi => d.stepi(), .step => d.step(), .cont => d.cont(), }) { .exited, .killed => break, else => {}, }; return .{ stops, now() - start }; } /// The same into a recording: its moments, how fast, and what each costs on disk. fn recorded(init: std.process.Init, what: []const u8, argv: [:null]const ?[*:0]const u8, mode: Mode, syscalls: @FieldType(Debugger, "syscalls"), breakpoint: ?[]const u8) !void { const path = "bench.ztrace"; var rec = try zt.Recorder.create(init.gpa, init.io, path); rec.cut &= ~zt.Kind.line.bit(); _, const ns = try drive(init, argv, rec.sink(), mode, 128, syscalls, breakpoint); const start = now(); const moments = rec.moments; try rec.close(); const size = (try std.Io.Dir.cwd().statFile(init.io, path, .{})).size; try std.Io.Dir.cwd().deleteFile(init.io, path); try row(what, moments, ns + (now() - start), "moments"); try out.print(" {s:<46} {d:>9} bytes {d:>9} a moment\n", .{ "", size, size / @max(moments, 1) }); } pub fn main(init: std.process.Init) !void { const args = try init.minimal.args.toSlice(init.arena.allocator()); if (args.len != 4) return error.Usage; // fib, graph, dd // The numbers go to stderr, and stdout nowhere: it is the targets' too. var buf: [4096]u8 = undefined; var stderr = std.Io.File.stderr().writer(init.io, &buf); out = &stderr.interface; _ = linux.dup2(@intCast(linux.open("/dev/null", .{ .ACCMODE = .WRONLY }, 0)), 1); const envp = init.minimal.environ.block.slice.ptr; const fib = [_:null]?[*:0]const u8{ args[1].ptr, "12", null }; const graph = [_:null]?[*:0]const u8{ args[2].ptr, null }; try out.print("instruction steps ({s} 12)\n", .{std.fs.path.basename(args[1])}); { var p = try zt.ptrace.Process.spawn(fib[0].?, &fib, envp); defer p.close(); var n: u64 = 0; const start = now(); while (try p.stepi() == .trap) n += 1; try row("ptrace singlestep + wait", n, now() - start, "steps"); } { var p = try zt.ptrace.Process.spawn(fib[0].?, &fib, envp); defer p.close(); var n: u64 = 0; var sum: u64 = 0; const start = now(); while (try p.stepi() == .trap) : (n += 1) sum +%= (try p.regs()).rip; try row("... + registers", n, now() - start, "steps"); } { const n, const ns = try drive(init, &fib, null, .stepi, 0, .ignore, null); try row("Debugger.stepi, no sink", n, ns, "steps"); } var count: Count = .{}; { const n, const ns = try drive(init, &fib, count.sink(), .stepi, 0, .ignore, null); try row("... + events (the source line looked up)", n, ns, "steps"); } { const n, const ns = try drive(init, &fib, count.sink(), .stepi, 0, .record, null); try row("... + syscalls told from the registers", n, ns, "steps"); } { const n, const ns = try drive(init, &fib, count.sink(), .stepi, 128, .record, null); try row("... + 128 bytes of stack watched", n, ns, "steps"); } { const n, const ns = try drive(init, &fib, count.sink(), .stepi, 4096, .record, null); try row("... or 4096 bytes of stack watched", n, ns, "steps"); } try recorded(init, "recorded (`ztrace record`)", &fib, .stepi, .record, null); try out.print("\nsource-line steps ({s})\n", .{std.fs.path.basename(args[2])}); { const insns, _ = try drive(init, &graph, null, .stepi, 0, .ignore, null); const n, const ns = try drive(init, &graph, null, .step, 0, .ignore, null); try row("Debugger.step, no sink", n, ns, "lines"); try out.print(" {s:<46} {d:>9} instructions under them, {d:.2} us each\n", .{ "", insns, @as(f64, @floatFromInt(ns)) / @as(f64, @floatFromInt(insns)) / 1e3 }); } try recorded(init, "recorded (`ztrace record --by line`)", &graph, .step, .record, null); try out.print("\nbreakpoints ({s} 22: one at fib, 28657 calls)\n", .{std.fs.path.basename(args[1])}); const deep = [_:null]?[*:0]const u8{ args[1].ptr, "22", null }; { const n, const ns = try drive(init, &deep, null, .cont, 0, .ignore, "fib"); try row("Debugger.cont to a breakpoint, no sink", n, ns, "hits"); } try recorded(init, "recorded (`ztrace record --by break -b fib`)", &deep, .cont, .record, "fib"); const calls = 200_000; const dd = [_:null]?[*:0]const u8{ args[3].ptr, "if=/dev/zero", "of=/dev/null", "bs=1", std.fmt.comptimePrint("count={d}", .{calls / 2}), "status=none", null }; try out.print("\nsyscall stops ({s} bs=1 count={d}: a read and a write each)\n", .{ std.fs.path.basename(args[3]), calls / 2 }); const native = native: { const start = now(); const pid = linux.fork(); if (pid == 0) { _ = linux.execve(dd[0].?, &dd, envp); linux.exit_group(127); } var status: u32 = 0; _ = linux.waitpid(@intCast(pid), @ptrCast(&status), 0); break :native now() - start; }; try row("native", calls, native, "calls"); { var p = try zt.ptrace.Process.spawn(dd[0].?, &dd, envp); defer p.close(); const start = now(); while (try p.syscall() == .syscall) {} try row("ptrace syscall + wait, entry and exit", calls, now() - start - native, "calls"); } { _, const ns = try drive(init, &dd, null, .cont, 0, .stop, null); try row("Debugger.cont stopping at both, no sink", calls, ns - native, "calls"); } { _, const ns = try drive(init, &dd, count.sink(), .cont, 0, .record, null); try row("... as events with the bytes written", calls, ns - native, "calls"); } try recorded(init, "recorded (`ztrace record --by syscall`)", &dd, .cont, .stop, null); try out.print("\nmemory (1 MiB of {s}'s code; 64 bytes of its stack)\n", .{std.fs.path.basename(args[2])}); { var d = try Debugger.spawn(init.gpa, init.io, graph[0].?, &graph, envp, null); defer d.deinit(); const p = &d.proc; const code = d.symbol("graph.main").?.addr & ~@as(u64, 0xfffff); const block = try init.gpa.alloc(u8, 1 << 20); defer init.gpa.free(block); const rounds = 200; var start = now(); for (0..rounds) |_| if (p.read(code + 0x1000, block) != block.len) return error.ShortRead; var ns = now() - start; try out.print(" {s:<46} {d:>9.0} MiB/s\n", .{ "process_vm_readv, one call", @as(f64, rounds) * 1e9 / @as(f64, @floatFromInt(ns)) }); start = now(); var at: usize = 0; while (at < block.len) : (at += 8) { const word = linux.ptrace(linux.PTRACE.PEEKDATA, p.pid, code + 0x1000 + at, @intFromPtr(block[at..].ptr), 0); if (linux.errno(word) != .SUCCESS) return error.Peek; } ns = now() - start; try out.print(" {s:<46} {d:>9.0} MiB/s\n", .{ "PTRACE_PEEKDATA, a word a call", 1e9 / @as(f64, @floatFromInt(ns)) }); var small: [64]u8 = undefined; const n = 200_000; start = now(); for (0..n) |_| _ = p.read(d.regs.rsp, &small); try row("64 bytes: process_vm_readv", n, now() - start, "reads"); start = now(); for (0..n) |_| { for (0..8) |i| _ = linux.ptrace(linux.PTRACE.PEEKDATA, p.pid, d.regs.rsp + i * 8, @intFromPtr(&small[i * 8]), 0); } try row("64 bytes: PTRACE_PEEKDATA x 8", n, now() - start, "reads"); start = now(); for (0..n) |_| try p.write(d.regs.rsp - 256, &small); try row("64 bytes: process_vm_writev", n, now() - start, "writes"); // Code is read-only: the same call goes through /proc/pid/mem. _ = p.read(code + 0x1000, &small); start = now(); for (0..n) |_| try p.write(code + 0x1000, &small); try row("64 bytes of code: writev fails, /proc/pid/mem", n, now() - start, "writes"); start = now(); for (0..n) |_| { for (0..8) |i| _ = linux.ptrace(linux.PTRACE.POKEDATA, p.pid, code + 0x1000 + i * 8, std.mem.readInt(u64, small[i * 8 ..][0..8], .little), 0); } try row("64 bytes of code: PTRACE_POKEDATA x 8", n, now() - start, "writes"); } try out.flush(); }