2021-01-18 15:20:06 +03:00
|
|
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
2019-11-07 20:38:27 +03:00
|
|
|
// Use of this source code is governed by an MIT license
|
|
|
|
// that can be found in the LICENSE file.
|
2020-04-26 09:32:05 +03:00
|
|
|
import os
|
|
|
|
import time
|
2019-11-07 20:38:27 +03:00
|
|
|
|
2021-05-22 07:20:48 +03:00
|
|
|
// TODO -usecache
|
|
|
|
const voptions = ' -skip-unused -show-timings -stats '
|
2021-05-09 15:14:06 +03:00
|
|
|
|
2019-11-07 20:38:27 +03:00
|
|
|
fn main() {
|
|
|
|
exe := os.executable()
|
2020-03-08 00:26:26 +03:00
|
|
|
dir := os.dir(exe)
|
|
|
|
vdir := os.dir(os.dir(os.dir(dir)))
|
2019-12-04 23:03:12 +03:00
|
|
|
if !os.exists('$vdir/v') && !os.is_dir('$vdir/vlib') {
|
2020-02-09 12:08:04 +03:00
|
|
|
println('fast.html generator needs to be located in `v/cmd/tools/fast`')
|
2019-12-16 22:22:04 +03:00
|
|
|
}
|
2019-11-07 20:38:27 +03:00
|
|
|
println('fast.html generator\n')
|
2019-11-08 00:07:53 +03:00
|
|
|
println('Fetching updates...')
|
2020-08-27 19:07:28 +03:00
|
|
|
ret := os.system('$vdir/v up')
|
2019-12-16 22:22:04 +03:00
|
|
|
if ret != 0 {
|
2020-08-27 19:07:28 +03:00
|
|
|
println('failed to update V')
|
2019-12-16 22:22:04 +03:00
|
|
|
return
|
|
|
|
}
|
2021-02-07 07:23:45 +03:00
|
|
|
// Fetch the last commit's hash
|
2021-02-07 07:11:48 +03:00
|
|
|
commit := exec('git rev-parse HEAD')[..8]
|
2019-12-04 23:03:12 +03:00
|
|
|
if !os.exists('table.html') {
|
2020-10-21 15:24:45 +03:00
|
|
|
os.create('table.html') ?
|
2019-12-16 22:22:04 +03:00
|
|
|
}
|
2020-10-21 15:24:45 +03:00
|
|
|
mut table := os.read_file('table.html') ?
|
2021-02-07 07:11:48 +03:00
|
|
|
if table.contains('>$commit<') {
|
2021-02-07 00:28:42 +03:00
|
|
|
println('nothing to benchmark')
|
|
|
|
exit(1)
|
|
|
|
return
|
|
|
|
}
|
2021-02-07 07:11:48 +03:00
|
|
|
// for i, commit in commits {
|
|
|
|
message := exec('git log --pretty=format:"%s" -n1 $commit')
|
|
|
|
// println('\n${i + 1}/$commits.len Benchmarking commit $commit "$message"')
|
|
|
|
println('\nBenchmarking commit $commit "$message"')
|
|
|
|
// Build an optimized V
|
|
|
|
// println('Checking out ${commit}...')
|
|
|
|
// exec('git checkout $commit')
|
|
|
|
println(' Building vprod...')
|
2021-05-05 22:02:26 +03:00
|
|
|
exec('v -o $vdir/vprod -prod -prealloc $vdir/cmd/v')
|
2021-04-30 15:31:20 +03:00
|
|
|
// exec('v -o $vdir/vprod $vdir/cmd/v') // for faster debugging
|
2021-05-15 05:52:06 +03:00
|
|
|
exec('v -o v2 -prod -usecache $vdir/cmd/v') // cache vlib modules
|
2021-05-09 15:14:06 +03:00
|
|
|
diff1 := measure('$vdir/vprod $voptions -o v.c $vdir/cmd/v', 'v.c')
|
2021-03-14 21:34:51 +03:00
|
|
|
mut tcc_path := 'tcc'
|
|
|
|
$if freebsd {
|
|
|
|
tcc_path = '/usr/local/bin/tcc'
|
|
|
|
}
|
2021-05-09 15:14:06 +03:00
|
|
|
diff2 := measure('$vdir/vprod $voptions -cc $tcc_path -o v2 $vdir/cmd/v', 'v2')
|
2021-04-26 16:39:38 +03:00
|
|
|
diff3 := 0 // measure('$vdir/vprod -native $vdir/cmd/tools/1mil.v', 'native 1mil')
|
2021-05-09 15:14:06 +03:00
|
|
|
diff4 := measure('$vdir/vprod $voptions -cc clang $vdir/examples/hello_world.v', 'hello.v')
|
2021-02-07 07:11:48 +03:00
|
|
|
vc_size := os.file_size('v.c') / 1000
|
2021-04-02 20:53:01 +03:00
|
|
|
// scan/parse/check/cgen
|
2021-04-30 15:31:20 +03:00
|
|
|
scan, parse, check, cgen, vlines := measure_steps(vdir)
|
2021-02-07 07:11:48 +03:00
|
|
|
// println('Building V took ${diff}ms')
|
|
|
|
commit_date := exec('git log -n1 --pretty="format:%at" $commit')
|
|
|
|
date := time.unix(commit_date.int())
|
|
|
|
mut out := os.create('table.html') ?
|
|
|
|
// Place the new row on top
|
2021-04-15 13:58:08 +03:00
|
|
|
html_message := message.replace_each(['<', '<', '>', '>'])
|
2021-04-03 19:30:25 +03:00
|
|
|
table =
|
2021-02-07 07:11:48 +03:00
|
|
|
'<tr>
|
2020-10-21 15:24:45 +03:00
|
|
|
<td>$date.format()</td>
|
2020-07-10 18:03:39 +03:00
|
|
|
<td><a target=_blank href="https://github.com/vlang/v/commit/$commit">$commit</a></td>
|
2021-04-15 13:58:08 +03:00
|
|
|
<td>$html_message</td>
|
2020-07-10 17:51:16 +03:00
|
|
|
<td>${diff1}ms</td>
|
|
|
|
<td>${diff2}ms</td>
|
|
|
|
<td>${diff3}ms</td>
|
|
|
|
<td>${diff4}ms</td>
|
2021-02-07 06:48:54 +03:00
|
|
|
<td>$vc_size KB</td>
|
|
|
|
<td>${parse}ms</td>
|
|
|
|
<td>${check}ms</td>
|
|
|
|
<td>${cgen}ms</td>
|
2021-04-02 20:53:01 +03:00
|
|
|
<td>${scan}ms</td>
|
2021-04-30 15:31:20 +03:00
|
|
|
<td>$vlines</td>
|
|
|
|
<td>${int(f64(vlines) / f64(diff1) * 1000.0)} lines/s</td>
|
2020-07-10 17:51:16 +03:00
|
|
|
</tr>\n' +
|
2021-02-07 07:11:48 +03:00
|
|
|
table.trim_space()
|
|
|
|
out.writeln(table) ?
|
|
|
|
out.close()
|
|
|
|
// Regenerate index.html
|
|
|
|
header := os.read_file('header.html') ?
|
|
|
|
footer := os.read_file('footer.html') ?
|
|
|
|
mut res := os.create('index.html') ?
|
|
|
|
res.writeln(header) ?
|
|
|
|
res.writeln(table) ?
|
|
|
|
res.writeln(footer) ?
|
|
|
|
res.close()
|
|
|
|
//}
|
|
|
|
// exec('git checkout master')
|
|
|
|
// os.write_file('last_commit.txt', commits[commits.len - 1]) ?
|
2019-11-20 17:59:37 +03:00
|
|
|
}
|
2019-11-07 20:38:27 +03:00
|
|
|
|
|
|
|
fn exec(s string) string {
|
2021-03-08 21:52:13 +03:00
|
|
|
e := os.execute_or_panic(s)
|
2020-06-15 15:16:37 +03:00
|
|
|
return e.output.trim_right('\r\n')
|
2019-11-20 17:59:37 +03:00
|
|
|
}
|
2019-11-07 21:47:31 +03:00
|
|
|
|
|
|
|
// returns milliseconds
|
2020-10-21 15:24:45 +03:00
|
|
|
fn measure(cmd string, description string) int {
|
2020-07-10 17:51:16 +03:00
|
|
|
println(' Measuring $description')
|
|
|
|
println(' Warming up...')
|
2020-10-21 15:24:45 +03:00
|
|
|
for _ in 0 .. 3 {
|
2019-11-07 21:47:31 +03:00
|
|
|
exec(cmd)
|
2019-12-16 22:22:04 +03:00
|
|
|
}
|
2020-07-10 17:51:16 +03:00
|
|
|
println(' Building...')
|
2020-11-30 22:01:11 +03:00
|
|
|
mut runs := []int{}
|
|
|
|
for r in 0 .. 5 {
|
2021-01-26 17:43:10 +03:00
|
|
|
println(' Sample ${r + 1}/5')
|
2020-11-30 22:01:11 +03:00
|
|
|
sw := time.new_stopwatch({})
|
|
|
|
exec(cmd)
|
|
|
|
runs << int(sw.elapsed().milliseconds())
|
|
|
|
}
|
|
|
|
// discard lowest and highest time
|
|
|
|
runs.sort()
|
|
|
|
runs = runs[1..4]
|
|
|
|
mut sum := 0
|
|
|
|
for run in runs {
|
|
|
|
sum += run
|
|
|
|
}
|
|
|
|
return int(sum / 3)
|
2019-11-20 17:59:37 +03:00
|
|
|
}
|
2021-02-07 06:48:54 +03:00
|
|
|
|
2021-04-30 15:31:20 +03:00
|
|
|
fn measure_steps(vdir string) (int, int, int, int, int) {
|
2021-05-09 15:14:06 +03:00
|
|
|
resp := os.execute_or_panic('$vdir/vprod $voptions -o v.c $vdir/cmd/v')
|
2021-04-30 15:31:20 +03:00
|
|
|
|
|
|
|
mut scan, mut parse, mut check, mut cgen, mut vlines := 0, 0, 0, 0, 0
|
2021-02-07 06:48:54 +03:00
|
|
|
lines := resp.output.split_into_lines()
|
2021-04-02 20:23:32 +03:00
|
|
|
if lines.len == 3 {
|
|
|
|
parse = lines[0].before('.').int()
|
|
|
|
check = lines[1].before('.').int()
|
|
|
|
cgen = lines[2].before('.').int()
|
|
|
|
} else {
|
|
|
|
ms_lines := lines.map(it.split(' ms '))
|
|
|
|
for line in ms_lines {
|
|
|
|
if line.len == 2 {
|
2021-04-02 20:53:01 +03:00
|
|
|
if line[1] == 'SCAN' {
|
|
|
|
scan = line[0].int()
|
|
|
|
}
|
2021-04-02 20:23:32 +03:00
|
|
|
if line[1] == 'PARSE' {
|
|
|
|
parse = line[0].int()
|
|
|
|
}
|
|
|
|
if line[1] == 'CHECK' {
|
|
|
|
check = line[0].int()
|
|
|
|
}
|
|
|
|
if line[1] == 'C GEN' {
|
|
|
|
cgen = line[0].int()
|
|
|
|
}
|
2021-04-30 15:31:20 +03:00
|
|
|
} else {
|
|
|
|
// Fetch number of V lines
|
|
|
|
if line[0].contains('V') && line[0].contains('source') && line[0].contains('size') {
|
|
|
|
start := line[0].index(':') or { 0 }
|
|
|
|
end := line[0].index('lines,') or { 0 }
|
|
|
|
s := line[0][start + 1..end]
|
|
|
|
vlines = s.trim_space().int()
|
|
|
|
}
|
2021-04-02 20:23:32 +03:00
|
|
|
}
|
|
|
|
}
|
2021-02-07 06:48:54 +03:00
|
|
|
}
|
2021-04-30 15:31:20 +03:00
|
|
|
return scan, parse, check, cgen, vlines
|
2021-02-07 06:48:54 +03:00
|
|
|
}
|