subopts.append(subo)        return subopts    def printinfo(self):        super(Group, self).printinfo()        print 'config: %s' % self.config.name        print 'options: %s' % [ o.name for o in self._options ]        super(Group, self).printverbose()class Configuration(Data):    def __init__(self, name, desc, **kwargs):        super(Configuration, self).__init__(name, desc, **kwargs)        self._groups = []    def group(self, name, desc, **kwargs):        grp = Group(name, desc, **kwargs)        grp.config = self        grp.number = len(self._groups)        self._groups.append(grp)        return grp    def groups(self, flags=Flags(), sign=True):        if not flags:            return self._groups        return [ grp for grp in self._groups if sign ^ grp.flags.match(flags) ]    def checkchildren(self, kids):        for kid in kids:            if kid.config != self:                raise AttributeError, "child from the wrong configuration"    def sortgroups(self, groups):        groups = [ (grp.number, grp) for grp in groups ]        groups.sort()        return [ grp[1] for grp in groups ]        def options(self, groups = None, checkpoint = False):        if groups is None:            groups = self._groups        self.checkchildren(groups)        groups = self.sortgroups(groups)        if checkpoint:            groups = [ grp for grp in groups if grp.checkpoint ]            optgroups = [ g.options() for g in groups ]        else:            optgroups = [ g.subopts() for g in groups ]        for options in crossproduct(optgroups):            for opt in options:                cpt = opt.group.checkpoint                if not isinstance(cpt, bool) and cpt != opt:                    if checkpoint:                        break                    else:                        yield options            else:                if checkpoint:                    yield options    def checkpoints(self, groups = None):        for options in self.options(groups, True):            yield Job(options)    def jobs(self, groups = None):        for options in self.options(groups, False):            yield Job(options)    def alljobs(self, groups = None):        for options in self.options(groups, True):            yield Job(options)        for options in self.options(groups, False):            yield Job(options)    def find(self, jobname):        for job in self.alljobs():            if job.name == jobname:                return job        else:            raise AttributeError, "job '%s' not found" % jobname    def job(self, options):        self.checkchildren(options)        options = [ (opt.group.number, opt) for opt in options ]        options.sort()        options = [ opt[1] for opt in options ]        job = Job(options)        return job    def printinfo(self):        super(Configuration, self).printinfo()        print 'groups: %s' % [ g.name for g in self._grouips ]        super(Configuration, self).printverbose()def JobFile(jobfile):    from os.path import expanduser, isfile, join as joinpath    filename = expanduser(jobfile)    # Can't find filename in the current path, search sys.path    if not isfile(filename):        for path in sys.path:            testname = joinpath(path, filename)            if isfile(testname):                filename = testname                break        else:            raise AttributeError, \\                  "Could not find file '%s'" % jobfile    data = {}    execfile(filename, data)    if 'conf' not in data:        raise ImportError, 'cannot import name conf from %s' % jobfile    conf = data['conf']    import jobfile    if not isinstance(conf, Configuration):        raise AttributeError, \\              'conf in jobfile: %s (%s) is not type %s' % \\              (jobfile, type(conf), Configuration)    return confif __name__ == '__main__':    from jobfile import *    import sys    usage = 'Usage: %s [-b] [-c] [-v] <jobfile>' % sys.argv[0]    try:        import getopt        opts, args = getopt.getopt(sys.argv[1:], '-bcv')    except getopt.GetoptError:        sys.exit(usage)    if len(args) != 1:        raise AttributeError, usage    both = False    checkpoint = False    verbose = False    for opt,arg in opts:        if opt == '-b':            both = True            checkpoint = True        if opt == '-c':            checkpoint = True        if opt == '-v':            verbose = True    jobfile = args[0]    conf = JobFile(jobfile)    if both:        gen = conf.alljobs()    elif checkpoint:        gen = conf.checkpoints()    else:        gen = conf.jobs()            for job in gen:        if not verbose:            cpt = ''            if job.checkpoint:                cpt = job.checkpoint.name            print job.name, cpt        else:            job.printinfo()''')AddModule(['m5'], '__init__', 'py', 'm5/python/m5/__init__.py', '''\# Copyright (c) 2005# The Regents of The University of Michigan# All Rights Reserved## This code is part of the M5 simulator, developed by Nathan Binkert,# Erik Hallnor, Steve Raasch, and Steve Reinhardt, with contributions# from Ron Dreslinski, Dave Greene, Lisa Hsu, Kevin Lim, Ali Saidi,# and Andrew Schultz.## Permission is granted to use, copy, create derivative works and# redistribute this software and such derivative works for any# purpose, so long as the copyright notice above, this grant of# permission, and the disclaimer below appear in all copies made; and# so long as the name of The University of Michigan is not used in any# advertising or publicity pertaining to the use or distribution of# this software without specific, written prior authorization.## THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE# UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND# WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER# EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR# PURPOSE. THE REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE# LIABLE FOR ANY DAMAGES, INCLUDING DIRECT, SPECIAL, INDIRECT,# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM# ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN# IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH# DAMAGES.import sys, os# define this here so we can use it right away if necessarydef panic(string):    print >>sys.stderr, 'panic:', string    sys.exit(1)def m5execfile(f, global_dict):    # copy current sys.path    oldpath = sys.path[:]    # push file's directory onto front of path    sys.path.insert(0, os.path.abspath(os.path.dirname(f)))    execfile(f, global_dict)    # restore original path    sys.path = oldpath# Prepend given directory to system module search path.def AddToPath(path):    # if it's a relative path and we know what directory the current    # python script is in, make the path relative to that directory.    if not os.path.isabs(path) and sys.path[0]:        path = os.path.join(sys.path[0], path)    path = os.path.realpath(path)    # sys.path[0] should always refer to the current script's directory,    # so place the new dir right after that.    sys.path.insert(1, path)# find the m5 compile options: must be specified as a dict in# __main__.m5_build_env.import __main__if not hasattr(__main__, 'm5_build_env'):    panic("__main__ must define m5_build_env")# make a SmartDict out of the build options for our local useimport smartdictbuild_env = smartdict.SmartDict()build_env.update(__main__.m5_build_env)# make a SmartDict out of the OS environment tooenv = smartdict.SmartDict()env.update(os.environ)# import the main m5 config codefrom config import *# import the built-in object definitionsfrom objects import *''')AddModule(['m5'], 'config', 'py', 'm5/python/m5/config.py', '''\# Copyright (c) 2004, 2005# The Regents of The University of Michigan# All Rights Reserved## This code is part of the M5 simulator, developed by Nathan Binkert,# Erik Hallnor, Steve Raasch, and Steve Reinhardt, with contributions# from Ron Dreslinski, Dave Greene, Lisa Hsu, Kevin Lim, Ali Saidi,# and Andrew Schultz.## Permission is granted to use, copy, create derivative works and# redistribute this software and such derivative works for any# purpose, so long as the copyright notice above, this grant of# permission, and the disclaimer below appear in all copies made; and# so long as the name of The University of Michigan is not used in any# advertising or publicity pertaining to the use or distribution of# this software without specific, written prior authorization.## THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE# UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND# WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER# EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR# PURPOSE. THE REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE# LIABLE FOR ANY DAMAGES, INCLUDING DIRECT, SPECIAL, INDIRECT,# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM# ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN# IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH# DAMAGES.from __future__ import generatorsimport os, re, sys, types, inspectimport m5panic = m5.panicfrom convert import *from multidict import multidictnoDot = Falsetry:    import pydotexcept:    noDot = Trueclass Singleton(type):    def __call__(cls, *args, **kwargs):        if hasattr(cls, '_instance'):            return cls._instance        cls._instance = super(Singleton, cls).__call__(*args, **kwargs)        return cls._instance####################################################################### M5 Python Configuration Utility## The basic idea is to write simple Python programs that build Python# objects corresponding to M5 SimObjects for the desired simulation# configuration.  For now, the Python emits a .ini file that can be# parsed by M5.  In the future, some tighter integration between M5# and the Python interpreter may allow bypassing the .ini file.## Each SimObject class in M5 is represented by a Python class with the# same name.  The Python inheritance tree mirrors the M5 C++ tree# (e.g., SimpleCPU derives from BaseCPU in both cases, and all# SimObjects inherit from a single SimObject base class).  To specify# an instance of an M5 SimObject in a configuration, the user simply# instantiates the corresponding Python object.  The parameters for# that SimObject are given by assigning to attributes of the Python# object, either using keyword assignment in the constructor or in# separate assignment statements.  For example:## cache = BaseCache(size='64KB')# cache.hit_latency = 3# cache.assoc = 8## The magic lies in the mapping of the Python attributes for SimObject# classes to the actual SimObject parameter specifications.  This# allows parameter validity checking in the Python code.  Continuing# the example above, the statements "cache.blurfl=3" or# "cache.assoc='hello'" would both result in runtime errors in Python,# since the BaseCache object has no 'blurfl' parameter and the 'assoc'# parameter requires an integer, respectively.  This magic is done# primarily by overriding the special __setattr__ method that controls# assignment to object attributes.## Once a set of Python objects have been instantiated in a hierarchy,# calling 'instantiate(obj)' (where obj is the root of the hierarchy)# will generate a .ini file.  See simple-4cpu.py for an example# (corresponding to m5-test/simple-4cpu.ini).############################################################################################################################################# ConfigNode/SimObject classes## The Python class hierarchy rooted by ConfigNode (which is the base# class of SimObject, which in turn is the base class of all other M5# SimObject classes) has special attribute behavior.  In general, an# object in this hierarchy has three categories of attribute-like# things:## 1. Regular Python methods and variables.  These must start with an# underscore to be treated normally.## 2. SimObject parameters.  These values are stored as normal Python# attributes, but all assignments to these attributes are checked# against the pre-defined set of parameters stored in the class's# _params dictionary.  Assignments to attributes that do not# correspond to predefined parameters, or that are not of the correct# type, incur runtime errors.## 3. Hierarchy children.  The child nodes of a ConfigNode are stored# in the node's _children dictionary, but can be accessed using the# Python attribute dot-notation (just as they are printed out by the# simulator).  Children cannot be created using attribute assigment;# they must be added by specifying the parent node in the child's# constructor or using the '+=' operator.# The SimObject parameters are the most complex, for a few reasons.# First, both parameter descriptions and parameter values are# inherited.  Thus parameter description lookup must go up the# inheritance chain like normal attribute lookup, but this behavior# must be explicitly coded since the lookup occurs in each class's# _params attribute.  Second, because parameter values can be set# on SimObject classes (to implement default values), the parameter# checking behavior must be enforced on class attribute assignments as# well as instance attribute assignments.  Finally, because we allow# class specialization via inheritance (e.g., see the L1Cache class in# the simple-4cpu.py example), we must do parameter checking even on# class instantiation.  To provide all these features, we use a# metaclass to define most of the SimObject parameter behavior for# this class hierarchy.######################################################################def isSimObject(value):    return isinstance(value, SimObject)