ext/testlib/configuration.py

   1 # Copyright (c) 2020 ARM Limited
   2 # All rights reserved
   3 #
   4 # The license below extends only to copyright in the software and shall
   5 # not be construed as granting a license to any other intellectual
   6 # property including but not limited to intellectual property relating
   7 # to a hardware implementation of the functionality of the software
   8 # licensed hereunder.  You may use the software subject to the license
   9 # terms below provided that you ensure that this notice is replicated
  10 # unmodified and in its entirety in all distributions of the software,
  11 # modified or unmodified, in source code or in binary form.
  12 #
  13 # Copyright (c) 2017 Mark D. Hill and David A. Wood
  14 # All rights reserved.
  15 #
  16 # Redistribution and use in source and binary forms, with or without
  17 # modification, are permitted provided that the following conditions are
  18 # met: redistributions of source code must retain the above copyright
  19 # notice, this list of conditions and the following disclaimer;
  20 # redistributions in binary form must reproduce the above copyright
  21 # notice, this list of conditions and the following disclaimer in the
  22 # documentation and/or other materials provided with the distribution;
  23 # neither the name of the copyright holders nor the names of its
  24 # contributors may be used to endorse or promote products derived from
  25 # this software without specific prior written permission.
  26 #
  27 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  28 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  29 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  30 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  31 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  32 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  33 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  34 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  35 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  36 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  37 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38 #
  39 # Authors: Sean Wilson
  40
  41 '''
  42 Global configuration module which exposes two types of configuration
  43 variables:
  44
  45 1. config
  46 2. constants (Also attached to the config variable as an attribute)
  47
  48 The main motivation for this module is to have a centralized location for
  49 defaults and configuration by command line and files for the test framework.
  50
  51 A secondary goal is to reduce programming errors by providing common constant
  52 strings and values as python attributes to simplify detection of typos.
  53 A simple typo in a string can take a lot of debugging to uncover the issue,
  54 attribute errors are easier to notice and most autocompletion systems detect
  55 them.
  56
  57 The config variable is initialzed by calling :func:`initialize_config`.
  58 Before this point only ``constants`` will be availaible. This is to ensure
  59 that library function writers never accidentally get stale config attributes.
  60
  61 Program arguments/flag arguments are available from the config as attributes.
  62 If an attribute was not set by the command line or the optional config file,
  63 then it will fallback to the `_defaults` value, if still the value is not
  64 found an AttributeError will be raised.
  65
  66 :func define_defaults:
  67     Provided by the config if the attribute is not found in the config or
  68     commandline. For instance, if we are using the list command fixtures might
  69     not be able to count on the build_dir being provided since we aren't going
  70     to build anything.
  71
  72 :var constants:
  73     Values not directly exposed by the config, but are attached to the object
  74     for centralized access. I.E. you can reach them with
  75     :code:`config.constants.attribute`. These should be used for setting
  76     common string names used across the test framework.
  77     :code:`_defaults.build_dir = None` Once this module has been imported
  78     constants should not be modified and their base attributes are frozen.
  79 '''
  80 import abc
  81 import argparse
  82 import copy
  83 import os
  84 import re
  85
  86 from six import add_metaclass
  87 from pickle import HIGHEST_PROTOCOL as highest_pickle_protocol
  88
  89 from testlib.helper import absdirpath, AttrDict, FrozenAttrDict
  90
  91 class UninitialzedAttributeException(Exception):
  92     '''
  93     Signals that an attribute in the config file was not initialized.
  94     '''
  95     pass
  96
  97 class UninitializedConfigException(Exception):
  98     '''
  99     Signals that the config was not initialized before trying to access an
 100     attribute.
 101     '''
 102     pass
 103
 104 class TagRegex(object):
 105     def __init__(self, include, regex):
 106         self.include = include
 107         self.regex = re.compile(regex)
 108
 109     def __str__(self):
 110         type_ = 'Include' if self.include else 'Remove'
 111         return '%10s: %s' % (type_, self.regex.pattern)
 112
 113 class _Config(object):
 114     _initialized = False
 115
 116     __shared_dict = {}
 117
 118     constants = AttrDict()
 119     _defaults = AttrDict()
 120     _config = {}
 121
 122     _cli_args = {}
 123     _post_processors = {}
 124
 125     def __init__(self):
 126         # This object will act as if it were a singleton.
 127         self.__dict__ = self.__shared_dict
 128
 129     def _init(self, parser):
 130         self._parse_commandline_args(parser)
 131         self._run_post_processors()
 132         self._initialized = True
 133
 134     def _add_post_processor(self, attr, post_processor):
 135         '''
 136         :param attr: Attribute to pass to and recieve from the
 137         :func:`post_processor`.
 138
 139         :param post_processor: A callback functions called in a chain to
 140             perform additional setup for a config argument. Should return a
 141             tuple containing the new value for the config attr.
 142         '''
 143         if attr not in self._post_processors:
 144             self._post_processors[attr] = []
 145         self._post_processors[attr].append(post_processor)
 146
 147     def _set(self, name, value):
 148         self._config[name] = value
 149
 150     def _parse_commandline_args(self, parser):
 151         args = parser.parse_args()
 152
 153         self._config_file_args = {}
 154
 155         for attr in dir(args):
 156             # Ignore non-argument attributes.
 157             if not attr.startswith('_'):
 158                 self._config_file_args[attr] = getattr(args, attr)
 159         self._config.update(self._config_file_args)
 160
 161     def _run_post_processors(self):
 162         for attr, callbacks in self._post_processors.items():
 163             newval = self._lookup_val(attr)
 164             for callback in callbacks:
 165                 newval = callback(newval)
 166             if newval is not None:
 167                 newval = newval[0]
 168             self._set(attr, newval)
 169
 170
 171     def _lookup_val(self, attr):
 172         '''
 173         Get the attribute from the config or fallback to defaults.
 174
 175         :returns: If the value is not stored return None. Otherwise a tuple
 176             containing the value.
 177         '''
 178         if attr in self._config:
 179             return (self._config[attr],)
 180         elif hasattr(self._defaults, attr):
 181             return (getattr(self._defaults, attr),)
 182
 183     def __getattr__(self, attr):
 184         if attr in dir(super(_Config, self)):
 185             return getattr(super(_Config, self), attr)
 186         elif not self._initialized:
 187             raise UninitializedConfigException(
 188                 'Cannot directly access elements from the config before it is'
 189                 ' initialized')
 190         else:
 191             val = self._lookup_val(attr)
 192             if val is not None:
 193                 return val[0]
 194             else:
 195                 raise UninitialzedAttributeException(
 196                     '%s was not initialzed in the config.' % attr)
 197
 198     def get_tags(self):
 199         d = {typ: set(self.__getattr__(typ))
 200             for typ in self.constants.supported_tags}
 201         if any(map(lambda vals: bool(vals), d.values())):
 202             return d
 203         else:
 204             return {}
 205
 206 def define_defaults(defaults):
 207     '''
 208     Defaults are provided by the config if the attribute is not found in the
 209     config or commandline. For instance, if we are using the list command
 210     fixtures might not be able to count on the build_dir being provided since
 211     we aren't going to build anything.
 212     '''
 213     defaults.base_dir = os.path.abspath(os.path.join(absdirpath(__file__),
 214                                                       os.pardir,
 215                                                       os.pardir))
 216     defaults.result_path = os.path.join(os.getcwd(), '.testing-results')
 217     defaults.resource_url = 'http://dist.gem5.org/dist/develop'
 218
 219 def define_constants(constants):
 220     '''
 221     'constants' are values not directly exposed by the config, but are attached
 222     to the object for centralized access. These should be used for setting
 223     common string names used across the test framework. A simple typo in
 224     a string can take a lot of debugging to uncover the issue, attribute errors
 225     are easier to notice and most autocompletion systems detect them.
 226     '''
 227     constants.system_out_name = 'system-out'
 228     constants.system_err_name = 'system-err'
 229
 230     constants.isa_tag_type = 'isa'
 231     constants.x86_tag = 'X86'
 232     constants.sparc_tag = 'SPARC'
 233     constants.riscv_tag = 'RISCV'
 234     constants.arm_tag = 'ARM'
 235     constants.mips_tag = 'MIPS'
 236     constants.power_tag = 'POWER'
 237     constants.null_tag = 'NULL'
 238
 239     constants.variant_tag_type = 'variant'
 240     constants.opt_tag = 'opt'
 241     constants.debug_tag = 'debug'
 242     constants.fast_tag = 'fast'
 243
 244     constants.length_tag_type = 'length'
 245     constants.quick_tag = 'quick'
 246     constants.long_tag = 'long'
 247
 248     constants.host_isa_tag_type = 'host'
 249     constants.host_x86_64_tag = 'x86_64'
 250     constants.host_arm_tag = 'aarch64'
 251
 252     constants.supported_tags = {
 253         constants.isa_tag_type : (
 254             constants.x86_tag,
 255             constants.sparc_tag,
 256             constants.riscv_tag,
 257             constants.arm_tag,
 258             constants.mips_tag,
 259             constants.power_tag,
 260             constants.null_tag,
 261             ),
 262         constants.variant_tag_type: (
 263             constants.opt_tag,
 264             constants.debug_tag,
 265             constants.fast_tag,
 266         ),
 267         constants.length_tag_type: (
 268             constants.quick_tag,
 269             constants.long_tag,
 270         ),
 271         constants.host_isa_tag_type: (
 272             constants.host_x86_64_tag,
 273             constants.host_arm_tag,
 274         ),
 275     }
 276
 277     # Binding target ISA with host ISA. This is useful for the
 278     # case where host ISA and target ISA need to coincide
 279     constants.target_host = {
 280         constants.arm_tag   : (constants.host_arm_tag,),
 281         constants.x86_tag   : (constants.host_x86_64_tag,),
 282         constants.sparc_tag : (constants.host_x86_64_tag,),
 283         constants.riscv_tag : (constants.host_x86_64_tag,),
 284         constants.mips_tag  : (constants.host_x86_64_tag,),
 285         constants.power_tag : (constants.host_x86_64_tag,),
 286         constants.null_tag  : (None,)
 287     }
 288
 289     constants.supported_isas = constants.supported_tags['isa']
 290     constants.supported_variants = constants.supported_tags['variant']
 291     constants.supported_lengths = constants.supported_tags['length']
 292     constants.supported_hosts = constants.supported_tags['host']
 293
 294     constants.tempdir_fixture_name = 'tempdir'
 295     constants.gem5_simulation_stderr = 'simerr'
 296     constants.gem5_simulation_stdout = 'simout'
 297     constants.gem5_simulation_stats = 'stats.txt'
 298     constants.gem5_simulation_config_ini = 'config.ini'
 299     constants.gem5_simulation_config_json = 'config.json'
 300     constants.gem5_returncode_fixture_name = 'gem5-returncode'
 301     constants.gem5_binary_fixture_name = 'gem5'
 302     constants.xml_filename = 'results.xml'
 303     constants.pickle_filename = 'results.pickle'
 304     constants.pickle_protocol = highest_pickle_protocol
 305
 306     # The root directory which all test names will be based off of.
 307     constants.testing_base = absdirpath(os.path.join(absdirpath(__file__),
 308                                                      os.pardir))
 309
 310 def define_post_processors(config):
 311     '''
 312     post_processors are used to do final configuration of variables. This is
 313     useful if there is a dynamically set default, or some function that needs
 314     to be applied after parsing in order to set a configration value.
 315
 316     Post processors must accept a single argument that will either be a tuple
 317     containing the already set config value or ``None`` if the config value
 318     has not been set to anything. They must return the modified value in the
 319     same format.
 320     '''
 321
 322     def set_default_build_dir(build_dir):
 323         '''
 324         Post-processor to set the default build_dir based on the base_dir.
 325
 326         .. seealso :func:`~_Config._add_post_processor`
 327         '''
 328         if not build_dir or build_dir[0] is None:
 329             base_dir = config._lookup_val('base_dir')[0]
 330             build_dir = (os.path.join(base_dir, 'build'),)
 331         return build_dir
 332
 333     def fix_verbosity_hack(verbose):
 334         return (verbose[0].val,)
 335
 336     def threads_as_int(threads):
 337         if threads is not None:
 338             return (int(threads[0]),)
 339
 340     def test_threads_as_int(test_threads):
 341         if test_threads is not None:
 342             return (int(test_threads[0]),)
 343
 344     def default_isa(isa):
 345         if not isa[0]:
 346             return [constants.supported_tags[constants.isa_tag_type]]
 347         else:
 348             return isa
 349
 350     def default_variant(variant):
 351         if not variant[0]:
 352             # Default variant is only opt. No need to run tests with multiple
 353             # different compilation targets
 354             return [[constants.opt_tag]]
 355         else:
 356             return variant
 357
 358     def default_length(length):
 359         if not length[0]:
 360             return [[constants.quick_tag]]
 361         else:
 362             return length
 363
 364     def default_host(host):
 365         if not host[0]:
 366             try:
 367                 import platform
 368                 host_machine = platform.machine()
 369                 if host_machine not in constants.supported_hosts:
 370                     raise ValueError("Invalid host machine")
 371                 return [[host_machine]]
 372             except:
 373                 return [[constants.host_x86_64_tag]]
 374         else:
 375             return host
 376
 377     def compile_tag_regex(positional_tags):
 378         if not positional_tags:
 379             return positional_tags
 380         else:
 381             new_positional_tags_list = []
 382             positional_tags = positional_tags[0]
 383
 384             for flag, regex in positional_tags:
 385                 if flag == 'exclude_tags':
 386                     tag_regex = TagRegex(False, regex)
 387                 elif flag  == 'include_tags':
 388                     tag_regex = TagRegex(True, regex)
 389                 else:
 390                     raise ValueError('Unsupported flag.')
 391                 new_positional_tags_list.append(tag_regex)
 392
 393             return (new_positional_tags_list,)
 394
 395     config._add_post_processor('build_dir', set_default_build_dir)
 396     config._add_post_processor('verbose', fix_verbosity_hack)
 397     config._add_post_processor('isa', default_isa)
 398     config._add_post_processor('variant', default_variant)
 399     config._add_post_processor('length', default_length)
 400     config._add_post_processor('host', default_host)
 401     config._add_post_processor('threads', threads_as_int)
 402     config._add_post_processor('test_threads', test_threads_as_int)
 403     config._add_post_processor(StorePositionalTagsAction.position_kword,
 404                                compile_tag_regex)
 405 class Argument(object):
 406     '''
 407     Class represents a cli argument/flag for a argparse parser.
 408
 409     :attr name: The long name of this object that will be stored in the arg
 410         output by the final parser.
 411     '''
 412     def __init__(self, *flags, **kwargs):
 413         self.flags = flags
 414         self.kwargs = kwargs
 415
 416         if len(flags) == 0:
 417             raise ValueError("Need at least one argument.")
 418         elif 'dest' in kwargs:
 419             self.name = kwargs['dest']
 420         elif len(flags) > 1 or flags[0].startswith('-'):
 421             for flag in flags:
 422                 if not flag.startswith('-'):
 423                     raise ValueError("invalid option string %s: must start"
 424                     "with a character '-'" % flag)
 425
 426                 if flag.startswith('--'):
 427                     if not hasattr(self, 'name'):
 428                         self.name = flag.lstrip('-')
 429
 430         if not hasattr(self, 'name'):
 431             self.name = flags[0].lstrip('-')
 432         self.name = self.name.replace('-', '_')
 433
 434     def add_to(self, parser):
 435         '''Add this argument to the given parser.'''
 436         parser.add_argument(*self.flags, **self.kwargs)
 437
 438     def copy(self):
 439         '''Copy this argument so you might modify any of its kwargs.'''
 440         return copy.deepcopy(self)
 441
 442
 443 class _StickyInt:
 444     '''
 445     A class that is used to cheat the verbosity count incrementer by
 446     pretending to be an int. This makes the int stay on the heap and eat other
 447     real numbers when they are added to it.
 448
 449     We use this so we can allow the verbose flag to be provided before or after
 450     the subcommand. This likely has no utility outside of this use case.
 451     '''
 452     def __init__(self, val=0):
 453         self.val = val
 454         self.type = int
 455     def __add__(self, other):
 456         self.val += other
 457         return self
 458
 459 common_args = NotImplemented
 460
 461 class StorePositionAction(argparse.Action):
 462     '''Base class for classes wishing to create namespaces where
 463     arguments are stored in the order provided via the command line.
 464     '''
 465     position_kword = 'positional'
 466
 467     def __call__(self, parser, namespace, values, option_string=None):
 468         if not self.position_kword in namespace:
 469             setattr(namespace, self.position_kword, [])
 470         previous = getattr(namespace, self.position_kword)
 471         previous.append((self.dest, values))
 472         setattr(namespace, self.position_kword, previous)
 473
 474 class StorePositionalTagsAction(StorePositionAction):
 475     position_kword = 'tag_filters'
 476
 477 def define_common_args(config):
 478     '''
 479     Common args are arguments which are likely to be simular between different
 480     subcommands, so they are available to all by placing their definitions
 481     here.
 482     '''
 483     global common_args
 484
 485     # A list of common arguments/flags used across cli parsers.
 486     common_args = [
 487         Argument(
 488             'directory',
 489             nargs='?',
 490             default=os.getcwd(),
 491             help='Directory to start searching for tests in'),
 492         Argument(
 493             '--exclude-tags',
 494             action=StorePositionalTagsAction,
 495             help='A tag comparison used to select tests.'),
 496         Argument(
 497             '--include-tags',
 498             action=StorePositionalTagsAction,
 499             help='A tag comparison used to select tests.'),
 500         Argument(
 501             '--isa',
 502             action='append',
 503             default=[],
 504             help="Only tests that are valid with one of these ISAs. "
 505                  "Comma separated."),
 506         Argument(
 507             '--variant',
 508             action='append',
 509             default=[],
 510             help="Only tests that are valid with one of these binary variants"
 511                  "(e.g., opt, debug). Comma separated."),
 512         Argument(
 513             '--length',
 514             action='append',
 515             default=[],
 516             help="Only tests that are one of these lengths. Comma separated."),
 517         Argument(
 518             '--host',
 519             action='append',
 520             default=[],
 521             help="Only tests that are meant to runnable on the selected host"),
 522         Argument(
 523             '--uid',
 524             action='store',
 525             default=None,
 526             help='UID of a specific test item to run.'),
 527         Argument(
 528             '--build-dir',
 529             action='store',
 530             help='Build directory for SCons'),
 531         Argument(
 532             '--base-dir',
 533             action='store',
 534             default=config._defaults.base_dir,
 535             help='Directory to change to in order to exec scons.'),
 536         Argument(
 537             '-j', '--threads',
 538             action='store',
 539             default=1,
 540             help='Number of threads to run SCons with.'),
 541         Argument(
 542             '-t', '--test-threads',
 543             action='store',
 544             default=1,
 545             help='Number of threads to spawn to run concurrent tests with.'),
 546         Argument(
 547             '-v',
 548             action='count',
 549             dest='verbose',
 550             default=_StickyInt(),
 551             help='Increase verbosity'),
 552         Argument(
 553             '--config-path',
 554             action='store',
 555             default=os.getcwd(),
 556             help='Path to read a testing.ini config in'
 557         ),
 558         Argument(
 559             '--skip-build',
 560             action='store_true',
 561             default=False,
 562             help='Skip the building component of SCons targets.'
 563         ),
 564         Argument(
 565             '--result-path',
 566             action='store',
 567             help='The path to store results in.'
 568         ),
 569         Argument(
 570             '--bin-path',
 571             action='store',
 572             default=None,
 573             help='Path where binaries are stored (downloaded if not present)'
 574         ),
 575         Argument(
 576             '--resource-url',
 577             action='store',
 578             default=config._defaults.resource_url,
 579             help='The URL where the resources reside.'
 580         ),
 581
 582     ]
 583
 584     # NOTE: There is a limitation which arises due to this format. If you have
 585     # multiple arguments with the same name only the final one in the list
 586     # will be saved.
 587     #
 588     # e.g. if you have a -v argument which increments verbosity level and
 589     # a separate --verbose flag which 'store's verbosity level. the final
 590     # one in the list will be saved.
 591     common_args = AttrDict({arg.name:arg for arg in common_args})
 592
 593 @add_metaclass(abc.ABCMeta)
 594 class ArgParser(object):
 595
 596     def __init__(self, parser):
 597         # Copy public methods of the parser.
 598         for attr in dir(parser):
 599             if not attr.startswith('_'):
 600                 setattr(self, attr, getattr(parser, attr))
 601         self.parser = parser
 602         self.add_argument = self.parser.add_argument
 603
 604         # Argument will be added to all parsers and subparsers.
 605         common_args.verbose.add_to(parser)
 606
 607
 608 class CommandParser(ArgParser):
 609     '''
 610     Main parser which parses command strings and uses those to direct to
 611     a subparser.
 612     '''
 613     def __init__(self):
 614         parser = argparse.ArgumentParser()
 615         super(CommandParser, self).__init__(parser)
 616         self.subparser = self.add_subparsers(dest='command')
 617
 618
 619 class RunParser(ArgParser):
 620     '''
 621     Parser for the \'run\' command.
 622     '''
 623     def __init__(self, subparser):
 624         parser = subparser.add_parser(
 625             'run',
 626             help='''Run Tests.'''
 627         )
 628
 629         super(RunParser, self).__init__(parser)
 630
 631         common_args.uid.add_to(parser)
 632         common_args.skip_build.add_to(parser)
 633         common_args.directory.add_to(parser)
 634         common_args.build_dir.add_to(parser)
 635         common_args.base_dir.add_to(parser)
 636         common_args.bin_path.add_to(parser)
 637         common_args.threads.add_to(parser)
 638         common_args.test_threads.add_to(parser)
 639         common_args.isa.add_to(parser)
 640         common_args.variant.add_to(parser)
 641         common_args.length.add_to(parser)
 642         common_args.host.add_to(parser)
 643         common_args.include_tags.add_to(parser)
 644         common_args.exclude_tags.add_to(parser)
 645
 646
 647 class ListParser(ArgParser):
 648     '''
 649     Parser for the \'list\' command.
 650     '''
 651     def __init__(self, subparser):
 652         parser = subparser.add_parser(
 653             'list',
 654             help='''List and query test metadata.'''
 655         )
 656         super(ListParser, self).__init__(parser)
 657
 658         Argument(
 659             '--suites',
 660             action='store_true',
 661             default=False,
 662             help='List all test suites.'
 663         ).add_to(parser)
 664         Argument(
 665             '--tests',
 666             action='store_true',
 667             default=False,
 668             help='List all test cases.'
 669         ).add_to(parser)
 670         Argument(
 671             '--fixtures',
 672             action='store_true',
 673             default=False,
 674             help='List all fixtures.'
 675         ).add_to(parser)
 676         Argument(
 677             '--all-tags',
 678             action='store_true',
 679             default=False,
 680             help='List all tags.'
 681         ).add_to(parser)
 682         Argument(
 683             '-q',
 684             dest='quiet',
 685             action='store_true',
 686             default=False,
 687             help='Quiet output (machine readable).'
 688         ).add_to(parser)
 689
 690         common_args.directory.add_to(parser)
 691         common_args.bin_path.add_to(parser)
 692         common_args.isa.add_to(parser)
 693         common_args.variant.add_to(parser)
 694         common_args.length.add_to(parser)
 695         common_args.host.add_to(parser)
 696         common_args.include_tags.add_to(parser)
 697         common_args.exclude_tags.add_to(parser)
 698
 699
 700 class RerunParser(ArgParser):
 701     def __init__(self, subparser):
 702         parser = subparser.add_parser(
 703             'rerun',
 704             help='''Rerun failed tests.'''
 705         )
 706         super(RerunParser, self).__init__(parser)
 707
 708         common_args.skip_build.add_to(parser)
 709         common_args.directory.add_to(parser)
 710         common_args.build_dir.add_to(parser)
 711         common_args.base_dir.add_to(parser)
 712         common_args.bin_path.add_to(parser)
 713         common_args.threads.add_to(parser)
 714         common_args.test_threads.add_to(parser)
 715         common_args.isa.add_to(parser)
 716         common_args.variant.add_to(parser)
 717         common_args.length.add_to(parser)
 718         common_args.host.add_to(parser)
 719
 720 config = _Config()
 721 define_constants(config.constants)
 722
 723 # Constants are directly exposed and available once this module is created.
 724 # All constants MUST be defined before this point.
 725 config.constants = FrozenAttrDict(config.constants.__dict__)
 726 constants = config.constants
 727
 728 '''
 729 This config object is the singleton config object available throughout the
 730 framework.
 731 '''
 732 def initialize_config():
 733     '''
 734     Parse the commandline arguments and setup the config varibles.
 735     '''
 736     global config
 737
 738     # Setup constants and defaults
 739     define_defaults(config._defaults)
 740     define_post_processors(config)
 741     define_common_args(config)
 742
 743     # Setup parser and subcommands
 744     baseparser = CommandParser()
 745     runparser = RunParser(baseparser.subparser)
 746     listparser = ListParser(baseparser.subparser)
 747     rerunparser = RerunParser(baseparser.subparser)
 748
 749     # Initialize the config by parsing args and running callbacks.
 750     config._init(baseparser)