#!/usr/bin/env python
#
# Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

# Simple wrapper for running benchmarks.

import getopt
import optparse
import os
from os.path import join, dirname, realpath, abspath
import subprocess
import sys
import utils
import re

HOST_OS = utils.GuessOS()
HOST_CPUS = utils.GuessCpus()


# Returns whether 'bench' matches any element in the 'filt' list.
def match(bench, filt):
    bench = bench.lower()
    for element in filt:
        if element.search(bench):
            return True
    return False


def GetBenchmarkFile(path):
    benchmark_root_path = [dirname(sys.argv[0]), '..', '..'] + ['benchmarks']
    return realpath(os.path.sep.join(benchmark_root_path + path))


def ReadBenchmarkList(mode, path, core):
    filename = GetBenchmarkFile([path])
    benchmarks = dict()
    execfile(filename, benchmarks)
    if (mode == "release") and not core:
        return benchmarks['SUPPORTED_BENCHMARKS']
    else:
        return benchmarks['SUPPORTED_CORE_BENCHMARKS']


def BuildOptions():
    result = optparse.OptionParser()
    result.add_option(
        "-m",
        "--mode",
        help='Build variants (comma-separated).',
        metavar='[all,debug,release]',
        default='release')
    result.add_option(
        "-v",
        "--verbose",
        help='Verbose output.',
        default=False,
        action="store_true")
    result.add_option(
        "-c",
        "--core",
        help='Run only core benchmarks.',
        default=False,
        action="store_true")
    result.add_option(
        "--arch",
        help='Target architectures (comma-separated).',
        metavar='[all,ia32,x64,simarm,arm,dartc]',
        default=utils.GuessArchitecture())
    result.add_option(
        "--executable",
        help='Virtual machine to execute.',
        metavar='[dart, (path to dart binary)]',
        default=None)
    result.add_option(
        "-w",
        "--warmup",
        help='Only run the warmup period.',
        default=False,
        action="store_true")
    return result


def ProcessOptions(options):
    if options.arch == 'all':
        options.arch = 'ia32,x64,simarm,dartc'
    if options.mode == 'all':
        options.mode = 'debug,release'
    options.mode = options.mode.split(',')
    options.arch = options.arch.split(',')
    for mode in options.mode:
        if not mode in ['debug', 'release']:
            print "Unknown mode %s" % mode
            return False
    for arch in options.arch:
        if not arch in ['ia32', 'x64', 'simarm', 'arm', 'dartc']:
            print "Unknown arch %s" % arch
            return False
    return True


def GetBuildRoot(mode, arch):
    return utils.GetBuildRoot(HOST_OS, mode, arch)


def GetDart(mode, arch):
    executable = [abspath(join(GetBuildRoot(mode, arch), 'dart'))]
    return executable


def Main():
    # Parse the options.
    parser = BuildOptions()
    (options, args) = parser.parse_args()
    if not ProcessOptions(options):
        parser.print_help()
        return 1

    chosen_benchmarks = ReadBenchmarkList(options.mode, 'BENCHMARKS',
                                          options.core)

    # Use arguments to filter the benchmarks.
    if len(args) > 0:
        filt = [re.compile(x.lower()) for x in args]
        chosen_benchmarks = [b for b in chosen_benchmarks if match(b[0], filt)]

    for mode in options.mode:
        for arch in options.arch:
            if options.executable is None:
                # Construct the path to the dart binary.
                executable = GetDart(mode, arch)
            else:
                executable = [options.executable]
            for benchmark, vmargs, progargs in chosen_benchmarks:
                command = executable
                command = command + [
                    GetBenchmarkFile([benchmark, 'dart', benchmark + '.dart']),
                ]
                if options.verbose:
                    print ' '.join(command)
                subprocess.call(command)
    return 0


if __name__ == '__main__':
    sys.exit(Main())