1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
//! 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();
}
|