d11c40dcac
This ensures `isort` is applied to all files in the repo. Change-Id: Ib7ced1c924ef1639542bf0d1a01c5737f6ba43e9
1045 lines
23 KiB
Python
1045 lines
23 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.
|
|
|
|
import os
|
|
import sys
|
|
from os.path import (
|
|
basename,
|
|
exists,
|
|
isdir,
|
|
isfile,
|
|
islink,
|
|
)
|
|
from os.path import join as joinpath
|
|
from os.path import normpath
|
|
|
|
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:
|
|
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 = f"{self.name}.out"
|
|
|
|
if not hasattr(self.__class__, "simpoint"):
|
|
self.simpoint = None
|
|
|
|
try:
|
|
func = getattr(self.__class__, input_set)
|
|
except AttributeError:
|
|
raise AttributeError(
|
|
f"The benchmark {self.name} does not have the {input_set} input set"
|
|
)
|
|
|
|
executable = joinpath(spec_dist, "binaries", isa, os, self.binary)
|
|
if not isfile(executable):
|
|
raise AttributeError(f"{executable} not found")
|
|
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(f"{inputs_dir} not found")
|
|
|
|
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, f"{self.name}.in")
|
|
if not isfile(self.stdin):
|
|
self.stdin = None
|
|
|
|
if not hasattr(self.__class__, "stdout"):
|
|
self.stdout = joinpath(outputs_dir, f"{self.name}.out")
|
|
if not isfile(self.stdout):
|
|
self.stdout = None
|
|
|
|
func(self, isa, os)
|
|
|
|
def makeProcessArgs(self, **kwargs):
|
|
# set up default args for Process 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 makeProcess(self, **kwargs):
|
|
process_args = self.makeProcessArgs(**kwargs)
|
|
|
|
# figure out working directory: use m5's outdir unless
|
|
# overridden by Process'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 Process object
|
|
from m5.objects import Process
|
|
|
|
return Process(**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",
|
|
f"{self.name}.in",
|
|
"-ppmfile",
|
|
f"{self.name}.ppm",
|
|
]
|
|
|
|
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 ("arm", "thumb", "aarch64"):
|
|
self.endian = "lendian"
|
|
elif isa == "sparc" or isa == "sparc32":
|
|
self.endian = "bendian"
|
|
else:
|
|
raise AttributeError(f"unknown ISA {isa}")
|
|
|
|
super().__init__(isa, os, input_set)
|
|
|
|
def test(self, isa, os):
|
|
self.args = [f"{self.endian}.raw"]
|
|
self.output = "vortex.out"
|
|
|
|
def train(self, isa, os):
|
|
self.args = [f"{self.endian}.raw"]
|
|
self.output = "vortex.out"
|
|
|
|
def smred(self, isa, os):
|
|
self.args = [f"{self.endian}.raw"]
|
|
self.output = "vortex.out"
|
|
|
|
def mdred(self, isa, os):
|
|
self.args = [f"{self.endian}.raw"]
|
|
self.output = "vortex.out"
|
|
|
|
def lgred(self, isa, os):
|
|
self.args = [f"{self.endian}.raw"]
|
|
self.output = "vortex.out"
|
|
|
|
|
|
class vortex1(vortex):
|
|
def ref(self, isa, os):
|
|
self.args = [f"{self.endian}1.raw"]
|
|
self.output = "vortex1.out"
|
|
self.simpoint = 271 * 100e6
|
|
|
|
|
|
class vortex2(vortex):
|
|
def ref(self, isa, os):
|
|
self.simpoint = 1024 * 100e6
|
|
self.args = [f"{self.endian}2.raw"]
|
|
self.output = "vortex2.out"
|
|
|
|
|
|
class vortex3(vortex):
|
|
def ref(self, isa, os):
|
|
self.simpoint = 564 * 100e6
|
|
self.args = [f"{self.endian}3.raw"]
|
|
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(f"class: {bench.__name__}")
|
|
x = bench("x86", "linux", input_set)
|
|
print(f"{x}: {input_set}")
|
|
pprint(x.makeProcessArgs())
|
|
print()
|