612f8f074f
Note: AArch64 and AArch32 interworking is not supported. If you use an AArch64 kernel you are restricted to AArch64 user-mode binaries. This will be addressed in a later patch. Note: Virtualization is only supported in AArch32 mode. This will also be fixed in a later patch. Contributors: Giacomo Gabrielli (TrustZone, LPAE, system-level AArch64, AArch64 NEON, validation) Thomas Grocutt (AArch32 Virtualization, AArch64 FP, validation) Mbou Eyole (AArch64 NEON, validation) Ali Saidi (AArch64 Linux support, code integration, validation) Edmund Grimley-Evans (AArch64 FP) William Wang (AArch64 Linux support) Rene De Jong (AArch64 Linux support, performance opt.) Matt Horsnell (AArch64 MP, validation) Matt Evans (device models, code integration, validation) Chris Adeniyi-Jones (AArch64 syscall-emulation) Prakash Ramrakhyani (validation) Dam Sunwoo (validation) Chander Sudanthi (validation) Stephan Diestelhorst (validation) Andreas Hansson (code integration, performance opt.) Eric Van Hensbergen (performance opt.) Gabe Black
754 lines
22 KiB
Python
754 lines
22 KiB
Python
# 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
|