#!/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())