|
# Copyright (c) 2006-2008 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 os |
|
import sys |
|
from os.path import basename, exists, join as joinpath, normpath |
|
from os.path import isdir, isfile, islink |
|
|
|
spec_dist = os.environ.get('M5_CPU2000', '/dist/m5/cpu2000') |
|
|
|
def copyfiles(srcdir, dstdir): |
|
from filecmp import cmp as filecmp |
|
from shutil import copyfile |
|
|
|
srcdir = normpath(srcdir) |
|
dstdir = normpath(dstdir) |
|
|
|
if not isdir(dstdir): |
|
os.mkdir(dstdir) |
|
|
|
for root, dirs, files in os.walk(srcdir): |
|
root = normpath(root) |
|
prefix = os.path.commonprefix([root, srcdir]) |
|
|
|
root = root[len(prefix):] |
|
if root.startswith('/'): |
|
root = root[1:] |
|
|
|
for entry in dirs: |
|
newdir = joinpath(dstdir, root, entry) |
|
if not isdir(newdir): |
|
os.mkdir(newdir) |
|
|
|
for entry in files: |
|
dest = normpath(joinpath(dstdir, root, entry)) |
|
src = normpath(joinpath(srcdir, root, entry)) |
|
if not isfile(dest) or not filecmp(src, dest): |
|
copyfile(src, dest) |
|
|
|
# some of the spec benchmarks expect to be run from one directory up. |
|
# just create some symlinks that solve the problem |
|
inlink = joinpath(dstdir, 'input') |
|
outlink = joinpath(dstdir, 'output') |
|
if not exists(inlink): |
|
os.symlink('.', inlink) |
|
if not exists(outlink): |
|
os.symlink('.', outlink) |
|
|
|
class Benchmark(object): |
|
def __init__(self, isa, os, input_set): |
|
if not hasattr(self.__class__, 'name'): |
|
self.name = self.__class__.__name__ |
|
|
|
if not hasattr(self.__class__, 'binary'): |
|
self.binary = self.name |
|
|
|
if not hasattr(self.__class__, 'args'): |
|
self.args = [] |
|
|
|
if not hasattr(self.__class__, 'output'): |
|
self.output = '%s.out' % self.name |
|
|
|
if not hasattr(self.__class__, 'simpoint'): |
|
self.simpoint = None |
|
|
|
try: |
|
func = getattr(self.__class__, input_set) |
|
except AttributeError: |
|
raise AttributeError, \ |
|
'The benchmark %s does not have the %s input set' % \ |
|
(self.name, input_set) |
|
|
|
executable = joinpath(spec_dist, 'binaries', isa, os, self.binary) |
|
if not isfile(executable): |
|
raise AttributeError, '%s not found' % executable |
|
self.executable = executable |
|
|
|
# root of tree for input & output data files |
|
data_dir = joinpath(spec_dist, 'data', self.name) |
|
# optional subtree with files shared across input sets |
|
all_dir = joinpath(data_dir, 'all') |
|
# dirs for input & output files for this input set |
|
inputs_dir = joinpath(data_dir, input_set, 'input') |
|
outputs_dir = joinpath(data_dir, input_set, 'output') |
|
# keep around which input set was specified |
|
self.input_set = input_set |
|
|
|
if not isdir(inputs_dir): |
|
raise AttributeError, '%s not found' % inputs_dir |
|
|
|
self.inputs_dir = [ inputs_dir ] |
|
if isdir(all_dir): |
|
self.inputs_dir += [ joinpath(all_dir, 'input') ] |
|
if isdir(outputs_dir): |
|
self.outputs_dir = outputs_dir |
|
|
|
if not hasattr(self.__class__, 'stdin'): |
|
self.stdin = joinpath(inputs_dir, '%s.in' % self.name) |
|
if not isfile(self.stdin): |
|
self.stdin = None |
|
|
|
if not hasattr(self.__class__, 'stdout'): |
|
self.stdout = joinpath(outputs_dir, '%s.out' % self.name) |
|
if not isfile(self.stdout): |
|
self.stdout = None |
|
|
|
func(self, isa, os) |
|
|
|
def makeLiveProcessArgs(self, **kwargs): |
|
# set up default args for LiveProcess object |
|
process_args = {} |
|
process_args['cmd'] = [ self.name ] + self.args |
|
process_args['executable'] = self.executable |
|
if self.stdin: |
|
process_args['input'] = self.stdin |
|
if self.stdout: |
|
process_args['output'] = self.stdout |
|
if self.simpoint: |
|
process_args['simpoint'] = self.simpoint |
|
# explicit keywords override defaults |
|
process_args.update(kwargs) |
|
|
|
return process_args |
|
|
|
def makeLiveProcess(self, **kwargs): |
|
process_args = self.makeLiveProcessArgs(**kwargs) |
|
|
|
# figure out working directory: use m5's outdir unless |
|
# overridden by LiveProcess's cwd param |
|
cwd = process_args.get('cwd') |
|
|
|
if not cwd: |
|
from m5 import options |
|
cwd = options.outdir |
|
process_args['cwd'] = cwd |
|
if not isdir(cwd): |
|
os.makedirs(cwd) |
|
# copy input files to working directory |
|
for d in self.inputs_dir: |
|
copyfiles(d, cwd) |
|
# generate LiveProcess object |
|
from m5.objects import LiveProcess |
|
return LiveProcess(**process_args) |
|
|
|
def __str__(self): |
|
return self.name |
|
|
|
class DefaultBenchmark(Benchmark): |
|
def ref(self, isa, os): pass |
|
def test(self, isa, os): pass |
|
def train(self, isa, os): pass |
|
|
|
class MinneDefaultBenchmark(DefaultBenchmark): |
|
def smred(self, isa, os): pass |
|
def mdred(self, isa, os): pass |
|
def lgred(self, isa, os): pass |
|
|
|
class ammp(MinneDefaultBenchmark): |
|
name = 'ammp' |
|
number = 188 |
|
lang = 'C' |
|
simpoint = 108*100E6 |
|
|
|
class applu(MinneDefaultBenchmark): |
|
name = 'applu' |
|
number = 173 |
|
lang = 'F77' |
|
simpoint = 2179*100E6 |
|
|
|
class apsi(MinneDefaultBenchmark): |
|
name = 'apsi' |
|
number = 301 |
|
lang = 'F77' |
|
simpoint = 3408*100E6 |
|
|
|
class art(DefaultBenchmark): |
|
name = 'art' |
|
number = 179 |
|
lang = 'C' |
|
|
|
def test(self, isa, os): |
|
self.args = [ '-scanfile', 'c756hel.in', |
|
'-trainfile1', 'a10.img', |
|
'-stride', '2', |
|
'-startx', '134', |
|
'-starty', '220', |
|
'-endx', '139', |
|
'-endy', '225', |
|
'-objects', '1' ] |
|
self.output = 'test.out' |
|
|
|
def train(self, isa, os): |
|
self.args = [ '-scanfile', 'c756hel.in', |
|
'-trainfile1', 'a10.img', |
|
'-stride', '2', |
|
'-startx', '134', |
|
'-starty', '220', |
|
'-endx', '184', |
|
'-endy', '240', |
|
'-objects', '3' ] |
|
self.output = 'train.out' |
|
|
|
def lgred(self, isa, os): |
|
self.args = ['-scanfile', 'c756hel.in', |
|
'-trainfile1', 'a10.img', |
|
'-stride', '5', |
|
'-startx', '134', |
|
'-starty', '220', |
|
'-endx', '184', |
|
'-endy', '240', |
|
'-objects', '1' ] |
|
self.output = 'lgred.out' |
|
|
|
|
|
class art110(art): |
|
def ref(self, isa, os): |
|
self.args = [ '-scanfile', 'c756hel.in', |
|
'-trainfile1', 'a10.img', |
|
'-trainfile2', 'hc.img', |
|
'-stride', '2', |
|
'-startx', '110', |
|
'-starty', '200', |
|
'-endx', '160', |
|
'-endy', '240', |
|
'-objects', '10' ] |
|
self.output = 'ref.1.out' |
|
self.simpoint = 340*100E6 |
|
|
|
class art470(art): |
|
def ref(self, isa, os): |
|
self.args = [ '-scanfile', 'c756hel.in', |
|
'-trainfile1', 'a10.img', |
|
'-trainfile2', 'hc.img', |
|
'-stride', '2', |
|
'-startx', '470', |
|
'-starty', '140', |
|
'-endx', '520', |
|
'-endy', '180', |
|
'-objects', '10' ] |
|
self.output = 'ref.2.out' |
|
self.simpoint = 365*100E6 |
|
|
|
class equake(DefaultBenchmark): |
|
name = 'equake' |
|
number = 183 |
|
lang = 'C' |
|
simpoint = 812*100E6 |
|
|
|
def lgred(self, isa, os): pass |
|
|
|
class facerec(MinneDefaultBenchmark): |
|
name = 'facerec' |
|
number = 187 |
|
lang = 'F' |
|
simpoint = 375*100E6 |
|
|
|
class fma3d(MinneDefaultBenchmark): |
|
name = 'fma3d' |
|
number = 191 |
|
lang = 'F' |
|
simpoint = 2541*100E6 |
|
|
|
class galgel(MinneDefaultBenchmark): |
|
name = 'galgel' |
|
number = 178 |
|
lang = 'F' |
|
simpoint = 2491*100E6 |
|
|
|
class lucas(MinneDefaultBenchmark): |
|
name = 'lucas' |
|
number = 189 |
|
lang = 'F' |
|
simpoint = 545*100E6 |
|
|
|
class mesa(Benchmark): |
|
name = 'mesa' |
|
number = 177 |
|
lang = 'C' |
|
stdin = None |
|
|
|
def __set_args(self, frames): |
|
self.args = [ '-frames', frames, '-meshfile', '%s.in' % self.name, |
|
'-ppmfile', '%s.ppm' % self.name ] |
|
|
|
def test(self, isa, os): |
|
self.__set_args('10') |
|
|
|
def train(self, isa, os): |
|
self.__set_args('500') |
|
|
|
def ref(self, isa, os): |
|
self.__set_args('1000') |
|
self.simpoint = 1135*100E6 |
|
|
|
def lgred(self, isa, os): |
|
self.__set_args('1') |
|
|
|
class mgrid(MinneDefaultBenchmark): |
|
name = 'mgrid' |
|
number = 172 |
|
lang = 'F77' |
|
simpoint = 3292*100E6 |
|
|
|
class sixtrack(DefaultBenchmark): |
|
name = 'sixtrack' |
|
number = 200 |
|
lang = 'F77' |
|
simpoint = 3043*100E6 |
|
|
|
def lgred(self, isa, os): pass |
|
|
|
class swim(MinneDefaultBenchmark): |
|
name = 'swim' |
|
number = 171 |
|
lang = 'F77' |
|
simpoint = 2079*100E6 |
|
|
|
class wupwise(DefaultBenchmark): |
|
name = 'wupwise' |
|
number = 168 |
|
lang = 'F77' |
|
simpoint = 3237*100E6 |
|
|
|
def lgred(self, isa, os): pass |
|
|
|
class bzip2(DefaultBenchmark): |
|
name = 'bzip2' |
|
number = 256 |
|
lang = 'C' |
|
|
|
def test(self, isa, os): |
|
self.args = [ 'input.random' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ 'input.compressed' ] |
|
|
|
class bzip2_source(bzip2): |
|
def ref(self, isa, os): |
|
self.simpoint = 977*100E6 |
|
self.args = [ 'input.source', '58' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ 'input.source', '1' ] |
|
|
|
class bzip2_graphic(bzip2): |
|
def ref(self, isa, os): |
|
self.simpoint = 718*100E6 |
|
self.args = [ 'input.graphic', '58' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ 'input.graphic', '1' ] |
|
|
|
class bzip2_program(bzip2): |
|
def ref(self, isa, os): |
|
self.simpoint = 458*100E6 |
|
self.args = [ 'input.program', '58' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ 'input.program', '1' ] |
|
|
|
class crafty(MinneDefaultBenchmark): |
|
name = 'crafty' |
|
number = 186 |
|
lang = 'C' |
|
simpoint = 774*100E6 |
|
|
|
class eon(MinneDefaultBenchmark): |
|
name = 'eon' |
|
number = 252 |
|
lang = 'CXX' |
|
stdin = None |
|
|
|
class eon_kajiya(eon): |
|
args = [ 'chair.control.kajiya', 'chair.camera', 'chair.surfaces', |
|
'chair.kajiya.ppm', 'ppm', 'pixels_out.kajiya'] |
|
output = 'kajiya_log.out' |
|
|
|
|
|
class eon_cook(eon): |
|
args = [ 'chair.control.cook', 'chair.camera', 'chair.surfaces', |
|
'chair.cook.ppm', 'ppm', 'pixels_out.cook' ] |
|
output = 'cook_log.out' |
|
|
|
class eon_rushmeier(eon): |
|
args = [ 'chair.control.rushmeier', 'chair.camera', 'chair.surfaces', |
|
'chair.rushmeier.ppm', 'ppm', 'pixels_out.rushmeier' ] |
|
output = 'rushmeier_log.out' |
|
simpoint = 403*100E6 |
|
|
|
class gap(DefaultBenchmark): |
|
name = 'gap' |
|
number = 254 |
|
lang = 'C' |
|
|
|
def __set_args(self, size): |
|
self.args = [ '-l', './', '-q', '-m', size ] |
|
|
|
def test(self, isa, os): |
|
self.__set_args('64M') |
|
|
|
def train(self, isa, os): |
|
self.__set_args('128M') |
|
|
|
def ref(self, isa, os): |
|
self.__set_args('192M') |
|
self.simpoint = 674*100E6 |
|
|
|
def lgred(self, isa, os): |
|
self.__set_args('64M') |
|
|
|
def mdred(self, isa, os): |
|
self.__set_args('64M') |
|
|
|
def smred(self, isa, os): |
|
self.__set_args('64M') |
|
|
|
class gcc(DefaultBenchmark): |
|
name = 'gcc' |
|
number = 176 |
|
lang = 'C' |
|
|
|
def test(self, isa, os): |
|
self.args = [ 'cccp.i', '-o', 'cccp.s' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ 'cp-decl.i', '-o', 'cp-decl.s' ] |
|
|
|
def smred(self, isa, os): |
|
self.args = [ 'c-iterate.i', '-o', 'c-iterate.s' ] |
|
|
|
def mdred(self, isa, os): |
|
self.args = [ 'rdlanal.i', '-o', 'rdlanal.s' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ 'cp-decl.i', '-o', 'cp-decl.s' ] |
|
|
|
class gcc_166(gcc): |
|
def ref(self, isa, os): |
|
self.simpoint = 389*100E6 |
|
self.args = [ '166.i', '-o', '166.s' ] |
|
|
|
class gcc_200(gcc): |
|
def ref(self, isa, os): |
|
self.simpoint = 736*100E6 |
|
self.args = [ '200.i', '-o', '200.s' ] |
|
|
|
class gcc_expr(gcc): |
|
def ref(self, isa, os): |
|
self.simpoint = 36*100E6 |
|
self.args = [ 'expr.i', '-o', 'expr.s' ] |
|
|
|
class gcc_integrate(gcc): |
|
def ref(self, isa, os): |
|
self.simpoint = 4*100E6 |
|
self.args = [ 'integrate.i', '-o', 'integrate.s' ] |
|
|
|
class gcc_scilab(gcc): |
|
def ref(self, isa, os): |
|
self.simpoint = 207*100E6 |
|
self.args = [ 'scilab.i', '-o', 'scilab.s' ] |
|
|
|
class gzip(DefaultBenchmark): |
|
name = 'gzip' |
|
number = 164 |
|
lang = 'C' |
|
|
|
def test(self, isa, os): |
|
self.args = [ 'input.compressed', '2' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ 'input.combined', '32' ] |
|
|
|
class gzip_source(gzip): |
|
def ref(self, isa, os): |
|
self.simpoint = 334*100E6 |
|
self.args = [ 'input.source', '1' ] |
|
def smred(self, isa, os): |
|
self.args = [ 'input.source', '1' ] |
|
def mdred(self, isa, os): |
|
self.args = [ 'input.source', '1' ] |
|
def lgred(self, isa, os): |
|
self.args = [ 'input.source', '1' ] |
|
|
|
class gzip_log(gzip): |
|
def ref(self, isa, os): |
|
self.simpoint = 265*100E6 |
|
self.args = [ 'input.log', '60' ] |
|
def smred(self, isa, os): |
|
self.args = [ 'input.log', '1' ] |
|
def mdred(self, isa, os): |
|
self.args = [ 'input.log', '1' ] |
|
def lgred(self, isa, os): |
|
self.args = [ 'input.log', '1' ] |
|
|
|
class gzip_graphic(gzip): |
|
def ref(self, isa, os): |
|
self.simpoint = 653*100E6 |
|
self.args = [ 'input.graphic', '60' ] |
|
def smred(self, isa, os): |
|
self.args = [ 'input.graphic', '1' ] |
|
def mdred(self, isa, os): |
|
self.args = [ 'input.graphic', '1' ] |
|
def lgred(self, isa, os): |
|
self.args = [ 'input.graphic', '1' ] |
|
|
|
class gzip_random(gzip): |
|
def ref(self, isa, os): |
|
self.simpoint = 623*100E6 |
|
self.args = [ 'input.random', '60' ] |
|
def smred(self, isa, os): |
|
self.args = [ 'input.random', '1' ] |
|
def mdred(self, isa, os): |
|
self.args = [ 'input.random', '1' ] |
|
def lgred(self, isa, os): |
|
self.args = [ 'input.random', '1' ] |
|
|
|
class gzip_program(gzip): |
|
def ref(self, isa, os): |
|
self.simpoint = 1189*100E6 |
|
self.args = [ 'input.program', '60' ] |
|
def smred(self, isa, os): |
|
self.args = [ 'input.program', '1' ] |
|
def mdred(self, isa, os): |
|
self.args = [ 'input.program', '1' ] |
|
def lgred(self, isa, os): |
|
self.args = [ 'input.program', '1' ] |
|
|
|
class mcf(MinneDefaultBenchmark): |
|
name = 'mcf' |
|
number = 181 |
|
lang = 'C' |
|
args = [ 'mcf.in' ] |
|
simpoint = 553*100E6 |
|
|
|
class parser(MinneDefaultBenchmark): |
|
name = 'parser' |
|
number = 197 |
|
lang = 'C' |
|
args = [ '2.1.dict', '-batch' ] |
|
simpoint = 1146*100E6 |
|
|
|
class perlbmk(DefaultBenchmark): |
|
name = 'perlbmk' |
|
number = 253 |
|
lang = 'C' |
|
|
|
def test(self, isa, os): |
|
self.args = [ '-I.', '-I', 'lib', 'test.pl' ] |
|
self.stdin = 'test.in' |
|
|
|
class perlbmk_diffmail(perlbmk): |
|
def ref(self, isa, os): |
|
self.simpoint = 141*100E6 |
|
self.args = [ '-I', 'lib', 'diffmail.pl', '2', '550', '15', '24', |
|
'23', '100' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ '-I', 'lib', 'diffmail.pl', '2', '350', '15', '24', |
|
'23', '150' ] |
|
|
|
class perlbmk_scrabbl(perlbmk): |
|
def train(self, isa, os): |
|
self.args = [ '-I.', '-I', 'lib', 'scrabbl.pl' ] |
|
self.stdin = 'scrabbl.in' |
|
|
|
class perlbmk_makerand(perlbmk): |
|
def ref(self, isa, os): |
|
self.simpoint = 11*100E6 |
|
self.args = [ '-I', 'lib', 'makerand.pl' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ '-I.', '-I', 'lib', 'lgred.makerand.pl' ] |
|
|
|
def mdred(self, isa, os): |
|
self.args = [ '-I.', '-I', 'lib', 'mdred.makerand.pl' ] |
|
|
|
def smred(self, isa, os): |
|
self.args = [ '-I.', '-I', 'lib', 'smred.makerand.pl' ] |
|
|
|
class perlbmk_perfect(perlbmk): |
|
def ref(self, isa, os): |
|
self.simpoint = 5*100E6 |
|
self.args = [ '-I', 'lib', 'perfect.pl', 'b', '3', 'm', '4' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ '-I', 'lib', 'perfect.pl', 'b', '3' ] |
|
|
|
class perlbmk_splitmail1(perlbmk): |
|
def ref(self, isa, os): |
|
self.simpoint = 405*100E6 |
|
self.args = [ '-I', 'lib', 'splitmail.pl', '850', '5', '19', |
|
'18', '1500' ] |
|
|
|
class perlbmk_splitmail2(perlbmk): |
|
def ref(self, isa, os): |
|
self.args = [ '-I', 'lib', 'splitmail.pl', '704', '12', '26', |
|
'16', '836' ] |
|
|
|
class perlbmk_splitmail3(perlbmk): |
|
def ref(self, isa, os): |
|
self.args = [ '-I', 'lib', 'splitmail.pl', '535', '13', '25', |
|
'24', '1091' ] |
|
|
|
class perlbmk_splitmail4(perlbmk): |
|
def ref(self, isa, os): |
|
self.args = [ '-I', 'lib', 'splitmail.pl', '957', '12', '23', |
|
'26', '1014' ] |
|
|
|
class twolf(Benchmark): |
|
name = 'twolf' |
|
number = 300 |
|
lang = 'C' |
|
stdin = None |
|
|
|
def test(self, isa, os): |
|
self.args = [ 'test' ] |
|
|
|
def train(self, isa, os): |
|
self.args = [ 'train' ] |
|
|
|
def ref(self, isa, os): |
|
self.simpoint = 1066*100E6 |
|
self.args = [ 'ref' ] |
|
|
|
def smred(self, isa, os): |
|
self.args = [ 'smred' ] |
|
|
|
def mdred(self, isa, os): |
|
self.args = [ 'mdred' ] |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ 'lgred' ] |
|
|
|
class vortex(Benchmark): |
|
name = 'vortex' |
|
number = 255 |
|
lang = 'C' |
|
stdin = None |
|
|
|
def __init__(self, isa, os, input_set): |
|
if (isa in ('alpha', 'arm', 'thumb', 'aarch64')): |
|
self.endian = 'lendian' |
|
elif (isa == 'sparc' or isa == 'sparc32'): |
|
self.endian = 'bendian' |
|
else: |
|
raise AttributeError, "unknown ISA %s" % isa |
|
|
|
super(vortex, self).__init__(isa, os, input_set) |
|
|
|
def test(self, isa, os): |
|
self.args = [ '%s.raw' % self.endian ] |
|
self.output = 'vortex.out' |
|
|
|
def train(self, isa, os): |
|
self.args = [ '%s.raw' % self.endian ] |
|
self.output = 'vortex.out' |
|
|
|
def smred(self, isa, os): |
|
self.args = [ '%s.raw' % self.endian ] |
|
self.output = 'vortex.out' |
|
|
|
def mdred(self, isa, os): |
|
self.args = [ '%s.raw' % self.endian ] |
|
self.output = 'vortex.out' |
|
|
|
def lgred(self, isa, os): |
|
self.args = [ '%s.raw' % self.endian ] |
|
self.output = 'vortex.out' |
|
|
|
class vortex1(vortex): |
|
def ref(self, isa, os): |
|
self.args = [ '%s1.raw' % self.endian ] |
|
self.output = 'vortex1.out' |
|
self.simpoint = 271*100E6 |
|
|
|
|
|
class vortex2(vortex): |
|
def ref(self, isa, os): |
|
self.simpoint = 1024*100E6 |
|
self.args = [ '%s2.raw' % self.endian ] |
|
self.output = 'vortex2.out' |
|
|
|
class vortex3(vortex): |
|
def ref(self, isa, os): |
|
self.simpoint = 564*100E6 |
|
self.args = [ '%s3.raw' % self.endian ] |
|
self.output = 'vortex3.out' |
|
|
|
class vpr(MinneDefaultBenchmark): |
|
name = 'vpr' |
|
number = 175 |
|
lang = 'C' |
|
|
|
# not sure about vpr minnespec place.in |
|
class vpr_place(vpr): |
|
args = [ 'net.in', 'arch.in', 'place.out', 'dum.out', '-nodisp', |
|
'-place_only', '-init_t', '5', '-exit_t', '0.005', |
|
'-alpha_t', '0.9412', '-inner_num', '2' ] |
|
output = 'place_log.out' |
|
|
|
class vpr_route(vpr): |
|
simpoint = 476*100E6 |
|
args = [ 'net.in', 'arch.in', 'place.in', 'route.out', '-nodisp', |
|
'-route_only', '-route_chan_width', '15', |
|
'-pres_fac_mult', '2', '-acc_fac', '1', |
|
'-first_iter_pres_fac', '4', '-initial_pres_fac', '8' ] |
|
output = 'route_log.out' |
|
|
|
all = [ ammp, applu, apsi, art, art110, art470, equake, facerec, fma3d, galgel, |
|
lucas, mesa, mgrid, sixtrack, swim, wupwise, bzip2_source, |
|
bzip2_graphic, bzip2_program, crafty, eon_kajiya, eon_cook, |
|
eon_rushmeier, gap, gcc_166, gcc_200, gcc_expr, gcc_integrate, |
|
gcc_scilab, gzip_source, gzip_log, gzip_graphic, gzip_random, |
|
gzip_program, mcf, parser, perlbmk_diffmail, perlbmk_makerand, |
|
perlbmk_perfect, perlbmk_splitmail1, perlbmk_splitmail2, |
|
perlbmk_splitmail3, perlbmk_splitmail4, twolf, vortex1, vortex2, |
|
vortex3, vpr_place, vpr_route ] |
|
|
|
__all__ = [ x.__name__ for x in all ] |
|
|
|
if __name__ == '__main__': |
|
from pprint import pprint |
|
for bench in all: |
|
for input_set in 'ref', 'test', 'train': |
|
print 'class: %s' % bench.__name__ |
|
x = bench('alpha', 'tru64', input_set) |
|
print '%s: %s' % (x, input_set) |
|
pprint(x.makeLiveProcessArgs()) |
|
print |