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
|
// Benchmarking script. This runs on compiled bench.wat and prints out timings.
//
// Usage:
//
// * wasm-opt scripts/benchmarking/bench.wat -all --inline-functions-with-loops --always-inline-max-function-size=1000 --inlining --precompute-propagate --optimize-instructions --inlining --simplify-locals --coalesce-locals --vacuum --remove-unused-module-elements -o bench.wasm -g
// * Inspect the optimized wasm to see that inlining etc. worked properly
// (we rely on inlining to let us write bench.wat in a short/simple form, and
// we use very specific optimizations in order to not optimize away the
// differences we care about).
// * d8 bench.js -- bench.wasm
// etc.
//
// Shell integration.
if (typeof console === 'undefined') {
console = { log: print };
}
var tempRet0;
var binary;
if (typeof process === 'object' && typeof require === 'function' /* node.js detection */) {
var args = process.argv.slice(2);
binary = require('fs').readFileSync(args[0]);
if (!binary.buffer) binary = new Uint8Array(binary);
} else {
var args;
if (typeof scriptArgs != 'undefined') {
args = scriptArgs;
} else if (typeof arguments != 'undefined') {
args = arguments;
}
if (typeof readbuffer === 'function') {
binary = new Uint8Array(readbuffer(args[0]));
} else {
binary = read(args[0], 'binary');
}
}
// Create the wasm.
const module = new WebAssembly.Module(binary);
const instance = new WebAssembly.Instance(module, {});
const exports = instance.exports;
// Create the benchmarkers.
function makeBenchmarker(name) {
return {
name: name,
func: exports[name],
time: 0,
sum: 0,
iters: 0,
};
}
const benchmarkers = [
makeBenchmarker('len'),
makeBenchmarker('and'),
makeBenchmarker('iff-both'),
makeBenchmarker('or'),
makeBenchmarker('iff-either'),
makeBenchmarker('select'),
makeBenchmarker('iff-nextor'),
makeBenchmarker('select-three'),
makeBenchmarker('iff-three'),
];
// We'll call the benchmark functions in random orders. Random orders avoid any
// interaction between the benchmarks from causing bias in the results.
//
// An alternative to randomly ordering the benchmarks in each iteration would be
// to fully benchmark one, then do the next, so there are large amounts of time
// between them, but that also allows them to become more like microbenchmarks
// where the branch predictor etc. might display very favorable behavior.
// Interleaving them makes things slightly more realistic.
//
// If we have too many benchmarks then eventually computing all orders ahead of
// time will not work, but so long as we can, it is faster this way rather than
// to compute random orders on the fly as we go.
function makeOrders(prefix) {
// Given a prefix of an order, like [] or [0, 3], return all the possible
// orders beginning with that prefix.
// We cannot repeat anything already seen.
const seen = new Set();
for (var x of prefix) {
seen.add(x);
}
// Starting from the prefix, extend it by one item in all valid ways.
const extensions = [];
for (var i = 0; i < benchmarkers.length; i++) {
if (!seen.has(i)) {
extensions.push(prefix.concat(i));
}
}
if (prefix.length == benchmarkers.length - 1) {
// The extensions are complete orders; stop the recursion.
return extensions;
}
// Recursively generate the full orders.
const ret = [];
for (var extension of extensions) {
for (var order of makeOrders(extension)) {
ret.push(order);
}
}
return ret;
}
const orders = makeOrders([]);
// Params.
const M = 10000000;
const N = 100;
console.log('iters :', M);
console.log('list len :', N);
console.log('benchmarkers:', benchmarkers.length);
console.log('orderings :', orders.length);
// Create a long linked list of objects of both type $A and $B.
var list = null;
for (var i = 0; i < N; i++) {
list = Math.random() < 0.5 ? exports.makeA(list) : exports.makeB(list);
}
console.log('benchmarking...');
// Call the benchmark functions.
for (var i = 0; i < M; i++) {
const order = orders[Math.floor(Math.random() * orders.length)];
for (var k = 0; k < benchmarkers.length; k++) {
const benchmarker = benchmarkers[order[k]];
const start = performance.now();
const result = benchmarker.func(list);
benchmarker.time += performance.now() - start;
benchmarker.sum += result;
benchmarker.iters++;
}
}
for (var benchmarker of benchmarkers) {
if (benchmarker.iters != M) {
throw 'wat';
}
}
console.log();
for (var benchmarker of benchmarkers) {
console.log(`${benchmarker.name} time: \t${benchmarker.time}`)
}
console.log();
for (var benchmarker of benchmarkers) {
console.log(`${benchmarker.name} mean sum: \t${benchmarker.sum / M}`)
}
|
