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
|
//! 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).
const std = @import("std");
const vector = @import("vector");
const scene = @import("scene").scene;
const typst = @import("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;
/// 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) {
const svg = typst.find(object.source.typst).?;
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(object.source.typst), shapes, ms(p), ms(c), ms(g), ms(p + c) });
if (shapes <= simple_shapes and (p + c > std.time.ns_per_ms or p + g > std.time.ns_per_ms)) 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 });
if (failed) return error.TooSlow;
}
/// 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;
}
|