summaryrefslogtreecommitdiff
path: root/tools/bench.zig
blob: 541286628e623ea590f05221d594a1111fc621a3 (plain) (blame)
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
//! How long a frame of vector graphics takes, per stage, in release mode:
//! parsing the SVG, turning it into polygons and coverage (CPU backend), or
//! into a GPU pass description (GPU backend; the GPU's own time is not
//! measured here). The objects: the compiled test scene's, and the manual
//! example's page of the Intel SDM (when the build has the PDF), thousands
//! of shapes, with a budget of its own.
const std = @import("std");
const vector = @import("vector");
const scene = @import("scene").scene;
const typst = @import("typst");
const manual = @import("manual").scene;
const manual_typst = @import("manual_typst");

const width = 1280;
const height = 720;
const runs = 300;
/// Drawings up to this many shapes count as simple: they must take < 1ms.
const simple_shapes = 30;
/// Drawings of more count as a page (Figure 2-1's page of the SDM is 1954
/// shapes; measured on a loaded 16-core machine: parse 6-12 ms, CPU draw
/// 2-5 ms, GPU record 0.85-1.7 ms). Parsing is once per object, drawing
/// every frame.
const page_shapes = 1000;
const page_parse_ms = 25;
const page_cpu_ms = 10;
const page_gpu_ms = 4;

/// Stand-in for `sketch.Host`: the renderers only need images (and to free
/// the GPU backend's paint buffer, which this bench never makes).
const Host = struct {
    pub fn newImage(_: Host, _: u32, _: u32) @import("abi").Image {
        return @fromBackingInt(@intCast(1));
    }
    pub fn freeImage(_: Host, _: @import("abi").Image) void {}
    pub fn freeBuffer(_: Host, _: @import("abi").Buffer) void {}
};

pub fn main(init: std.process.Init) !void {
    const gpa = std.heap.smp_allocator;
    const io = init.io;
    var failed = false;
    std.debug.print("{s:<24} {s:>7} {s:>10} {s:>10} {s:>10} {s:>10}\n", .{ "object", "shapes", "parse", "cpu draw", "gpu record", "cpu total" });
    // Every Typst object of the scene being played (a live scene adds them
    // all whatever the time).
    var objects_arena: std.heap.ArenaAllocator = .init(gpa);
    defer objects_arena.deinit();
    const shot = try scene.shot(objects_arena.allocator(), .{ .t = 0 });
    for (shot.objects, 0..) |object, index| if (object.source == .typst) {
        if (try bench(gpa, io, index, object.source.typst, typst.find(object.source.typst).?)) failed = true;
    };
    // The manual's page of the SDM, when the build has the PDF.
    for (manual.typst_sources, 0..) |source, index| if (std.mem.startsWith(u8, source, "#image(")) {
        if (try bench(gpa, io, index, source, manual_typst.find(source).?)) failed = true;
    };
    std.debug.print("\nup to {d} shapes must parse and draw in under 1ms at {d}x{d}, filling the canvas;\n", .{ simple_shapes, width, height });
    std.debug.print("a page (over {d}) parse in under {d}ms, draw on the CPU in {d}ms and record for the GPU in {d}ms.\n", .{ page_shapes, page_parse_ms, page_cpu_ms, page_gpu_ms });
    if (failed) return error.TooSlow;
}

/// Times one SVG, prints its line, and says whether it is over budget.
fn bench(gpa: std.mem.Allocator, io: std.Io, index: usize, source: []const u8, svg: []const u8) !bool {
    var arena: std.heap.ArenaAllocator = .init(gpa);
    defer arena.deinit();
    var cpu: vector.Renderer(.cpu) = try .init(gpa, Host{}, width, height);
    defer cpu.deinit(Host{});
    var gpu: vector.Renderer(.gpu) = try .init(gpa, Host{}, width, height);
    defer gpu.deinit(Host{});
    const Frame = struct { scratch: std.mem.Allocator };

    var parse_ns: [runs]u64 = undefined;
    var cpu_ns: [runs]u64 = undefined;
    var gpu_ns: [runs]u64 = undefined;
    var shapes: usize = 0;
    for (0..runs) |i| {
        _ = arena.reset(.retain_capacity);
        const t0 = now(io);
        const d = try vector.svg.parse(arena.allocator(), svg);
        const t1 = now(io);
        // Fit to the canvas, as large as it goes: the worst case.
        const m = vector.fit(d, .{ .w = width, .h = height });
        cpu.begin(Frame{ .scratch = arena.allocator() }, .{ 0, 0, 0, 1 });
        try cpu.draw(d, m, 1);
        const t2 = now(io);
        gpu.begin(Frame{ .scratch = arena.allocator() }, .{ 0, 0, 0, 1 });
        try gpu.draw(d, m, 1);
        std.mem.doNotOptimizeAway(gpu.target.pass());
        const t3 = now(io);
        parse_ns[i] = t1 - t0;
        cpu_ns[i] = t2 - t1;
        gpu_ns[i] = t3 - t2;
        shapes = d.shapes.len;
    }
    const p = median(&parse_ns);
    const c = median(&cpu_ns);
    const g = median(&gpu_ns);
    std.debug.print("{d:>2} {s:<21} {d:>7} {d:>8.3}ms {d:>8.3}ms {d:>8.3}ms {d:>8.3}ms\n", .{ index, label(source), shapes, ms(p), ms(c), ms(g), ms(p + c) });
    if (shapes <= simple_shapes) return p + c > std.time.ns_per_ms or p + g > std.time.ns_per_ms;
    if (shapes > page_shapes) return p > page_parse_ms * std.time.ns_per_ms or c > page_cpu_ms * std.time.ns_per_ms or g > page_gpu_ms * std.time.ns_per_ms;
    return false;
}

/// The start of a Typst source's first line.
fn label(source: []const u8) []const u8 {
    const line = source[0 .. std.mem.indexOfScalar(u8, source, '\n') orelse source.len];
    return line[0..@min(line.len, 21)];
}

fn now(io: std.Io) u64 {
    return @intCast(std.Io.Timestamp.now(io, .awake).nanoseconds);
}

fn median(samples: []u64) u64 {
    std.mem.sort(u64, samples, {}, std.sort.asc(u64));
    return samples[samples.len / 2];
}

fn ms(ns: u64) f64 {
    return @as(f64, @floatFromInt(ns)) / std.time.ns_per_ms;
}