# 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