xref: /aosp_15_r20/cts/tools/incremental-cts/incremental_deqp.py (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf)

#!/usr/bin/env python3
#
#   Copyright 2021 - The Android Open Source Project
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.

"""Incremental dEQP

This script will run a subset of dEQP test on device to get dEQP dependency.

Usage 1: Compare with a base build to check if any dEQP dependency has
changed. Output a decision if dEQP could be skipped, and a cts-tradefed
command to be used based on the decision.

python3 incremental_deqp.py -s [device serial] -t [test directory] -b
[base build target file] -c [current build target file]

Usage 2: Generate a file containing a list of dEQP dependencies for the
build on device.

python3 incremental_deqp.py -s [device serial] -t [test directory]
--generate_deps_only

"""
import argparse
import importlib
import json
import logging
import os
import pkgutil
import re
import subprocess
import tempfile
import time
import uuid
from target_file_handler import TargetFileHandler
from custom_build_file_handler import CustomBuildFileHandler
from zipfile import ZipFile


DEFAULT_CTS_XML = ('<?xml version="1.0" encoding="utf-8"?>\n'
                   '<configuration description="Runs CTS from a pre-existing CTS installation">\n'
                   '   <include name="cts-common" />\n'
                   '   <include name="cts-exclude" />\n'
                   '   <include name="cts-exclude-instant" />\n'
                   '   <option name="enable-token-sharding" '
                   'value="true" />\n'
                   '   <option name="plan" value="cts" />\n'
                   '</configuration>\n')

INCREMENTAL_DEQP_XML = ('<?xml version="1.0" encoding="utf-8"?>\n'
                        '<configuration description="Runs CTS with incremental dEQP">\n'
                        '   <include name="cts-common" />\n'
                        '   <include name="cts-exclude" />\n'
                        '   <include name="cts-exclude-instant" />\n'
                        '   <option name="enable-token-sharding" '
                        'value="true" />\n'
                        '   <option name="compatibility:exclude-filter" '
                        'value="CtsDeqpTestCases" />\n'
                        '   <option name="plan" value="cts" />\n'
                        '</configuration>\n')

REPORT_FILENAME = 'incremental_dEQP_report.json'

logger = logging.getLogger()


class AtsError(Exception):
  """Error when running incremental dEQP with Android Test Station"""
  pass

class AdbError(Exception):
  """Error when running adb command."""
  pass

class TestError(Exception):
  """Error when running dEQP test."""
  pass

class TestResourceError(Exception):
  """Error with test resource. """
  pass

class BuildHelper(object):
  """Helper class for analyzing build."""

  def __init__(self, custom_handler=False):
    """Init BuildHelper.

    Args:
      custom_handler: use custom build handler.
    """
    self._build_file_handler = TargetFileHandler
    if custom_handler:
      self._build_file_handler = CustomBuildFileHandler


  def compare_base_build_with_current_build(self, deqp_deps, current_build_file,
                                            base_build_file):
    """Compare the difference of current build and base build with dEQP dependency.

    If the difference doesn't involve dEQP dependency, current build could skip dEQP test if
    base build has passed test.

    Args:
      deqp_deps: a set of dEQP dependency.
      current_build_file: current build's file name.
      base_build_file: base build's file name.
    Returns:
      True if current build could skip dEQP, otherwise False.
      Dictionary of changed dependencies and their details.
    """
    print('Comparing base build and current build...')
    current_build_handler = self._build_file_handler(current_build_file)
    current_build_hash = current_build_handler.get_file_hash(deqp_deps)

    base_build_handler = self._build_file_handler(base_build_file)
    base_build_hash = base_build_handler.get_file_hash(deqp_deps)

    return self._compare_build_hash(current_build_hash, base_build_hash)


  def compare_base_build_with_device_files(self, deqp_deps, adb, base_build_file):
    """Compare the difference of files on device and base build with dEQP dependency.

    If the difference doesn't involve dEQP dependency, current build could skip dEQP test if
    base build has passed test.

    Args:
      deqp_deps: a set of dEQP dependency.
      adb: an instance of AdbHelper for current device under test.
      base_build_file: base build file name.
    Returns:
      True if current build could skip dEQP, otherwise False.
      Dictionary of changed dependencies and their details.
    """
    print('Comparing base build and current build on the device...')
    # Get current build's hash.
    current_build_hash = dict()
    for dep in deqp_deps:
      content = adb.run_shell_command('cat ' + dep)
      current_build_hash[dep] = hash(content)

    base_build_handler = self._build_file_handler(base_build_file)
    base_build_hash = base_build_handler.get_file_hash(deqp_deps)

    return self._compare_build_hash(current_build_hash, base_build_hash)

  def get_system_fingerprint(self, build_file):
    """Get build fingerprint in SYSTEM partition.

    Returns:
      String of build fingerprint.
    """
    return self._build_file_handler(build_file).get_system_fingerprint()


  def _compare_build_hash(self, current_build_hash, base_build_hash):
    """Compare the hash value of current build and base build.

    Args:
      current_build_hash: map of current build where key is file name, and value is content hash.
      base_build_hash: map of base build where key is file name and value is content hash.
    Returns:
      Boolean about if two builds' hash is the same.
      Dictionary of changed dependencies and their details.
    """
    changes = {}
    if current_build_hash == base_build_hash:
      print('Done!')
      return True, changes

    for key, val in current_build_hash.items():
      if key not in base_build_hash:
        detail = 'File:{build_file} was not found in base build'.format(build_file=key)
        changes[key] = detail
        logger.info(detail)
      elif base_build_hash[key] != val:
        detail = ('Detected dEQP dependency file difference:{deps}. Base build hash:{base}, '
                  'current build hash:{current}'.format(deps=key, base=base_build_hash[key],
                                                        current=val))
        changes[key] = detail
        logger.info(detail)

    print('Done!')
    return False, changes


