87b9f0b87b
In some newer Linux distributions, env python default to Python 3.0. This patch explicitly uses "python2" instead of just "python" for all scripts that use #! Reported-by: Sanchayan Maity <maitysanchayan@gmail.com> Signed-off-by: Jason Lowe-Power <jason@lowepower.com>
487 lines
14 KiB
Python
Executable file
487 lines
14 KiB
Python
Executable file
#!/usr/bin/env python2
|
|
|
|
# Copyright (c) 2003-2004 The Regents of The University of Michigan
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met: redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer;
|
|
# redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution;
|
|
# neither the name of the copyright holders nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
# Authors: Nathan Binkert
|
|
|
|
import re, sys, math
|
|
|
|
def usage():
|
|
print '''\
|
|
Usage: %s [-E] [-F] [ -G <get> ] [-d <db> ] [-g <graphdir> ] [-h <host>] [-p]
|
|
[-s <system>] [-r <runs> ] [-T <samples>] [-u <username>]
|
|
<command> [command args]
|
|
|
|
commands extra parameters description
|
|
----------- ------------------ ---------------------------------------
|
|
formula <formula> Evaluated formula specified
|
|
formulas [regex] List formulas (only matching regex)
|
|
runs none List all runs in database
|
|
samples none List samples present in database
|
|
stability <pairnum> <stats> Calculated statistical info about stats
|
|
stat <regex> Show stat data (only matching regex)
|
|
stats [regex] List all stats (only matching regex)
|
|
|
|
database <command> Where command is drop, init, or clean
|
|
|
|
''' % sys.argv[0]
|
|
sys.exit(1)
|
|
|
|
def getopts(list, flags):
|
|
import getopt
|
|
try:
|
|
opts, args = getopt.getopt(list, flags)
|
|
except getopt.GetoptError:
|
|
usage()
|
|
|
|
return opts, args
|
|
|
|
class CommandException(Exception):
|
|
pass
|
|
|
|
def commands(options, command, args):
|
|
if command == 'database':
|
|
if len(args) == 0: raise CommandException
|
|
|
|
import dbinit
|
|
mydb = dbinit.MyDB(options)
|
|
|
|
if args[0] == 'drop':
|
|
if len(args) > 2: raise CommandException
|
|
mydb.admin()
|
|
mydb.drop()
|
|
if len(args) == 2 and args[1] == 'init':
|
|
mydb.create()
|
|
mydb.connect()
|
|
mydb.populate()
|
|
mydb.close()
|
|
return
|
|
|
|
if args[0] == 'init':
|
|
if len(args) > 1: raise CommandException
|
|
mydb.admin()
|
|
mydb.create()
|
|
mydb.connect()
|
|
mydb.populate()
|
|
mydb.close()
|
|
return
|
|
|
|
if args[0] == 'clean':
|
|
if len(args) > 1: raise CommandException
|
|
mydb.connect()
|
|
mydb.clean()
|
|
return
|
|
|
|
raise CommandException
|
|
|
|
import db
|
|
source = db.Database()
|
|
source.host = options.host
|
|
source.db = options.db
|
|
source.passwd = options.passwd
|
|
source.user = options.user
|
|
source.connect()
|
|
#source.update_dict(globals())
|
|
|
|
if type(options.method) is str:
|
|
source.method = options.method
|
|
|
|
if options.runs is None:
|
|
runs = source.allRuns
|
|
else:
|
|
rx = re.compile(options.runs)
|
|
runs = []
|
|
for run in source.allRuns:
|
|
if rx.match(run.name):
|
|
runs.append(run)
|
|
|
|
if command == 'runs':
|
|
user = None
|
|
opts, args = getopts(args, '-u')
|
|
if len(args):
|
|
raise CommandException
|
|
for o,a in opts:
|
|
if o == '-u':
|
|
user = a
|
|
source.listRuns(user)
|
|
return
|
|
|
|
if command == 'stats':
|
|
if len(args) == 0:
|
|
source.listStats()
|
|
elif len(args) == 1:
|
|
source.listStats(args[0])
|
|
else:
|
|
raise CommandException
|
|
|
|
return
|
|
|
|
if command == 'formulas':
|
|
if len(args) == 0:
|
|
source.listFormulas()
|
|
elif len(args) == 1:
|
|
source.listFormulas(args[0])
|
|
else:
|
|
raise CommandException
|
|
|
|
return
|
|
|
|
if command == 'samples':
|
|
if len(args):
|
|
raise CommandException
|
|
|
|
source.listTicks(runs)
|
|
return
|
|
|
|
if command == 'stability':
|
|
if len(args) < 2:
|
|
raise CommandException
|
|
|
|
try:
|
|
merge = int(args[0])
|
|
except ValueError:
|
|
usage()
|
|
stats = source.getStat(args[1])
|
|
source.method = 'sum'
|
|
|
|
def disp(*args):
|
|
print "%-35s %12s %12s %4s %5s %5s %5s %10s" % args
|
|
|
|
# temporary variable containing a bunch of dashes
|
|
d = '-' * 100
|
|
|
|
#loop through all the stats selected
|
|
for stat in stats:
|
|
print "%s:" % stat.name
|
|
disp("run name", "average", "stdev", ">10%", ">1SDV", ">2SDV",
|
|
"SAMP", "CV")
|
|
disp(d[:35], d[:12], d[:12], d[:4], d[:5], d[:5], d[:5], d[:10])
|
|
|
|
#loop through all the selected runs
|
|
for run in runs:
|
|
runTicks = source.retTicks([ run ])
|
|
#throw away the first one, it's 0
|
|
runTicks.pop(0)
|
|
source.ticks = runTicks
|
|
avg = 0
|
|
stdev = 0
|
|
numoutsideavg = 0
|
|
numoutside1std = 0
|
|
numoutside2std = 0
|
|
pairRunTicks = []
|
|
if value(stat, run.run) == 1e300*1e300:
|
|
continue
|
|
for t in range(0, len(runTicks)-(merge-1), merge):
|
|
tempPair = []
|
|
for p in range(0,merge):
|
|
tempPair.append(runTicks[t+p])
|
|
pairRunTicks.append(tempPair)
|
|
#loop through all the various ticks for each run
|
|
for tick in pairRunTicks:
|
|
source.ticks = tick
|
|
avg += value(stat, run.run)
|
|
avg /= len(pairRunTicks)
|
|
for tick in pairRunTicks:
|
|
source.ticks = tick
|
|
val = value(stat, run.run)
|
|
stdev += pow((val-avg),2)
|
|
stdev = math.sqrt(stdev / len(pairRunTicks))
|
|
for tick in pairRunTicks:
|
|
source.ticks = tick
|
|
val = value(stat, run.run)
|
|
if (val < (avg * .9)) or (val > (avg * 1.1)):
|
|
numoutsideavg += 1
|
|
if (val < (avg - stdev)) or (val > (avg + stdev)):
|
|
numoutside1std += 1
|
|
if (val < (avg - (2*stdev))) or (val > (avg + (2*stdev))):
|
|
numoutside2std += 1
|
|
if avg > 1000:
|
|
disp(run.name, "%.1f" % avg, "%.1f" % stdev,
|
|
"%d" % numoutsideavg, "%d" % numoutside1std,
|
|
"%d" % numoutside2std, "%d" % len(pairRunTicks),
|
|
"%.3f" % (stdev/avg*100))
|
|
elif avg > 100:
|
|
disp(run.name, "%.1f" % avg, "%.1f" % stdev,
|
|
"%d" % numoutsideavg, "%d" % numoutside1std,
|
|
"%d" % numoutside2std, "%d" % len(pairRunTicks),
|
|
"%.5f" % (stdev/avg*100))
|
|
else:
|
|
disp(run.name, "%.5f" % avg, "%.5f" % stdev,
|
|
"%d" % numoutsideavg, "%d" % numoutside1std,
|
|
"%d" % numoutside2std, "%d" % len(pairRunTicks),
|
|
"%.7f" % (stdev/avg*100))
|
|
return
|
|
|
|
if command == 'all':
|
|
if len(args):
|
|
raise CommandException
|
|
|
|
all = [ 'bps', 'misses', 'mpkb', 'ipkb', 'pps', 'bpt' ]
|
|
for command in all:
|
|
commands(options, command, args)
|
|
|
|
if options.ticks:
|
|
if not options.graph:
|
|
print 'only displaying sample %s' % options.ticks
|
|
source.ticks = [ int(x) for x in options.ticks.split() ]
|
|
|
|
from output import StatOutput
|
|
output = StatOutput(options.jobfile, source)
|
|
output.xlabel = 'System Configuration'
|
|
output.colormap = 'RdYlGn'
|
|
|
|
if command == 'stat' or command == 'formula':
|
|
if len(args) != 1:
|
|
raise CommandException
|
|
|
|
if command == 'stat':
|
|
stats = source.getStat(args[0])
|
|
if command == 'formula':
|
|
stats = eval(args[0])
|
|
|
|
for stat in stats:
|
|
output.stat = stat
|
|
output.ylabel = stat.name
|
|
if options.graph:
|
|
output.graph(stat.name, options.graphdir)
|
|
else:
|
|
output.display(stat.name, options.printmode)
|
|
|
|
return
|
|
|
|
if len(args):
|
|
raise CommandException
|
|
|
|
from info import ProxyGroup
|
|
proxy = ProxyGroup(system = source[options.system])
|
|
system = proxy.system
|
|
|
|
etherdev = system.tsunami.etherdev0
|
|
bytes = etherdev.rxBytes + etherdev.txBytes
|
|
kbytes = bytes / 1024
|
|
packets = etherdev.rxPackets + etherdev.txPackets
|
|
|
|
def display():
|
|
if options.graph:
|
|
output.graph(command, options.graphdir, proxy)
|
|
else:
|
|
output.display(command, options.printmode)
|
|
|
|
if command == 'ticks':
|
|
output.stat = system.run0.numCycles
|
|
|
|
display()
|
|
return
|
|
|
|
if command == 'bytes':
|
|
output.stat = bytes
|
|
display()
|
|
return
|
|
|
|
if command == 'packets':
|
|
output.stat = packets
|
|
display()
|
|
return
|
|
|
|
if command == 'ppt' or command == 'tpp':
|
|
output.stat = packets / system.run0.numCycles
|
|
output.invert = command == 'tpp'
|
|
display()
|
|
return
|
|
|
|
if command == 'pps':
|
|
output.stat = packets / source['sim_seconds']
|
|
output.ylabel = 'Packets/s'
|
|
display()
|
|
return
|
|
|
|
if command == 'bpt' or command == 'tpb':
|
|
output.stat = bytes / system.run0.numCycles * 8
|
|
output.ylabel = 'bps / Hz'
|
|
output.invert = command == 'tpb'
|
|
display()
|
|
return
|
|
|
|
if command in ('rxbps', 'txbps', 'bps'):
|
|
if command == 'rxbps':
|
|
output.stat = etherdev.rxBandwidth / 1e9
|
|
if command == 'txbps':
|
|
output.stat = etherdev.txBandwidth / 1e9
|
|
if command == 'bps':
|
|
output.stat = (etherdev.rxBandwidth + etherdev.txBandwidth) / 1e9
|
|
|
|
output.ylabel = 'Bandwidth (Gbps)'
|
|
output.ylim = [ 0.0, 10.0 ]
|
|
display()
|
|
return
|
|
|
|
if command == 'bpp':
|
|
output.stat = bytes / packets
|
|
output.ylabel = 'Bytes / Packet'
|
|
display()
|
|
return
|
|
|
|
if command == 'rxbpp':
|
|
output.stat = etherdev.rxBytes / etherdev.rxPackets
|
|
output.ylabel = 'Receive Bytes / Packet'
|
|
display()
|
|
return
|
|
|
|
if command == 'txbpp':
|
|
output.stat = etherdev.txBytes / etherdev.txPackets
|
|
output.ylabel = 'Transmit Bytes / Packet'
|
|
display()
|
|
return
|
|
|
|
if command == 'rtp':
|
|
output.stat = etherdev.rxPackets / etherdev.txPackets
|
|
output.ylabel = 'rxPackets / txPackets'
|
|
display()
|
|
return
|
|
|
|
if command == 'rtb':
|
|
output.stat = etherdev.rxBytes / etherdev.txBytes
|
|
output.ylabel = 'rxBytes / txBytes'
|
|
display()
|
|
return
|
|
|
|
misses = system.l2.overall_mshr_misses
|
|
|
|
if command == 'misses':
|
|
output.stat = misses
|
|
output.ylabel = 'Overall MSHR Misses'
|
|
display()
|
|
return
|
|
|
|
if command == 'mpkb':
|
|
output.stat = misses / (bytes / 1024)
|
|
output.ylabel = 'Misses / KB'
|
|
display()
|
|
return
|
|
|
|
if command == 'ipkb':
|
|
interrupts = system.run0.kern.faults[4]
|
|
output.stat = interrupts / kbytes
|
|
output.ylabel = 'Interrupts / KB'
|
|
display()
|
|
return
|
|
|
|
if command == 'execute':
|
|
output.stat = system.run0.ISSUE__count
|
|
display()
|
|
return
|
|
|
|
if command == 'commit':
|
|
output.stat = system.run0.COM__count
|
|
display()
|
|
return
|
|
|
|
if command == 'fetch':
|
|
output.stat = system.run0.FETCH__count
|
|
display()
|
|
return
|
|
|
|
raise CommandException
|
|
|
|
|
|
class Options: pass
|
|
|
|
if __name__ == '__main__':
|
|
import getpass
|
|
|
|
options = Options()
|
|
options.host = None
|
|
options.db = None
|
|
options.passwd = ''
|
|
options.user = getpass.getuser()
|
|
options.runs = None
|
|
options.system = 'client'
|
|
options.method = None
|
|
options.graph = False
|
|
options.ticks = False
|
|
options.printmode = 'G'
|
|
jobfilename = None
|
|
options.jobfile = None
|
|
options.all = False
|
|
|
|
opts, args = getopts(sys.argv[1:], '-EFJad:g:h:j:m:pr:s:u:T:')
|
|
for o,a in opts:
|
|
if o == '-E':
|
|
options.printmode = 'E'
|
|
if o == '-F':
|
|
options.printmode = 'F'
|
|
if o == '-a':
|
|
options.all = True
|
|
if o == '-d':
|
|
options.db = a
|
|
if o == '-g':
|
|
options.graph = True;
|
|
options.graphdir = a
|
|
if o == '-h':
|
|
options.host = a
|
|
if o == '-J':
|
|
jobfilename = None
|
|
if o == '-j':
|
|
jobfilename = a
|
|
if o == '-m':
|
|
options.method = a
|
|
if o == '-p':
|
|
options.passwd = getpass.getpass()
|
|
if o == '-r':
|
|
options.runs = a
|
|
if o == '-u':
|
|
options.user = a
|
|
if o == '-s':
|
|
options.system = a
|
|
if o == '-T':
|
|
options.ticks = a
|
|
|
|
if jobfilename:
|
|
from jobfile import JobFile
|
|
options.jobfile = JobFile(jobfilename)
|
|
if not options.host:
|
|
options.host = options.jobfile.dbhost
|
|
if not options.db:
|
|
options.db = options.jobfile.statdb
|
|
|
|
if not options.host:
|
|
sys.exit('Database server must be provided from a jobfile or -h')
|
|
|
|
if not options.db:
|
|
sys.exit('Database name must be provided from a jobfile or -d')
|
|
|
|
if len(args) == 0:
|
|
usage()
|
|
|
|
command = args[0]
|
|
args = args[1:]
|
|
|
|
try:
|
|
commands(options, command, args)
|
|
except CommandException:
|
|
usage()
|