blob: 47490b9a98289f22a14018a1e54884cf5a90f4cf [file] [log] [blame]
#!/usr/bin/env python
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#
# ==------------------------------------------------------------------------==#
import os
import glob
import re
import subprocess
import json
import datetime
import argparse
try:
from urllib.parse import urlencode
from urllib.request import urlopen, Request
except ImportError:
from urllib import urlencode
from urllib2 import urlopen, Request
parser = argparse.ArgumentParser()
parser.add_argument('benchmark_directory')
parser.add_argument('--runs', type=int, default=10)
parser.add_argument('--wrapper', default='')
parser.add_argument('--machine', required=True)
parser.add_argument('--revision', required=True)
parser.add_argument('--threads', action='store_true')
parser.add_argument('--url', help='The lnt server url to send the results to',
default='http://localhost:8000/db_default/v4/link/submitRun')
args = parser.parse_args()
class Bench:
def __init__(self, directory, variant):
self.directory = directory
self.variant = variant
def __str__(self):
if not self.variant:
return self.directory
return '%s-%s' % (self.directory, self.variant)
def getBenchmarks():
ret = []
for i in glob.glob('*/response*.txt'):
m = re.match('response-(.*)\.txt', os.path.basename(i))
variant = m.groups()[0] if m else None
ret.append(Bench(os.path.dirname(i), variant))
return ret
def parsePerfNum(num):
num = num.replace(b',',b'')
try:
return int(num)
except ValueError:
return float(num)
def parsePerfLine(line):
ret = {}
line = line.split(b'#')[0].strip()
if len(line) != 0:
p = line.split()
ret[p[1].strip().decode('ascii')] = parsePerfNum(p[0])
return ret
def parsePerf(output):
ret = {}
lines = [x.strip() for x in output.split(b'\n')]
seconds = [x for x in lines if b'seconds time elapsed' in x][0]
seconds = seconds.strip().split()[0].strip()
ret['seconds-elapsed'] = parsePerfNum(seconds)
measurement_lines = [x for x in lines if b'#' in x]
for l in measurement_lines:
ret.update(parsePerfLine(l))
return ret
def run(cmd):
try:
return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
print(e.output)
raise e
def combinePerfRun(acc, d):
for k,v in d.items():
a = acc.get(k, [])
a.append(v)
acc[k] = a
def perf(cmd):
# Discard the first run to warm up any system cache.
run(cmd)
ret = {}
wrapper_args = [x for x in args.wrapper.split(',') if x]
for i in range(args.runs):
os.unlink('t')
out = run(wrapper_args + ['perf', 'stat'] + cmd)
r = parsePerf(out)
combinePerfRun(ret, r)
os.unlink('t')
return ret
def runBench(bench):
thread_arg = [] if args.threads else ['--no-threads']
os.chdir(bench.directory)
suffix = '-%s' % bench.variant if bench.variant else ''
response = 'response' + suffix + '.txt'
ret = perf(['../ld.lld', '@' + response, '-o', 't'] + thread_arg)
ret['name'] = str(bench)
os.chdir('..')
return ret
def buildLntJson(benchmarks):
start = datetime.datetime.utcnow().isoformat()
tests = [runBench(b) for b in benchmarks]
end = datetime.datetime.utcnow().isoformat()
ret = {
'format_version' : 2,
'machine' : { 'name' : args.machine },
'run' : {
'end_time' : start,
'start_time' : end,
'llvm_project_revision': args.revision
},
'tests' : tests
}
return json.dumps(ret, sort_keys=True, indent=4)
def submitToServer(data):
data2 = urlencode({ 'input_data' : data }).encode('ascii')
urlopen(Request(args.url, data2))
os.chdir(args.benchmark_directory)
data = buildLntJson(getBenchmarks())
submitToServer(data)