SimObject.py revision 8596
111986Sandreas.sandberg@arm.com# Copyright (c) 2004-2006 The Regents of The University of Michigan
211986Sandreas.sandberg@arm.com# Copyright (c) 2010 Advanced Micro Devices, Inc.
311986Sandreas.sandberg@arm.com# All rights reserved.
411986Sandreas.sandberg@arm.com#
511986Sandreas.sandberg@arm.com# Redistribution and use in source and binary forms, with or without
611986Sandreas.sandberg@arm.com# modification, are permitted provided that the following conditions are
711986Sandreas.sandberg@arm.com# met: redistributions of source code must retain the above copyright
811986Sandreas.sandberg@arm.com# notice, this list of conditions and the following disclaimer;
911986Sandreas.sandberg@arm.com# redistributions in binary form must reproduce the above copyright
1011986Sandreas.sandberg@arm.com# notice, this list of conditions and the following disclaimer in the
1111986Sandreas.sandberg@arm.com# documentation and/or other materials provided with the distribution;
1211986Sandreas.sandberg@arm.com# neither the name of the copyright holders nor the names of its
1311986Sandreas.sandberg@arm.com# contributors may be used to endorse or promote products derived from
1411986Sandreas.sandberg@arm.com# this software without specific prior written permission.
1511986Sandreas.sandberg@arm.com#
1611986Sandreas.sandberg@arm.com# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1711986Sandreas.sandberg@arm.com# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
1811986Sandreas.sandberg@arm.com# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
1911986Sandreas.sandberg@arm.com# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2011986Sandreas.sandberg@arm.com# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2111986Sandreas.sandberg@arm.com# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2211986Sandreas.sandberg@arm.com# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2311986Sandreas.sandberg@arm.com# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2411986Sandreas.sandberg@arm.com# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2511986Sandreas.sandberg@arm.com# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2611986Sandreas.sandberg@arm.com# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2711986Sandreas.sandberg@arm.com#
2811986Sandreas.sandberg@arm.com# Authors: Steve Reinhardt
2911986Sandreas.sandberg@arm.com#          Nathan Binkert
3011986Sandreas.sandberg@arm.com
3111986Sandreas.sandberg@arm.comimport sys
3211986Sandreas.sandberg@arm.comfrom types import FunctionType, MethodType, ModuleType
3311986Sandreas.sandberg@arm.com
3411986Sandreas.sandberg@arm.comtry:
3511986Sandreas.sandberg@arm.com    import pydot
3612037Sandreas.sandberg@arm.comexcept:
3711986Sandreas.sandberg@arm.com    pydot = False
3811986Sandreas.sandberg@arm.com
3911986Sandreas.sandberg@arm.comimport m5
4011986Sandreas.sandberg@arm.comfrom m5.util import *
4111986Sandreas.sandberg@arm.com
4211986Sandreas.sandberg@arm.com# Have to import params up top since Param is referenced on initial
4311986Sandreas.sandberg@arm.com# load (when SimObject class references Param to create a class
4411986Sandreas.sandberg@arm.com# variable, the 'name' param)...
4511986Sandreas.sandberg@arm.comfrom m5.params import *
4611986Sandreas.sandberg@arm.com# There are a few things we need that aren't in params.__all__ since
4711986Sandreas.sandberg@arm.com# normal users don't need them
4811986Sandreas.sandberg@arm.comfrom m5.params import ParamDesc, VectorParamDesc, \
4912037Sandreas.sandberg@arm.com     isNullPointer, SimObjectVector
5012037Sandreas.sandberg@arm.com
5112037Sandreas.sandberg@arm.comfrom m5.proxy import *
5212037Sandreas.sandberg@arm.comfrom m5.proxy import isproxy
5312037Sandreas.sandberg@arm.com
5412037Sandreas.sandberg@arm.com#####################################################################
5511986Sandreas.sandberg@arm.com#
5611986Sandreas.sandberg@arm.com# M5 Python Configuration Utility
5711986Sandreas.sandberg@arm.com#
5811986Sandreas.sandberg@arm.com# The basic idea is to write simple Python programs that build Python
5911986Sandreas.sandberg@arm.com# objects corresponding to M5 SimObjects for the desired simulation
6012391Sjason@lowepower.com# configuration.  For now, the Python emits a .ini file that can be
6111986Sandreas.sandberg@arm.com# parsed by M5.  In the future, some tighter integration between M5
6212391Sjason@lowepower.com# and the Python interpreter may allow bypassing the .ini file.
6312391Sjason@lowepower.com#
6412391Sjason@lowepower.com# Each SimObject class in M5 is represented by a Python class with the
6511986Sandreas.sandberg@arm.com# same name.  The Python inheritance tree mirrors the M5 C++ tree
6611986Sandreas.sandberg@arm.com# (e.g., SimpleCPU derives from BaseCPU in both cases, and all
6711986Sandreas.sandberg@arm.com# SimObjects inherit from a single SimObject base class).  To specify
6811986Sandreas.sandberg@arm.com# an instance of an M5 SimObject in a configuration, the user simply
6911986Sandreas.sandberg@arm.com# instantiates the corresponding Python object.  The parameters for
7011986Sandreas.sandberg@arm.com# that SimObject are given by assigning to attributes of the Python
7111986Sandreas.sandberg@arm.com# object, either using keyword assignment in the constructor or in
7211986Sandreas.sandberg@arm.com# separate assignment statements.  For example:
7311986Sandreas.sandberg@arm.com#
7411986Sandreas.sandberg@arm.com# cache = BaseCache(size='64KB')
7511986Sandreas.sandberg@arm.com# cache.hit_latency = 3
7611986Sandreas.sandberg@arm.com# cache.assoc = 8
7711986Sandreas.sandberg@arm.com#
7811986Sandreas.sandberg@arm.com# The magic lies in the mapping of the Python attributes for SimObject
7911986Sandreas.sandberg@arm.com# classes to the actual SimObject parameter specifications.  This
8011986Sandreas.sandberg@arm.com# allows parameter validity checking in the Python code.  Continuing
8111986Sandreas.sandberg@arm.com# the example above, the statements "cache.blurfl=3" or
8211986Sandreas.sandberg@arm.com# "cache.assoc='hello'" would both result in runtime errors in Python,
8312037Sandreas.sandberg@arm.com# since the BaseCache object has no 'blurfl' parameter and the 'assoc'
8411986Sandreas.sandberg@arm.com# parameter requires an integer, respectively.  This magic is done
8511986Sandreas.sandberg@arm.com# primarily by overriding the special __setattr__ method that controls
8611986Sandreas.sandberg@arm.com# assignment to object attributes.
8711986Sandreas.sandberg@arm.com#
8811986Sandreas.sandberg@arm.com# Once a set of Python objects have been instantiated in a hierarchy,
8911986Sandreas.sandberg@arm.com# calling 'instantiate(obj)' (where obj is the root of the hierarchy)
9011986Sandreas.sandberg@arm.com# will generate a .ini file.
9111986Sandreas.sandberg@arm.com#
9211986Sandreas.sandberg@arm.com#####################################################################
9311986Sandreas.sandberg@arm.com
9411986Sandreas.sandberg@arm.com# list of all SimObject classes
9511986Sandreas.sandberg@arm.comallClasses = {}
9611986Sandreas.sandberg@arm.com
9711986Sandreas.sandberg@arm.com# dict to look up SimObjects based on path
9812391Sjason@lowepower.cominstanceDict = {}
9912391Sjason@lowepower.com
10011986Sandreas.sandberg@arm.comdef public_value(key, value):
10111986Sandreas.sandberg@arm.com    return key.startswith('_') or \
10212391Sjason@lowepower.com               isinstance(value, (FunctionType, MethodType, ModuleType,
10311986Sandreas.sandberg@arm.com                                  classmethod, type))
10411986Sandreas.sandberg@arm.com
10511986Sandreas.sandberg@arm.com# The metaclass for SimObject.  This class controls how new classes
10611986Sandreas.sandberg@arm.com# that derive from SimObject are instantiated, and provides inherited
10711986Sandreas.sandberg@arm.com# class behavior (just like a class controls how instances of that
10811986Sandreas.sandberg@arm.com# class are instantiated, and provides inherited instance behavior).
10911986Sandreas.sandberg@arm.comclass MetaSimObject(type):
11011986Sandreas.sandberg@arm.com    # Attributes that can be set only at initialization time
11111986Sandreas.sandberg@arm.com    init_keywords = { 'abstract' : bool,
11211986Sandreas.sandberg@arm.com                      'cxx_class' : str,
11311986Sandreas.sandberg@arm.com                      'cxx_type' : str,
11412391Sjason@lowepower.com                      'type' : str }
11512391Sjason@lowepower.com    # Attributes that can be set any time
11612391Sjason@lowepower.com    keywords = { 'check' : FunctionType }
11712391Sjason@lowepower.com
11812391Sjason@lowepower.com    # __new__ is called before __init__, and is where the statements
11911986Sandreas.sandberg@arm.com    # in the body of the class definition get loaded into the class's
12011986Sandreas.sandberg@arm.com    # __dict__.  We intercept this to filter out parameter & port assignments
12112391Sjason@lowepower.com    # and only allow "private" attributes to be passed to the base
12211986Sandreas.sandberg@arm.com    # __new__ (starting with underscore).
12311986Sandreas.sandberg@arm.com    def __new__(mcls, name, bases, dict):
12411986Sandreas.sandberg@arm.com        assert name not in allClasses, "SimObject %s already present" % name
12511986Sandreas.sandberg@arm.com
12611986Sandreas.sandberg@arm.com        # Copy "private" attributes, functions, and classes to the
12711986Sandreas.sandberg@arm.com        # official dict.  Everything else goes in _init_dict to be
12811986Sandreas.sandberg@arm.com        # filtered in __init__.
12911986Sandreas.sandberg@arm.com        cls_dict = {}
13011986Sandreas.sandberg@arm.com        value_dict = {}
13111986Sandreas.sandberg@arm.com        for key,val in dict.items():
13211986Sandreas.sandberg@arm.com            if public_value(key, val):
13311986Sandreas.sandberg@arm.com                cls_dict[key] = val
13411986Sandreas.sandberg@arm.com            else:
13511986Sandreas.sandberg@arm.com                # must be a param/port setting
13611986Sandreas.sandberg@arm.com                value_dict[key] = val
13711986Sandreas.sandberg@arm.com        if 'abstract' not in value_dict:
13811986Sandreas.sandberg@arm.com            value_dict['abstract'] = False
13911986Sandreas.sandberg@arm.com        cls_dict['_value_dict'] = value_dict
14011986Sandreas.sandberg@arm.com        cls = super(MetaSimObject, mcls).__new__(mcls, name, bases, cls_dict)
14111986Sandreas.sandberg@arm.com        if 'type' in value_dict:
14211986Sandreas.sandberg@arm.com            allClasses[name] = cls
14311986Sandreas.sandberg@arm.com        return cls
14411986Sandreas.sandberg@arm.com
14511986Sandreas.sandberg@arm.com    # subclass initialization
14611986Sandreas.sandberg@arm.com    def __init__(cls, name, bases, dict):
14711986Sandreas.sandberg@arm.com        # calls type.__init__()... I think that's a no-op, but leave
14811986Sandreas.sandberg@arm.com        # it here just in case it's not.
14911986Sandreas.sandberg@arm.com        super(MetaSimObject, cls).__init__(name, bases, dict)
15011986Sandreas.sandberg@arm.com
15111986Sandreas.sandberg@arm.com        # initialize required attributes
15211986Sandreas.sandberg@arm.com
15311986Sandreas.sandberg@arm.com        # class-only attributes
15412037Sandreas.sandberg@arm.com        cls._params = multidict() # param descriptions
15511986Sandreas.sandberg@arm.com        cls._ports = multidict()  # port descriptions
15611986Sandreas.sandberg@arm.com
15711986Sandreas.sandberg@arm.com        # class or instance attributes
15811986Sandreas.sandberg@arm.com        cls._values = multidict()   # param values
15911986Sandreas.sandberg@arm.com        cls._children = multidict() # SimObject children
16011986Sandreas.sandberg@arm.com        cls._port_refs = multidict() # port ref objects
16111986Sandreas.sandberg@arm.com        cls._instantiated = False # really instantiated, cloned, or subclassed
16211986Sandreas.sandberg@arm.com
16311986Sandreas.sandberg@arm.com        # We don't support multiple inheritance.  If you want to, you
16411986Sandreas.sandberg@arm.com        # must fix multidict to deal with it properly.
16511986Sandreas.sandberg@arm.com        if len(bases) > 1:
16611986Sandreas.sandberg@arm.com            raise TypeError, "SimObjects do not support multiple inheritance"
16711986Sandreas.sandberg@arm.com
16811986Sandreas.sandberg@arm.com        base = bases[0]
16911986Sandreas.sandberg@arm.com
17011986Sandreas.sandberg@arm.com        # Set up general inheritance via multidicts.  A subclass will
17111986Sandreas.sandberg@arm.com        # inherit all its settings from the base class.  The only time
17211986Sandreas.sandberg@arm.com        # the following is not true is when we define the SimObject
17311986Sandreas.sandberg@arm.com        # class itself (in which case the multidicts have no parent).
17411986Sandreas.sandberg@arm.com        if isinstance(base, MetaSimObject):
17512037Sandreas.sandberg@arm.com            cls._base = base
17612037Sandreas.sandberg@arm.com            cls._params.parent = base._params
17712037Sandreas.sandberg@arm.com            cls._ports.parent = base._ports
17812037Sandreas.sandberg@arm.com            cls._values.parent = base._values
17911986Sandreas.sandberg@arm.com            cls._children.parent = base._children
18011986Sandreas.sandberg@arm.com            cls._port_refs.parent = base._port_refs
18111986Sandreas.sandberg@arm.com            # mark base as having been subclassed
18211986Sandreas.sandberg@arm.com            base._instantiated = True
18311986Sandreas.sandberg@arm.com        else:
18411986Sandreas.sandberg@arm.com            cls._base = None
18511986Sandreas.sandberg@arm.com
18611986Sandreas.sandberg@arm.com        # default keyword values
18711986Sandreas.sandberg@arm.com        if 'type' in cls._value_dict:
18811986Sandreas.sandberg@arm.com            if 'cxx_class' not in cls._value_dict:
18911986Sandreas.sandberg@arm.com                cls._value_dict['cxx_class'] = cls._value_dict['type']
19011986Sandreas.sandberg@arm.com
19111986Sandreas.sandberg@arm.com            cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class']
19212037Sandreas.sandberg@arm.com
19312391Sjason@lowepower.com        # Now process the _value_dict items.  They could be defining
19412037Sandreas.sandberg@arm.com        # new (or overriding existing) parameters or ports, setting
19511986Sandreas.sandberg@arm.com        # class keywords (e.g., 'abstract'), or setting parameter
19612037Sandreas.sandberg@arm.com        # values or port bindings.  The first 3 can only be set when
19712037Sandreas.sandberg@arm.com        # the class is defined, so we handle them here.  The others
19812037Sandreas.sandberg@arm.com        # can be set later too, so just emulate that by calling
19912037Sandreas.sandberg@arm.com        # setattr().
20011986Sandreas.sandberg@arm.com        for key,val in cls._value_dict.items():
20112391Sjason@lowepower.com            # param descriptions
20212391Sjason@lowepower.com            if isinstance(val, ParamDesc):
20312391Sjason@lowepower.com                cls._new_param(key, val)
20412391Sjason@lowepower.com
20512391Sjason@lowepower.com            # port objects
20612391Sjason@lowepower.com            elif isinstance(val, Port):
20712391Sjason@lowepower.com                cls._new_port(key, val)
20811986Sandreas.sandberg@arm.com
20911986Sandreas.sandberg@arm.com            # init-time-only keywords
21011986Sandreas.sandberg@arm.com            elif cls.init_keywords.has_key(key):
21111986Sandreas.sandberg@arm.com                cls._set_keyword(key, val, cls.init_keywords[key])
21211986Sandreas.sandberg@arm.com
21311986Sandreas.sandberg@arm.com            # default: use normal path (ends up in __setattr__)
21411986Sandreas.sandberg@arm.com            else:
21511986Sandreas.sandberg@arm.com                setattr(cls, key, val)
21611986Sandreas.sandberg@arm.com
21711986Sandreas.sandberg@arm.com    def _set_keyword(cls, keyword, val, kwtype):
21811986Sandreas.sandberg@arm.com        if not isinstance(val, kwtype):
21911986Sandreas.sandberg@arm.com            raise TypeError, 'keyword %s has bad type %s (expecting %s)' % \
22011986Sandreas.sandberg@arm.com                  (keyword, type(val), kwtype)
22111986Sandreas.sandberg@arm.com        if isinstance(val, FunctionType):
22211986Sandreas.sandberg@arm.com            val = classmethod(val)
22311986Sandreas.sandberg@arm.com        type.__setattr__(cls, keyword, val)
22411986Sandreas.sandberg@arm.com
22511986Sandreas.sandberg@arm.com    def _new_param(cls, name, pdesc):
22611986Sandreas.sandberg@arm.com        # each param desc should be uniquely assigned to one variable
22711986Sandreas.sandberg@arm.com        assert(not hasattr(pdesc, 'name'))
22811986Sandreas.sandberg@arm.com        pdesc.name = name
22911986Sandreas.sandberg@arm.com        cls._params[name] = pdesc
23011986Sandreas.sandberg@arm.com        if hasattr(pdesc, 'default'):
23111986Sandreas.sandberg@arm.com            cls._set_param(name, pdesc.default, pdesc)
23211986Sandreas.sandberg@arm.com
23311986Sandreas.sandberg@arm.com    def _set_param(cls, name, value, param):
23411986Sandreas.sandberg@arm.com        assert(param.name == name)
23511986Sandreas.sandberg@arm.com        try:
23611986Sandreas.sandberg@arm.com            value = param.convert(value)
23711986Sandreas.sandberg@arm.com        except Exception, e:
23811986Sandreas.sandberg@arm.com            msg = "%s\nError setting param %s.%s to %s\n" % \
23911986Sandreas.sandberg@arm.com                  (e, cls.__name__, name, value)
24011986Sandreas.sandberg@arm.com            e.args = (msg, )
24111986Sandreas.sandberg@arm.com            raise
24212391Sjason@lowepower.com        cls._values[name] = value
24311986Sandreas.sandberg@arm.com        # if param value is a SimObject, make it a child too, so that
24412391Sjason@lowepower.com        # it gets cloned properly when the class is instantiated
24511986Sandreas.sandberg@arm.com        if isSimObjectOrVector(value) and not value.has_parent():
24612391Sjason@lowepower.com            cls._add_cls_child(name, value)
24712391Sjason@lowepower.com
24812391Sjason@lowepower.com    def _add_cls_child(cls, name, child):
24911986Sandreas.sandberg@arm.com        # It's a little funky to have a class as a parent, but these
25011986Sandreas.sandberg@arm.com        # objects should never be instantiated (only cloned, which
25111986Sandreas.sandberg@arm.com        # clears the parent pointer), and this makes it clear that the
25211986Sandreas.sandberg@arm.com        # object is not an orphan and can provide better error
25311986Sandreas.sandberg@arm.com        # messages.
25411986Sandreas.sandberg@arm.com        child.set_parent(cls, name)
25511986Sandreas.sandberg@arm.com        cls._children[name] = child
25611986Sandreas.sandberg@arm.com
25711986Sandreas.sandberg@arm.com    def _new_port(cls, name, port):
25811986Sandreas.sandberg@arm.com        # each port should be uniquely assigned to one variable
25911986Sandreas.sandberg@arm.com        assert(not hasattr(port, 'name'))
26011986Sandreas.sandberg@arm.com        port.name = name
26111986Sandreas.sandberg@arm.com        cls._ports[name] = port
26211986Sandreas.sandberg@arm.com        if hasattr(port, 'default'):
26311986Sandreas.sandberg@arm.com            cls._cls_get_port_ref(name).connect(port.default)
26411986Sandreas.sandberg@arm.com
26511986Sandreas.sandberg@arm.com    # same as _get_port_ref, effectively, but for classes
26611986Sandreas.sandberg@arm.com    def _cls_get_port_ref(cls, attr):
26711986Sandreas.sandberg@arm.com        # Return reference that can be assigned to another port
26811986Sandreas.sandberg@arm.com        # via __setattr__.  There is only ever one reference
26911986Sandreas.sandberg@arm.com        # object per port, but we create them lazily here.
27011986Sandreas.sandberg@arm.com        ref = cls._port_refs.get(attr)
27111986Sandreas.sandberg@arm.com        if not ref:
27211986Sandreas.sandberg@arm.com            ref = cls._ports[attr].makeRef(cls)
27311986Sandreas.sandberg@arm.com            cls._port_refs[attr] = ref
27411986Sandreas.sandberg@arm.com        return ref
27511986Sandreas.sandberg@arm.com
27611986Sandreas.sandberg@arm.com    # Set attribute (called on foo.attr = value when foo is an
27711986Sandreas.sandberg@arm.com    # instance of class cls).
27811986Sandreas.sandberg@arm.com    def __setattr__(cls, attr, value):
27911986Sandreas.sandberg@arm.com        # normal processing for private attributes
28011986Sandreas.sandberg@arm.com        if public_value(attr, value):
28111986Sandreas.sandberg@arm.com            type.__setattr__(cls, attr, value)
28211986Sandreas.sandberg@arm.com            return
28311986Sandreas.sandberg@arm.com
28411986Sandreas.sandberg@arm.com        if cls.keywords.has_key(attr):
28511986Sandreas.sandberg@arm.com            cls._set_keyword(attr, value, cls.keywords[attr])
28611986Sandreas.sandberg@arm.com            return
28712391Sjason@lowepower.com
28811986Sandreas.sandberg@arm.com        if cls._ports.has_key(attr):
28911986Sandreas.sandberg@arm.com            cls._cls_get_port_ref(attr).connect(value)
29011986Sandreas.sandberg@arm.com            return
29111986Sandreas.sandberg@arm.com
29211986Sandreas.sandberg@arm.com        if isSimObjectOrSequence(value) and cls._instantiated:
29311986Sandreas.sandberg@arm.com            raise RuntimeError, \
29411986Sandreas.sandberg@arm.com                  "cannot set SimObject parameter '%s' after\n" \
29512037Sandreas.sandberg@arm.com                  "    class %s has been instantiated or subclassed" \
29612037Sandreas.sandberg@arm.com                  % (attr, cls.__name__)
29712037Sandreas.sandberg@arm.com
29812037Sandreas.sandberg@arm.com        # check for param
29912037Sandreas.sandberg@arm.com        param = cls._params.get(attr)
30012037Sandreas.sandberg@arm.com        if param:
30112037Sandreas.sandberg@arm.com            cls._set_param(attr, value, param)
30212037Sandreas.sandberg@arm.com            return
30312037Sandreas.sandberg@arm.com
30412037Sandreas.sandberg@arm.com        if isSimObjectOrSequence(value):
30512037Sandreas.sandberg@arm.com            # If RHS is a SimObject, it's an implicit child assignment.
30612037Sandreas.sandberg@arm.com            cls._add_cls_child(attr, coerceSimObjectOrVector(value))
30712037Sandreas.sandberg@arm.com            return
30812037Sandreas.sandberg@arm.com
30912037Sandreas.sandberg@arm.com        # no valid assignment... raise exception
31012037Sandreas.sandberg@arm.com        raise AttributeError, \
31112037Sandreas.sandberg@arm.com              "Class %s has no parameter \'%s\'" % (cls.__name__, attr)
31212391Sjason@lowepower.com
31312391Sjason@lowepower.com    def __getattr__(cls, attr):
31412391Sjason@lowepower.com        if attr == 'cxx_class_path':
31512037Sandreas.sandberg@arm.com            return cls.cxx_class.split('::')
31612037Sandreas.sandberg@arm.com
31712037Sandreas.sandberg@arm.com        if attr == 'cxx_class_name':
31812037Sandreas.sandberg@arm.com            return cls.cxx_class_path[-1]
31912037Sandreas.sandberg@arm.com
32012391Sjason@lowepower.com        if attr == 'cxx_namespaces':
32112391Sjason@lowepower.com            return cls.cxx_class_path[:-1]
32212391Sjason@lowepower.com
32312037Sandreas.sandberg@arm.com        if cls._values.has_key(attr):
32412037Sandreas.sandberg@arm.com            return cls._values[attr]
32512037Sandreas.sandberg@arm.com
32612037Sandreas.sandberg@arm.com        if cls._children.has_key(attr):
32712037Sandreas.sandberg@arm.com            return cls._children[attr]
32812037Sandreas.sandberg@arm.com
32912037Sandreas.sandberg@arm.com        raise AttributeError, \
33012037Sandreas.sandberg@arm.com              "object '%s' has no attribute '%s'" % (cls.__name__, attr)
33112037Sandreas.sandberg@arm.com
33212037Sandreas.sandberg@arm.com    def __str__(cls):
33312037Sandreas.sandberg@arm.com        return cls.__name__
33412037Sandreas.sandberg@arm.com
33512037Sandreas.sandberg@arm.com    # See ParamValue.cxx_predecls for description.
33612037Sandreas.sandberg@arm.com    def cxx_predecls(cls, code):
33712037Sandreas.sandberg@arm.com        code('#include "params/$cls.hh"')
33812037Sandreas.sandberg@arm.com
33912037Sandreas.sandberg@arm.com    # See ParamValue.swig_predecls for description.
34012037Sandreas.sandberg@arm.com    def swig_predecls(cls, code):
34112037Sandreas.sandberg@arm.com        code('%import "python/m5/internal/param_$cls.i"')
34212037Sandreas.sandberg@arm.com
34312037Sandreas.sandberg@arm.com    # Generate the declaration for this object for wrapping with SWIG.
34412037Sandreas.sandberg@arm.com    # Generates code that goes into a SWIG .i file.  Called from
34512037Sandreas.sandberg@arm.com    # src/SConscript.
34612037Sandreas.sandberg@arm.com    def swig_decl(cls, code):
34712037Sandreas.sandberg@arm.com        class_path = cls.cxx_class.split('::')
34812037Sandreas.sandberg@arm.com        classname = class_path[-1]
34912037Sandreas.sandberg@arm.com        namespaces = class_path[:-1]
35012037Sandreas.sandberg@arm.com
35112037Sandreas.sandberg@arm.com        # The 'local' attribute restricts us to the params declared in
35212037Sandreas.sandberg@arm.com        # the object itself, not including inherited params (which
35312037Sandreas.sandberg@arm.com        # will also be inherited from the base class's param struct
35412037Sandreas.sandberg@arm.com        # here).
35512037Sandreas.sandberg@arm.com        params = cls._params.local.values()
35612037Sandreas.sandberg@arm.com
35712037Sandreas.sandberg@arm.com        code('%module(package="m5.internal") param_$cls')
35812037Sandreas.sandberg@arm.com        code()
35912037Sandreas.sandberg@arm.com        code('%{')
36012037Sandreas.sandberg@arm.com        code('#include "params/$cls.hh"')
36112037Sandreas.sandberg@arm.com        for param in params:
36212037Sandreas.sandberg@arm.com            param.cxx_predecls(code)
36312037Sandreas.sandberg@arm.com        code('%}')
36412037Sandreas.sandberg@arm.com        code()
36512037Sandreas.sandberg@arm.com
36612037Sandreas.sandberg@arm.com        for param in params:
367            param.swig_predecls(code)
368
369        code()
370        if cls._base:
371            code('%import "python/m5/internal/param_${{cls._base}}.i"')
372        code()
373
374        for ns in namespaces:
375            code('namespace $ns {')
376
377        if namespaces:
378            code('// avoid name conflicts')
379            sep_string = '_COLONS_'
380            flat_name = sep_string.join(class_path)
381            code('%rename($flat_name) $classname;')
382
383        if cls == SimObject:
384            code('%include "python/swig/sim_object.i"')
385        else:
386            code()
387            code('// stop swig from creating/wrapping default ctor/dtor')
388            code('%nodefault $classname;')
389            code('class $classname')
390            if cls._base:
391                code('    : public ${{cls._base.cxx_class}}')
392            code('{};')
393
394        for ns in reversed(namespaces):
395            code('} // namespace $ns')
396
397        code()
398        code('%include "params/$cls.hh"')
399
400
401    # Generate the C++ declaration (.hh file) for this SimObject's
402    # param struct.  Called from src/SConscript.
403    def cxx_param_decl(cls, code):
404        # The 'local' attribute restricts us to the params declared in
405        # the object itself, not including inherited params (which
406        # will also be inherited from the base class's param struct
407        # here).
408        params = cls._params.local.values()
409        try:
410            ptypes = [p.ptype for p in params]
411        except:
412            print cls, p, p.ptype_str
413            print params
414            raise
415
416        class_path = cls._value_dict['cxx_class'].split('::')
417
418        code('''\
419#ifndef __PARAMS__${cls}__
420#define __PARAMS__${cls}__
421
422''')
423
424        # A forward class declaration is sufficient since we are just
425        # declaring a pointer.
426        for ns in class_path[:-1]:
427            code('namespace $ns {')
428        code('class $0;', class_path[-1])
429        for ns in reversed(class_path[:-1]):
430            code('} // namespace $ns')
431        code()
432
433        for param in params:
434            param.cxx_predecls(code)
435        code()
436
437        if cls._base:
438            code('#include "params/${{cls._base.type}}.hh"')
439            code()
440
441        for ptype in ptypes:
442            if issubclass(ptype, Enum):
443                code('#include "enums/${{ptype.__name__}}.hh"')
444                code()
445
446        # now generate the actual param struct
447        if cls == SimObject:
448            code('#include "sim/sim_object_params.hh"')
449        else:
450            code("struct ${cls}Params")
451            if cls._base:
452                code("    : public ${{cls._base.type}}Params")
453            code("{")
454            if not hasattr(cls, 'abstract') or not cls.abstract:
455                if 'type' in cls.__dict__:
456                    code("    ${{cls.cxx_type}} create();")
457
458            code.indent()
459            for param in params:
460                param.cxx_decl(code)
461            code.dedent()
462            code('};')
463
464        code()
465        code('#endif // __PARAMS__${cls}__')
466        return code
467
468
469
470# The SimObject class is the root of the special hierarchy.  Most of
471# the code in this class deals with the configuration hierarchy itself
472# (parent/child node relationships).
473class SimObject(object):
474    # Specify metaclass.  Any class inheriting from SimObject will
475    # get this metaclass.
476    __metaclass__ = MetaSimObject
477    type = 'SimObject'
478    abstract = True
479
480    # Initialize new instance.  For objects with SimObject-valued
481    # children, we need to recursively clone the classes represented
482    # by those param values as well in a consistent "deep copy"-style
483    # fashion.  That is, we want to make sure that each instance is
484    # cloned only once, and that if there are multiple references to
485    # the same original object, we end up with the corresponding
486    # cloned references all pointing to the same cloned instance.
487    def __init__(self, **kwargs):
488        ancestor = kwargs.get('_ancestor')
489        memo_dict = kwargs.get('_memo')
490        if memo_dict is None:
491            # prepare to memoize any recursively instantiated objects
492            memo_dict = {}
493        elif ancestor:
494            # memoize me now to avoid problems with recursive calls
495            memo_dict[ancestor] = self
496
497        if not ancestor:
498            ancestor = self.__class__
499        ancestor._instantiated = True
500
501        # initialize required attributes
502        self._parent = None
503        self._name = None
504        self._ccObject = None  # pointer to C++ object
505        self._ccParams = None
506        self._instantiated = False # really "cloned"
507
508        # Clone children specified at class level.  No need for a
509        # multidict here since we will be cloning everything.
510        # Do children before parameter values so that children that
511        # are also param values get cloned properly.
512        self._children = {}
513        for key,val in ancestor._children.iteritems():
514            self.add_child(key, val(_memo=memo_dict))
515
516        # Inherit parameter values from class using multidict so
517        # individual value settings can be overridden but we still
518        # inherit late changes to non-overridden class values.
519        self._values = multidict(ancestor._values)
520        # clone SimObject-valued parameters
521        for key,val in ancestor._values.iteritems():
522            val = tryAsSimObjectOrVector(val)
523            if val is not None:
524                self._values[key] = val(_memo=memo_dict)
525
526        # clone port references.  no need to use a multidict here
527        # since we will be creating new references for all ports.
528        self._port_refs = {}
529        for key,val in ancestor._port_refs.iteritems():
530            self._port_refs[key] = val.clone(self, memo_dict)
531        # apply attribute assignments from keyword args, if any
532        for key,val in kwargs.iteritems():
533            setattr(self, key, val)
534
535    # "Clone" the current instance by creating another instance of
536    # this instance's class, but that inherits its parameter values
537    # and port mappings from the current instance.  If we're in a
538    # "deep copy" recursive clone, check the _memo dict to see if
539    # we've already cloned this instance.
540    def __call__(self, **kwargs):
541        memo_dict = kwargs.get('_memo')
542        if memo_dict is None:
543            # no memo_dict: must be top-level clone operation.
544            # this is only allowed at the root of a hierarchy
545            if self._parent:
546                raise RuntimeError, "attempt to clone object %s " \
547                      "not at the root of a tree (parent = %s)" \
548                      % (self, self._parent)
549            # create a new dict and use that.
550            memo_dict = {}
551            kwargs['_memo'] = memo_dict
552        elif memo_dict.has_key(self):
553            # clone already done & memoized
554            return memo_dict[self]
555        return self.__class__(_ancestor = self, **kwargs)
556
557    def _get_port_ref(self, attr):
558        # Return reference that can be assigned to another port
559        # via __setattr__.  There is only ever one reference
560        # object per port, but we create them lazily here.
561        ref = self._port_refs.get(attr)
562        if not ref:
563            ref = self._ports[attr].makeRef(self)
564            self._port_refs[attr] = ref
565        return ref
566
567    def __getattr__(self, attr):
568        if self._ports.has_key(attr):
569            return self._get_port_ref(attr)
570
571        if self._values.has_key(attr):
572            return self._values[attr]
573
574        if self._children.has_key(attr):
575            return self._children[attr]
576
577        # If the attribute exists on the C++ object, transparently
578        # forward the reference there.  This is typically used for
579        # SWIG-wrapped methods such as init(), regStats(),
580        # regFormulas(), resetStats(), startup(), drain(), and
581        # resume().
582        if self._ccObject and hasattr(self._ccObject, attr):
583            return getattr(self._ccObject, attr)
584
585        raise AttributeError, "object '%s' has no attribute '%s'" \
586              % (self.__class__.__name__, attr)
587
588    # Set attribute (called on foo.attr = value when foo is an
589    # instance of class cls).
590    def __setattr__(self, attr, value):
591        # normal processing for private attributes
592        if attr.startswith('_'):
593            object.__setattr__(self, attr, value)
594            return
595
596        if self._ports.has_key(attr):
597            # set up port connection
598            self._get_port_ref(attr).connect(value)
599            return
600
601        if isSimObjectOrSequence(value) and self._instantiated:
602            raise RuntimeError, \
603                  "cannot set SimObject parameter '%s' after\n" \
604                  "    instance been cloned %s" % (attr, `self`)
605
606        param = self._params.get(attr)
607        if param:
608            try:
609                value = param.convert(value)
610            except Exception, e:
611                msg = "%s\nError setting param %s.%s to %s\n" % \
612                      (e, self.__class__.__name__, attr, value)
613                e.args = (msg, )
614                raise
615            self._values[attr] = value
616            # implicitly parent unparented objects assigned as params
617            if isSimObjectOrVector(value) and not value.has_parent():
618                self.add_child(attr, value)
619            return
620
621        # if RHS is a SimObject, it's an implicit child assignment
622        if isSimObjectOrSequence(value):
623            self.add_child(attr, value)
624            return
625
626        # no valid assignment... raise exception
627        raise AttributeError, "Class %s has no parameter %s" \
628              % (self.__class__.__name__, attr)
629
630
631    # this hack allows tacking a '[0]' onto parameters that may or may
632    # not be vectors, and always getting the first element (e.g. cpus)
633    def __getitem__(self, key):
634        if key == 0:
635            return self
636        raise TypeError, "Non-zero index '%s' to SimObject" % key
637
638    # Also implemented by SimObjectVector
639    def clear_parent(self, old_parent):
640        assert self._parent is old_parent
641        self._parent = None
642
643    # Also implemented by SimObjectVector
644    def set_parent(self, parent, name):
645        self._parent = parent
646        self._name = name
647
648    # Also implemented by SimObjectVector
649    def get_name(self):
650        return self._name
651
652    # Also implemented by SimObjectVector
653    def has_parent(self):
654        return self._parent is not None
655
656    # clear out child with given name. This code is not likely to be exercised.
657    # See comment in add_child.
658    def clear_child(self, name):
659        child = self._children[name]
660        child.clear_parent(self)
661        del self._children[name]
662
663    # Add a new child to this object.
664    def add_child(self, name, child):
665        child = coerceSimObjectOrVector(child)
666        if child.has_parent():
667            print "warning: add_child('%s'): child '%s' already has parent" % \
668                  (name, child.get_name())
669        if self._children.has_key(name):
670            # This code path had an undiscovered bug that would make it fail
671            # at runtime. It had been here for a long time and was only
672            # exposed by a buggy script. Changes here will probably not be
673            # exercised without specialized testing.
674            self.clear_child(name)
675        child.set_parent(self, name)
676        self._children[name] = child
677
678    # Take SimObject-valued parameters that haven't been explicitly
679    # assigned as children and make them children of the object that
680    # they were assigned to as a parameter value.  This guarantees
681    # that when we instantiate all the parameter objects we're still
682    # inside the configuration hierarchy.
683    def adoptOrphanParams(self):
684        for key,val in self._values.iteritems():
685            if not isSimObjectVector(val) and isSimObjectSequence(val):
686                # need to convert raw SimObject sequences to
687                # SimObjectVector class so we can call has_parent()
688                val = SimObjectVector(val)
689                self._values[key] = val
690            if isSimObjectOrVector(val) and not val.has_parent():
691                print "warning: %s adopting orphan SimObject param '%s'" \
692                      % (self, key)
693                self.add_child(key, val)
694
695    def path(self):
696        if not self._parent:
697            return '<orphan %s>' % self.__class__
698        ppath = self._parent.path()
699        if ppath == 'root':
700            return self._name
701        return ppath + "." + self._name
702
703    def __str__(self):
704        return self.path()
705
706    def ini_str(self):
707        return self.path()
708
709    def find_any(self, ptype):
710        if isinstance(self, ptype):
711            return self, True
712
713        found_obj = None
714        for child in self._children.itervalues():
715            if isinstance(child, ptype):
716                if found_obj != None and child != found_obj:
717                    raise AttributeError, \
718                          'parent.any matched more than one: %s %s' % \
719                          (found_obj.path, child.path)
720                found_obj = child
721        # search param space
722        for pname,pdesc in self._params.iteritems():
723            if issubclass(pdesc.ptype, ptype):
724                match_obj = self._values[pname]
725                if found_obj != None and found_obj != match_obj:
726                    raise AttributeError, \
727                          'parent.any matched more than one: %s and %s' % (found_obj.path, match_obj.path)
728                found_obj = match_obj
729        return found_obj, found_obj != None
730
731    def find_all(self, ptype):
732        all = {}
733        # search children
734        for child in self._children.itervalues():
735            if isinstance(child, ptype) and not isproxy(child) and \
736               not isNullPointer(child):
737                all[child] = True
738        # search param space
739        for pname,pdesc in self._params.iteritems():
740            if issubclass(pdesc.ptype, ptype):
741                match_obj = self._values[pname]
742                if not isproxy(match_obj) and not isNullPointer(match_obj):
743                    all[match_obj] = True
744        return all.keys(), True
745
746    def unproxy(self, base):
747        return self
748
749    def unproxyParams(self):
750        for param in self._params.iterkeys():
751            value = self._values.get(param)
752            if value != None and isproxy(value):
753                try:
754                    value = value.unproxy(self)
755                except:
756                    print "Error in unproxying param '%s' of %s" % \
757                          (param, self.path())
758                    raise
759                setattr(self, param, value)
760
761        # Unproxy ports in sorted order so that 'append' operations on
762        # vector ports are done in a deterministic fashion.
763        port_names = self._ports.keys()
764        port_names.sort()
765        for port_name in port_names:
766            port = self._port_refs.get(port_name)
767            if port != None:
768                port.unproxy(self)
769
770    def print_ini(self, ini_file):
771        print >>ini_file, '[' + self.path() + ']'       # .ini section header
772
773        instanceDict[self.path()] = self
774
775        if hasattr(self, 'type'):
776            print >>ini_file, 'type=%s' % self.type
777
778        child_names = self._children.keys()
779        child_names.sort()
780        if len(child_names):
781            print >>ini_file, 'children=%s' % \
782                  ' '.join(self._children[n].get_name() for n in child_names)
783
784        param_names = self._params.keys()
785        param_names.sort()
786        for param in param_names:
787            value = self._values.get(param)
788            if value != None:
789                print >>ini_file, '%s=%s' % (param,
790                                             self._values[param].ini_str())
791
792        port_names = self._ports.keys()
793        port_names.sort()
794        for port_name in port_names:
795            port = self._port_refs.get(port_name, None)
796            if port != None:
797                print >>ini_file, '%s=%s' % (port_name, port.ini_str())
798
799        print >>ini_file        # blank line between objects
800
801    def getCCParams(self):
802        if self._ccParams:
803            return self._ccParams
804
805        cc_params_struct = getattr(m5.internal.params, '%sParams' % self.type)
806        cc_params = cc_params_struct()
807        cc_params.pyobj = self
808        cc_params.name = str(self)
809
810        param_names = self._params.keys()
811        param_names.sort()
812        for param in param_names:
813            value = self._values.get(param)
814            if value is None:
815                fatal("%s.%s without default or user set value",
816                      self.path(), param)
817
818            value = value.getValue()
819            if isinstance(self._params[param], VectorParamDesc):
820                assert isinstance(value, list)
821                vec = getattr(cc_params, param)
822                assert not len(vec)
823                for v in value:
824                    vec.append(v)
825            else:
826                setattr(cc_params, param, value)
827
828        port_names = self._ports.keys()
829        port_names.sort()
830        for port_name in port_names:
831            port = self._port_refs.get(port_name, None)
832            if port != None:
833                setattr(cc_params, port_name, port)
834        self._ccParams = cc_params
835        return self._ccParams
836
837    # Get C++ object corresponding to this object, calling C++ if
838    # necessary to construct it.  Does *not* recursively create
839    # children.
840    def getCCObject(self):
841        if not self._ccObject:
842            # Make sure this object is in the configuration hierarchy
843            if not self._parent and not isRoot(self):
844                raise RuntimeError, "Attempt to instantiate orphan node"
845            # Cycles in the configuration hierarchy are not supported. This
846            # will catch the resulting recursion and stop.
847            self._ccObject = -1
848            params = self.getCCParams()
849            self._ccObject = params.create()
850        elif self._ccObject == -1:
851            raise RuntimeError, "%s: Cycle found in configuration hierarchy." \
852                  % self.path()
853        return self._ccObject
854
855    def descendants(self):
856        yield self
857        for child in self._children.itervalues():
858            for obj in child.descendants():
859                yield obj
860
861    # Call C++ to create C++ object corresponding to this object
862    def createCCObject(self):
863        self.getCCParams()
864        self.getCCObject() # force creation
865
866    def getValue(self):
867        return self.getCCObject()
868
869    # Create C++ port connections corresponding to the connections in
870    # _port_refs
871    def connectPorts(self):
872        for portRef in self._port_refs.itervalues():
873            portRef.ccConnect()
874
875    def getMemoryMode(self):
876        if not isinstance(self, m5.objects.System):
877            return None
878
879        return self._ccObject.getMemoryMode()
880
881    def changeTiming(self, mode):
882        if isinstance(self, m5.objects.System):
883            # i don't know if there's a better way to do this - calling
884            # setMemoryMode directly from self._ccObject results in calling
885            # SimObject::setMemoryMode, not the System::setMemoryMode
886            self._ccObject.setMemoryMode(mode)
887
888    def takeOverFrom(self, old_cpu):
889        self._ccObject.takeOverFrom(old_cpu._ccObject)
890
891    # generate output file for 'dot' to display as a pretty graph.
892    # this code is currently broken.
893    def outputDot(self, dot):
894        label = "{%s|" % self.path
895        if isSimObject(self.realtype):
896            label +=  '%s|' % self.type
897
898        if self.children:
899            # instantiate children in same order they were added for
900            # backward compatibility (else we can end up with cpu1
901            # before cpu0).
902            for c in self.children:
903                dot.add_edge(pydot.Edge(self.path,c.path, style="bold"))
904
905        simobjs = []
906        for param in self.params:
907            try:
908                if param.value is None:
909                    raise AttributeError, 'Parameter with no value'
910
911                value = param.value
912                string = param.string(value)
913            except Exception, e:
914                msg = 'exception in %s:%s\n%s' % (self.name, param.name, e)
915                e.args = (msg, )
916                raise
917
918            if isSimObject(param.ptype) and string != "Null":
919                simobjs.append(string)
920            else:
921                label += '%s = %s\\n' % (param.name, string)
922
923        for so in simobjs:
924            label += "|<%s> %s" % (so, so)
925            dot.add_edge(pydot.Edge("%s:%s" % (self.path, so), so,
926                                    tailport="w"))
927        label += '}'
928        dot.add_node(pydot.Node(self.path,shape="Mrecord",label=label))
929
930        # recursively dump out children
931        for c in self.children:
932            c.outputDot(dot)
933
934# Function to provide to C++ so it can look up instances based on paths
935def resolveSimObject(name):
936    obj = instanceDict[name]
937    return obj.getCCObject()
938
939def isSimObject(value):
940    return isinstance(value, SimObject)
941
942def isSimObjectClass(value):
943    return issubclass(value, SimObject)
944
945def isSimObjectVector(value):
946    return isinstance(value, SimObjectVector)
947
948def isSimObjectSequence(value):
949    if not isinstance(value, (list, tuple)) or len(value) == 0:
950        return False
951
952    for val in value:
953        if not isNullPointer(val) and not isSimObject(val):
954            return False
955
956    return True
957
958def isSimObjectOrSequence(value):
959    return isSimObject(value) or isSimObjectSequence(value)
960
961def isRoot(obj):
962    from m5.objects import Root
963    return obj and obj is Root.getInstance()
964
965def isSimObjectOrVector(value):
966    return isSimObject(value) or isSimObjectVector(value)
967
968def tryAsSimObjectOrVector(value):
969    if isSimObjectOrVector(value):
970        return value
971    if isSimObjectSequence(value):
972        return SimObjectVector(value)
973    return None
974
975def coerceSimObjectOrVector(value):
976    value = tryAsSimObjectOrVector(value)
977    if value is None:
978        raise TypeError, "SimObject or SimObjectVector expected"
979    return value
980
981baseClasses = allClasses.copy()
982baseInstances = instanceDict.copy()
983
984def clear():
985    global allClasses, instanceDict
986
987    allClasses = baseClasses.copy()
988    instanceDict = baseInstances.copy()
989
990# __all__ defines the list of symbols that get exported when
991# 'from config import *' is invoked.  Try to keep this reasonably
992# short to avoid polluting other namespaces.
993__all__ = [ 'SimObject' ]
994