class AdbHelper(object):
  """Helper class for running adb."""

  def __init__(self, device_serial=None):
    """Initialize AdbHelper.

    Args:
      device_serial: A string of device serial number, optional.
    """
    self._device_serial = device_serial

  def _run_adb_command(self, *args):
    """Run adb command."""
    adb_cmd = ['adb']
    if self._device_serial:
      adb_cmd.extend(['-s', self._device_serial])
    adb_cmd.extend(args)
    adb_cmd = ' '.join(adb_cmd)
    completed = subprocess.run(adb_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    if completed.returncode != 0:
      raise AdbError('adb command: {cmd} failed with error: {error}'
                     .format(cmd=adb_cmd, error=completed.stderr))

    return completed.stdout

  def push_file(self, source_file, destination_file):
    """Push a file from device to host.

    Args:
      source_file: A string representing file to push.
      destination_file: A string representing target on device to push to.
    """
    return self._run_adb_command('push', source_file, destination_file)

  def pull_file(self, source_file, destination_file):
    """Pull a file to device.

    Args:
      source_file: A string representing file on device to pull.
      destination_file: A string representing target on host to pull to.
    """
    return self._run_adb_command('pull', source_file, destination_file)

  def get_fingerprint(self):
    """Get fingerprint of the device."""
    return self._run_adb_command('shell', 'getprop ro.build.fingerprint').decode("utf-8").strip()

  def run_shell_command(self, command):
    """Run a adb shell command.

    Args:
      command: A string of command to run, executed through 'adb shell'
    """
    return self._run_adb_command('shell', command)


class DeqpDependencyCollector(object):
  """Collect dEQP dependency from device under test."""

  def __init__(self, work_dir, test_dir, adb):
    """Init DeqpDependencyCollector.

    Args:
      work_dir: path of directory for saving script result and logs.
      test_dir: path of directory for incremental dEQP test file.
      adb: an instance of AdbHelper.
    """
    self._work_dir = work_dir
    self._test_dir = test_dir
    self._adb = adb
    # dEQP dependency with pattern below are not an actual file:
    # files has prefix /data/ are not system files, e.g. intermediate files.
    # [vdso] is virtual dynamic shared object.
    # /dmabuf is a temporary file.
    self._exclude_deqp_pattern = re.compile('(^/data/|^\[vdso\]|^/dmabuf)')

  def check_test_log(self, test_file, log_file):
    """Check test's log to see if all tests are executed.

    Args:
      test_file: Name of test .txt file.
      log_content: Name of log file.
    Returns:
      True if all tests are executed, otherwise False.
    """
    test_cnt = 0
    with open(test_file, 'r') as f:
      for _ in f:
        test_cnt += 1

    executed_test_cnt = 0

    with open(log_file, 'r') as f:
      for line in f:
        # 'NotSupported' status means test is not supported in device.
        # TODO(yichunli): Check with graphics team if failed test is allowed.
        if ('StatusCode="Pass"' in line or 'StatusCode="NotSupported"' in line or
            'StatusCode="Fail"' in line):
          executed_test_cnt += 1
    return executed_test_cnt == test_cnt

  def update_dependency(self, deps, dump):
    """Parse perf dump file and update dEQP dependency.

     Below is an example of how dump file looks like:
     630 record comm: type 3, misc 0, size 64
     631   pid 23365, tid 23365, comm simpleperf
     632   sample_id: pid 0, tid 0
     633   sample_id: time 0
     634   sample_id: id 23804
     635   sample_id: cpu 0, res 0
  .......
     684 record comm: type 3, misc 8192, size 64
     685   pid 23365, tid 23365, comm deqp-binary64
     686   sample_id: pid 23365, tid 23365
     687   sample_id: time 595063921159958
     688   sample_id: id 23808
     689   sample_id: cpu 4, res 0
  .......
     698 record mmap2: type 10, misc 8194, size 136
     699   pid 23365, tid 23365, addr 0x58b817b000, len 0x3228000
     700   pgoff 0x0, maj 253, min 9, ino 14709, ino_generation 2575019956
     701   prot 1, flags 6146, filename /data/local/tmp/deqp-binary64
     702   sample_id: pid 23365, tid 23365
     703   sample_id: time 595063921188552
     704   sample_id: id 23808
     705   sample_id: cpu 4, res 0

    Args:
      deps: a set of string containing dEQP dependency.
      dump: perf dump file's name.
    """
    binary_executed = False
    correct_mmap = False
    with open(dump, 'r') as f:
      for line in f:
        # It means dEQP binary starts to be executed.
        if re.search(' comm .*deqp-binary', line):
          binary_executed = True
        if not binary_executed:
          continue
        # We get a new perf event
        if not line.startswith(' '):
          # mmap with misc 1 is not for deqp binary.
          correct_mmap = line.startswith('record mmap') and 'misc 1,' not in line
        # Get file name in memory map.
        if 'filename' in line and correct_mmap:
          deps_file = line[line.find('filename') + 9:].strip()
          if not re.search(self._exclude_deqp_pattern, deps_file):
            deps.add(deps_file)


  def get_test_binary_name(self, test_name):
    """Get dEQP binary's name based on test name.

    Args:
      test_name: name of test.
    Returns:
      dEQP binary's name.
    """
    if test_name.endswith('32'):
      return 'deqp-binary'
    elif test_name.endswith('64'):
      return 'deqp-binary64'
    else:
      raise TestError('Fail to get dEQP binary due to unknonw test name: ' + test_name)

  def get_test_log_name(self, test_name):
    """Get test log's name based on test name.

    Args:
      test_name: name of test.
    Returns:
      test log's name when running dEQP test.
    """
    return test_name + '.qpa'

  def get_test_perf_name(self, test_name):
    """Get perf file's name based on test name.

    Args:
      test_name: name of test.
    Returns:
      perf file's name.
    """
    return test_name + '.data'

  def get_perf_dump_name(self, test_name):
    """Get perf dump file's name based on test name.

    Args:
      test_name: name of test.
    Returns:
      perf dump file's name.
    """
    return test_name + '-perf-dump.txt'

  def get_test_list_name(self, test_name):
    """Get test list file's name based on test name.

    test list file is used to run dEQP test.

    Args:
      test_name: name of test.
    Returns:
      test list file's name.
    """
    if test_name.startswith('vk'):
      return 'vk-master-subset.txt'
    elif test_name.startswith('gles3'):
      return 'gles3-master-subset.txt'
    else:
      raise TestError('Fail to get test list due to unknown test name: ' + test_name)

  def get_deqp_dependency(self):
    """Get dEQP dependency.

    Returns:
      A set of dEQP dependency.
    """
    device_deqp_dir = '/data/local/tmp'
    device_deqp_out_dir = '/data/local/tmp/out'
    test_list = ['vk-32', 'vk-64', 'gles3-32', 'gles3-64']

    # Clean up the device.
    self._adb.run_shell_command('mkdir -p ' + device_deqp_out_dir)

    # Copy test resources to device.
    logger.info(self._adb.push_file(self._test_dir + '/*', device_deqp_dir))

    # Run the dEQP binary with simpleperf
    print('Running a subset of dEQP tests as binary on the device...')
    deqp_deps = set()
    for test in test_list:
      test_file = os.path.join(device_deqp_dir, self.get_test_list_name(test))
      log_file = os.path.join(device_deqp_out_dir, self.get_test_log_name(test))
      perf_file = os.path.join(device_deqp_out_dir, self.get_test_perf_name(test))
      deqp_binary = os.path.join(device_deqp_dir, self.get_test_binary_name(test))
      simpleperf_command = ('"cd {device_deqp_dir} && simpleperf record -o {perf_file} {binary} '
                            '--deqp-caselist-file={test_list} --deqp-log-images=disable '
                            '--deqp-log-shader-sources=disable --deqp-log-filename={log_file} '
                            '--deqp-surface-type=fbo --deqp-surface-width=2048 '
                            '--deqp-surface-height=2048"')
      self._adb.run_shell_command(
          simpleperf_command.format(device_deqp_dir=device_deqp_dir, binary=deqp_binary,
                                    perf_file=perf_file, test_list=test_file, log_file=log_file))

      # Check test log.
      host_log_file = os.path.join(self._work_dir, self.get_test_log_name(test))
      self._adb.pull_file(log_file, host_log_file )
      if not self.check_test_log(os.path.join(self._test_dir, self.get_test_list_name(test)),
                                 host_log_file):
        error_msg = ('Fail to run incremental dEQP because of crashed test. Check test'
                     'log {} for more detail.').format(host_log_file)
        logger.error(error_msg)
        raise TestError(error_msg)
    print('Tests are all passed!')

    # Parse perf dump result to get dependency.
    print('Analyzing dEQP dependency...')
    for test in test_list:
      perf_file = os.path.join(device_deqp_out_dir, self.get_test_perf_name(test))
      dump_file = os.path.join(self._work_dir, self.get_perf_dump_name(test))
      self._adb.run_shell_command('simpleperf dump {perf_file} > {dump_file}'
                                  .format(perf_file=perf_file, dump_file=dump_file))
      self.update_dependency(deqp_deps, dump_file)
    print('Done!')
    return deqp_deps

def _is_deqp_dependency(dependency_name):
  """Check if dependency is related to dEQP."""
  # dEQP dependency with pattern below will not be used to compare build:
  # files has /apex/ prefix are not related to dEQP.
  return not re.search(re.compile('^/apex/'), dependency_name)

def _get_parser():
  parser = argparse.ArgumentParser(description='Run incremental dEQP on devices.')
  parser.add_argument('-s', '--serial', help='Optional. Use device with given serial.')
  parser.add_argument('-t', '--test', help=('Optional. Directory of incremental deqp test file. '
                                            'This directory should have test resources and dEQP '
                                            'binaries.'))
  parser.add_argument('-b', '--base_build', help=('Target file of base build that has passed dEQP '
                                                  'test, e.g. flame-target_files-6935423.zip.'))
  parser.add_argument('-c', '--current_build',
                      help=('Optional. When empty, the script will read files in the build from '
                            'the device via adb. When set, the script will read build files from '
                            'the file provided by this argument. And this file should be the '
                            'current build that is flashed to device, such as a target file '
                            'like flame-target_files-6935424.zip. This argument can be used when '
                            'some dependencies files are not accessible via adb.'))
  parser.add_argument('--generate_deps_only', action='store_true',
                      help=('Run test and generate dEQP dependency list only '
                            'without comparing build.'))
  parser.add_argument('--custom_handler', action='store_true',
                      help='Use custome build file handler')
  parser.add_argument('--ats_mode', action='store_true',
                      help=('Run incremental dEQP with Android Test Station.'))
  parser.add_argument('--userdebug_build', action='store_true',
                      help=('ATS mode option. Current build on device is userdebug.'))
  return parser

def _create_logger(log_file_name):
  """Create logger.

  Args:
    log_file_name: absolute path of the log file.
  Returns:
    a logging.Logger
  """
  logging.basicConfig(filename=log_file_name)
  logger = logging.getLogger()
  logger.setLevel(level=logging.NOTSET)
  return logger

def _save_deqp_deps(deqp_deps, file_name):
  """Save dEQP dependency to file.

  Args:
    deqp_deps: a set of dEQP dependency.
    file_name: name of the file to save dEQP dependency.
  Returns:
    name of the file that saves dEQP dependency.
  """
  with open(file_name, 'w') as f:
    for dep in sorted(deqp_deps):
      f.write(dep+'\n')
  return file_name

def _generate_report(
    report_name,
    base_build_fingerprint,
    current_build_fingerprint,
    deqp_deps,
    extra_deqp_deps,
    deqp_deps_changes):
  """Generate a json report.

  Args:
    report_name: absolute file name of report.
    base_build_fingerprint: fingerprint of the base build.
    current_build_fingerprint: fingerprint of the current build.
    deqp_deps: list of dEQP dependencies generated by the tool.
    extra_deqp_deps: list of extra dEQP dependencies.
    deqp_deps_changes: dictionary of dependency changes.
  """
  data = {}
  data['base_build_fingerprint'] = base_build_fingerprint
  data['current_build_fingerprint'] = current_build_fingerprint
  data['deqp_deps'] = sorted(list(deqp_deps))
  data['extra_deqp_deps'] = sorted(list(extra_deqp_deps))
  data['deqp_deps_changes'] = deqp_deps_changes

  with open(report_name, 'w') as f:
    json.dump(data, f, indent=4)

  print('Incremental dEQP report is generated at: ' + report_name)


def _local_run(args, work_dir):
  """Run incremental dEQP locally.

  Args:
    args: return of parser.parse_args().
    work_dir: path of directory for saving script result and logs.
  """
  print('Logs and simpleperf results will be copied to: ' + work_dir)
  if args.test:
    test_dir = args.test
  else:
    test_dir = os.path.dirname(os.path.abspath(__file__))
  # Extra dEQP dependencies are the files can't be loaded to memory such as firmware.
  extra_deqp_deps = set()
  extra_deqp_deps_file = os.path.join(test_dir, 'extra_deqp_dependency.txt')
  if not os.path.exists(extra_deqp_deps_file):
    if not args.generate_deps_only:
      raise TestResourceError('{test_resource} doesn\'t exist'
                             .format(test_resource=extra_deqp_deps_file))
  else:
    with open(extra_deqp_deps_file, 'r') as f:
      for line in f:
        extra_deqp_deps.add(line.strip())

  if args.serial:
    adb = AdbHelper(args.serial)
  else:
    adb = AdbHelper()

  dependency_collector = DeqpDependencyCollector(work_dir, test_dir, adb)
  deqp_deps = dependency_collector.get_deqp_dependency()
  aggregated_deqp_deps = deqp_deps.union(extra_deqp_deps)

  deqp_deps_file_name = _save_deqp_deps(aggregated_deqp_deps,
                                        os.path.join(work_dir, 'dEQP-dependency.txt'))
  print('dEQP dependency list has been generated in: ' + deqp_deps_file_name)

  if args.generate_deps_only:
    return

  # Compare the build difference with dEQP dependency
  valid_deqp_deps = [dep for dep in aggregated_deqp_deps if _is_deqp_dependency(dep)]
  build_helper = BuildHelper(args.custom_handler)
  if args.current_build:
    skip_dEQP, changes = build_helper.compare_base_build_with_current_build(
        valid_deqp_deps, args.current_build, args.base_build)
  else:
    skip_dEQP, changes = build_helper.compare_base_build_with_device_files(
        valid_deqp_deps, adb, args.base_build)
  if skip_dEQP:
    print('Congratulations, current build could skip dEQP test.\n'
          'If you run CTS through suite, you could pass filter like '
          '\'--exclude-filter CtsDeqpTestCases\'.')
  else:
    print('Sorry, current build can\'t skip dEQP test because dEQP dependency has been '
          'changed.\nPlease check logs for more details.')

  _generate_report(os.path.join(work_dir, REPORT_FILENAME),
                   build_helper.get_system_fingerprint(args.base_build),
                   adb.get_fingerprint(),
                   deqp_deps,
                   extra_deqp_deps,
                   changes)

def _generate_cts_xml(out_dir, content):
  """Generate cts configuration for Android Test Station.

  Args:
   out_dir: output directory for cts confiugration.
   content: configuration content.
  """
  with open(os.path.join(out_dir, 'incremental_deqp.xml'), 'w') as f:
    f.write(content)


def _ats_run(args, work_dir):
  """Run incremental dEQP with Android Test Station.

  Args:
    args: return of parser.parse_args().
    work_dir: path of directory for saving script result and logs.
  """
  # Extra dEQP dependencies are the files can't be loaded to memory such as firmware.
  extra_deqp_deps = set()
  with open(os.path.join(work_dir, 'extra_deqp_dependency.txt'), 'r') as f:
    for line in f:
      if line.strip():
        extra_deqp_deps.add(line.strip())

  android_serials = os.getenv('ANDROID_SERIALS')
  if not android_serials:
    raise AtsError('Fail to read environment variable ANDROID_SERIALS.')
  first_device_serial = android_serials.split(',')[0]
  adb = AdbHelper(first_device_serial)

  dependency_collector = DeqpDependencyCollector(work_dir,
                                                 os.path.join(work_dir, 'test_resources'), adb)
  deqp_deps = dependency_collector.get_deqp_dependency()
  aggregated_deqp_deps = deqp_deps.union(extra_deqp_deps)

  deqp_deps_file_name = _save_deqp_deps(aggregated_deqp_deps,
                                        os.path.join(work_dir, 'dEQP-dependency.txt'))

  if args.generate_deps_only:
    _generate_cts_xml(work_dir, DEFAULT_CTS_XML)
    return

  # Compare the build difference with dEQP dependency
  valid_deqp_deps = [dep for dep in aggregated_deqp_deps if _is_deqp_dependency(dep)]

  # base build target file is from test resources.
  base_build_target = os.path.join(work_dir, 'base_build_target_files')
  build_helper = BuildHelper(args.custom_handler)
  if args.userdebug_build:
    current_build_fingerprint = adb.get_fingerprint()
    skip_dEQP, changes = build_helper.compare_base_build_with_device_files(
        valid_deqp_deps, adb, base_build_target)
  else:
    current_build_target = os.path.join(work_dir, 'current_build_target_files')
    current_build_fingerprint = build_helper.get_system_fingerprint(current_build_target)
    skip_dEQP, changes = build_helper.compare_base_build_with_current_build(
        valid_deqp_deps, current_build_target, base_build_target)
  if skip_dEQP:
    _generate_cts_xml(work_dir, INCREMENTAL_DEQP_XML)
  else:
    _generate_cts_xml(work_dir, DEFAULT_CTS_XML)

  _generate_report(os.path.join(*[work_dir, 'logs', REPORT_FILENAME]),
                   build_helper.get_system_fingerprint(base_build_target),
                   current_build_fingerprint,
                   deqp_deps,
                   extra_deqp_deps,
                   changes)

def main():
  parser = _get_parser()
  args = parser.parse_args()
  if not args.generate_deps_only and not args.base_build and not args.ats_mode:
    parser.error('Base build argument: \'-b [file] or --base_build [file]\' '
                 'is required to compare build.')

  work_dir = ''
  log_file_name = ''
  if args.ats_mode:
    work_dir = os.getenv('TF_WORK_DIR')
    log_file_name = os.path.join(*[work_dir, 'logs', 'incremental-deqp-log-'+str(uuid.uuid4())])
  else:
    work_dir = tempfile.mkdtemp(prefix='incremental-deqp-'
                                + time.strftime("%Y%m%d-%H%M%S"))
    log_file_name = os.path.join(work_dir, 'incremental-deqp-log')
  global logger
  logger = _create_logger(log_file_name)

  if args.ats_mode:
    _ats_run(args, work_dir)
  else:
    _local_run(args, work_dir)

if __name__ == '__main__':
  main()