+# Copyright (c) 2012 ARM Limited
+# All rights reserved.
+#
+# The license below extends only to copyright in the software and shall
+# not be construed as granting a license to any other intellectual
+# property including but not limited to intellectual property relating
+# to a hardware implementation of the functionality of the software
+# licensed hereunder. You may use the software subject to the license
+# terms below provided that you ensure that this notice is replicated
+# unmodified and in its entirety in all distributions of the software,
+# modified or unmodified, in source code or in binary form.
+#
# Copyright (c) 2004-2006 The Regents of The University of Michigan
# Copyright (c) 2010 Advanced Micro Devices, Inc.
# All rights reserved.
#
# Authors: Steve Reinhardt
# Nathan Binkert
+# Andreas Hansson
import sys
-from types import FunctionType, MethodType
-
-try:
- import pydot
-except:
- pydot = False
+from types import FunctionType, MethodType, ModuleType
import m5
from m5.util import *
# There are a few things we need that aren't in params.__all__ since
# normal users don't need them
from m5.params import ParamDesc, VectorParamDesc, \
- isNullPointer, SimObjectVector
+ isNullPointer, SimObjectVector, Port
from m5.proxy import *
from m5.proxy import isproxy
# dict to look up SimObjects based on path
instanceDict = {}
-def default_cxx_predecls(cls, code):
- code('#include "params/$cls.hh"')
-
-def default_swig_predecls(cls, code):
- code('%import "python/m5/internal/param_$cls.i"')
-
-def default_swig_objdecls(cls, code):
- class_path = cls.cxx_class.split('::')
- classname = class_path[-1]
- namespaces = class_path[:-1]
-
- for ns in namespaces:
- code('namespace $ns {')
-
- if namespaces:
- code('// avoid name conflicts')
- sep_string = '_COLONS_'
- flat_name = sep_string.join(class_path)
- code('%rename($flat_name) $classname;')
-
- code()
- code('// stop swig from creating/wrapping default ctor/dtor')
- code('%nodefault $classname;')
- code('class $classname')
- if cls._base:
- code(' : public ${{cls._base.cxx_class}}')
- code('{};')
-
- for ns in reversed(namespaces):
- code('/* namespace $ns */ }')
+# Did any of the SimObjects lack a header file?
+noCxxHeader = False
def public_value(key, value):
return key.startswith('_') or \
- isinstance(value, (FunctionType, MethodType, classmethod, type))
+ isinstance(value, (FunctionType, MethodType, ModuleType,
+ classmethod, type))
# The metaclass for SimObject. This class controls how new classes
# that derive from SimObject are instantiated, and provides inherited
init_keywords = { 'abstract' : bool,
'cxx_class' : str,
'cxx_type' : str,
- 'cxx_predecls' : MethodType,
- 'swig_objdecls' : MethodType,
- 'swig_predecls' : MethodType,
- 'type' : str }
+ 'cxx_header' : str,
+ 'type' : str,
+ 'cxx_bases' : list }
# Attributes that can be set any time
keywords = { 'check' : FunctionType }
value_dict[key] = val
if 'abstract' not in value_dict:
value_dict['abstract'] = False
+ if 'cxx_bases' not in value_dict:
+ value_dict['cxx_bases'] = []
cls_dict['_value_dict'] = value_dict
cls = super(MetaSimObject, mcls).__new__(mcls, name, bases, cls_dict)
if 'type' in value_dict:
cls._port_refs = multidict() # port ref objects
cls._instantiated = False # really instantiated, cloned, or subclassed
- # We don't support multiple inheritance. If you want to, you
- # must fix multidict to deal with it properly.
- if len(bases) > 1:
- raise TypeError, "SimObjects do not support multiple inheritance"
+ # We don't support multiple inheritance of sim objects. If you want
+ # to, you must fix multidict to deal with it properly. Non sim-objects
+ # are ok, though
+ bTotal = 0
+ for c in bases:
+ if isinstance(c, MetaSimObject):
+ bTotal += 1
+ if bTotal > 1:
+ raise TypeError, "SimObjects do not support multiple inheritance"
base = bases[0]
cls._value_dict['cxx_class'] = cls._value_dict['type']
cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class']
-
- if 'cxx_predecls' not in cls.__dict__:
- m = MethodType(default_cxx_predecls, cls, MetaSimObject)
- setattr(cls, 'cxx_predecls', m)
-
- if 'swig_predecls' not in cls.__dict__:
- m = MethodType(default_swig_predecls, cls, MetaSimObject)
- setattr(cls, 'swig_predecls', m)
- if 'swig_objdecls' not in cls.__dict__:
- m = MethodType(default_swig_objdecls, cls, MetaSimObject)
- setattr(cls, 'swig_objdecls', m)
+ if 'cxx_header' not in cls._value_dict:
+ global noCxxHeader
+ noCxxHeader = True
+ print >> sys.stderr, \
+ "warning: No header file specified for SimObject: %s" % name
+
+ # Export methods are automatically inherited via C++, so we
+ # don't want the method declarations to get inherited on the
+ # python side (and thus end up getting repeated in the wrapped
+ # versions of derived classes). The code below basicallly
+ # suppresses inheritance by substituting in the base (null)
+ # versions of these methods unless a different version is
+ # explicitly supplied.
+ for method_name in ('export_methods', 'export_method_cxx_predecls',
+ 'export_method_swig_predecls'):
+ if method_name not in cls.__dict__:
+ base_method = getattr(MetaSimObject, method_name)
+ m = MethodType(base_method, cls, MetaSimObject)
+ setattr(cls, method_name, m)
# Now process the _value_dict items. They could be defining
# new (or overriding existing) parameters or ports, setting
def _set_param(cls, name, value, param):
assert(param.name == name)
try:
- cls._values[name] = param.convert(value)
+ value = param.convert(value)
except Exception, e:
msg = "%s\nError setting param %s.%s to %s\n" % \
(e, cls.__name__, name, value)
e.args = (msg, )
raise
+ cls._values[name] = value
+ # if param value is a SimObject, make it a child too, so that
+ # it gets cloned properly when the class is instantiated
+ if isSimObjectOrVector(value) and not value.has_parent():
+ cls._add_cls_child(name, value)
+
+ def _add_cls_child(cls, name, child):
+ # It's a little funky to have a class as a parent, but these
+ # objects should never be instantiated (only cloned, which
+ # clears the parent pointer), and this makes it clear that the
+ # object is not an orphan and can provide better error
+ # messages.
+ child.set_parent(cls, name)
+ cls._children[name] = child
def _new_port(cls, name, port):
# each port should be uniquely assigned to one variable
assert(not hasattr(port, 'name'))
port.name = name
cls._ports[name] = port
- if hasattr(port, 'default'):
- cls._cls_get_port_ref(name).connect(port.default)
# same as _get_port_ref, effectively, but for classes
def _cls_get_port_ref(cls, attr):
if isSimObjectOrSequence(value):
# If RHS is a SimObject, it's an implicit child assignment.
- cls._children[attr] = coerceSimObjectOrVector(value)
+ cls._add_cls_child(attr, coerceSimObjectOrVector(value))
return
# no valid assignment... raise exception
def __str__(cls):
return cls.__name__
- def cxx_decl(cls, code):
- # The 'dict' attribute restricts us to the params declared in
+ # See ParamValue.cxx_predecls for description.
+ def cxx_predecls(cls, code):
+ code('#include "params/$cls.hh"')
+
+ # See ParamValue.swig_predecls for description.
+ def swig_predecls(cls, code):
+ code('%import "python/m5/internal/param_$cls.i"')
+
+ # Hook for exporting additional C++ methods to Python via SWIG.
+ # Default is none, override using @classmethod in class definition.
+ def export_methods(cls, code):
+ pass
+
+ # Generate the code needed as a prerequisite for the C++ methods
+ # exported via export_methods() to be compiled in the _wrap.cc
+ # file. Typically generates one or more #include statements. If
+ # any methods are exported, typically at least the C++ header
+ # declaring the relevant SimObject class must be included.
+ def export_method_cxx_predecls(cls, code):
+ pass
+
+ # Generate the code needed as a prerequisite for the C++ methods
+ # exported via export_methods() to be processed by SWIG.
+ # Typically generates one or more %include or %import statements.
+ # If any methods are exported, typically at least the C++ header
+ # declaring the relevant SimObject class must be included.
+ def export_method_swig_predecls(cls, code):
+ pass
+
+ # Generate the declaration for this object for wrapping with SWIG.
+ # Generates code that goes into a SWIG .i file. Called from
+ # src/SConscript.
+ def swig_decl(cls, code):
+ class_path = cls.cxx_class.split('::')
+ classname = class_path[-1]
+ namespaces = class_path[:-1]
+
+ # The 'local' attribute restricts us to the params declared in
# the object itself, not including inherited params (which
# will also be inherited from the base class's param struct
# here).
params = cls._params.local.values()
+ ports = cls._ports.local
+
+ code('%module(package="m5.internal") param_$cls')
+ code()
+ code('%{')
+ code('#include "sim/sim_object.hh"')
+ code('#include "params/$cls.hh"')
+ for param in params:
+ param.cxx_predecls(code)
+ code('#include "${{cls.cxx_header}}"')
+ cls.export_method_cxx_predecls(code)
+ code('''\
+/**
+ * This is a workaround for bug in swig. Prior to gcc 4.6.1 the STL
+ * headers like vector, string, etc. used to automatically pull in
+ * the cstddef header but starting with gcc 4.6.1 they no longer do.
+ * This leads to swig generated a file that does not compile so we
+ * explicitly include cstddef. Additionally, including version 2.0.4,
+ * swig uses ptrdiff_t without the std:: namespace prefix which is
+ * required with gcc 4.6.1. We explicitly provide access to it.
+ */
+#include <cstddef>
+using std::ptrdiff_t;
+''')
+ code('%}')
+ code()
+
+ for param in params:
+ param.swig_predecls(code)
+ cls.export_method_swig_predecls(code)
+
+ code()
+ if cls._base:
+ code('%import "python/m5/internal/param_${{cls._base}}.i"')
+ code()
+
+ for ns in namespaces:
+ code('namespace $ns {')
+
+ if namespaces:
+ code('// avoid name conflicts')
+ sep_string = '_COLONS_'
+ flat_name = sep_string.join(class_path)
+ code('%rename($flat_name) $classname;')
+
+ code()
+ code('// stop swig from creating/wrapping default ctor/dtor')
+ code('%nodefault $classname;')
+ code('class $classname')
+ if cls._base:
+ bases = [ cls._base.cxx_class ] + cls.cxx_bases
+ else:
+ bases = cls.cxx_bases
+ base_first = True
+ for base in bases:
+ if base_first:
+ code(' : public ${{base}}')
+ base_first = False
+ else:
+ code(' , public ${{base}}')
+
+ code('{')
+ code(' public:')
+ cls.export_methods(code)
+ code('};')
+
+ for ns in reversed(namespaces):
+ code('} // namespace $ns')
+
+ code()
+ code('%include "params/$cls.hh"')
+
+
+ # Generate the C++ declaration (.hh file) for this SimObject's
+ # param struct. Called from src/SConscript.
+ def cxx_param_decl(cls, code):
+ # The 'local' attribute restricts us to the params declared in
+ # the object itself, not including inherited params (which
+ # will also be inherited from the base class's param struct
+ # here).
+ params = cls._params.local.values()
+ ports = cls._ports.local
try:
ptypes = [p.ptype for p in params]
except:
code('namespace $ns {')
code('class $0;', class_path[-1])
for ns in reversed(class_path[:-1]):
- code('/* namespace $ns */ }')
+ code('} // namespace $ns')
code()
+ # The base SimObject has a couple of params that get
+ # automatically set from Python without being declared through
+ # the normal Param mechanism; we slip them in here (needed
+ # predecls now, actual declarations below)
+ if cls == SimObject:
+ code('''
+#ifndef PY_VERSION
+struct PyObject;
+#endif
+
+#include <string>
+
+class EventQueue;
+''')
for param in params:
param.cxx_predecls(code)
+ for port in ports.itervalues():
+ port.cxx_predecls(code)
code()
if cls._base:
code('#include "enums/${{ptype.__name__}}.hh"')
code()
- cls.cxx_struct(code, cls._base, params)
-
- code()
- code('#endif // __PARAMS__${cls}__')
- return code
-
- def cxx_struct(cls, code, base, params):
- if cls == SimObject:
- code('#include "sim/sim_object_params.hh"')
- return
-
# now generate the actual param struct
code("struct ${cls}Params")
- if base:
- code(" : public ${{base.type}}Params")
+ if cls._base:
+ code(" : public ${{cls._base.type}}Params")
code("{")
if not hasattr(cls, 'abstract') or not cls.abstract:
if 'type' in cls.__dict__:
code(" ${{cls.cxx_type}} create();")
code.indent()
+ if cls == SimObject:
+ code('''
+ SimObjectParams()
+ {
+ extern EventQueue mainEventQueue;
+ eventq = &mainEventQueue;
+ }
+ virtual ~SimObjectParams() {}
+
+ std::string name;
+ PyObject *pyobj;
+ EventQueue *eventq;
+ ''')
for param in params:
param.cxx_decl(code)
+ for port in ports.itervalues():
+ port.cxx_decl(code)
+
code.dedent()
code('};')
- def swig_decl(cls, code):
- code('''\
-%module $cls
-
-%{
-#include "params/$cls.hh"
-%}
-
-''')
-
- # The 'dict' attribute restricts us to the params declared in
- # the object itself, not including inherited params (which
- # will also be inherited from the base class's param struct
- # here).
- params = cls._params.local.values()
- ptypes = [p.ptype for p in params]
-
- # get all predeclarations
- for param in params:
- param.swig_predecls(code)
code()
+ code('#endif // __PARAMS__${cls}__')
+ return code
- if cls._base:
- code('%import "python/m5/internal/param_${{cls._base.type}}.i"')
- code()
-
- for ptype in ptypes:
- if issubclass(ptype, Enum):
- code('%import "enums/${{ptype.__name__}}.hh"')
- code()
- code('%import "params/${cls}_type.hh"')
- code('%include "params/${cls}.hh"')
# The SimObject class is the root of the special hierarchy. Most of
# the code in this class deals with the configuration hierarchy itself
__metaclass__ = MetaSimObject
type = 'SimObject'
abstract = True
+ cxx_header = "sim/sim_object.hh"
+
+ cxx_bases = [ "Drainable", "Serializable" ]
+
+ @classmethod
+ def export_method_swig_predecls(cls, code):
+ code('''
+%include <std_string.i>
+
+%import "python/swig/drain.i"
+%import "python/swig/serialize.i"
+''')
@classmethod
- def swig_objdecls(cls, code):
- code('%include "python/swig/sim_object.i"')
+ def export_methods(cls, code):
+ code('''
+ void init();
+ void loadState(Checkpoint *cp);
+ void initState();
+ void regStats();
+ void resetStats();
+ void startup();
+''')
# Initialize new instance. For objects with SimObject-valued
# children, we need to recursively clone the classes represented
self._ccParams = None
self._instantiated = False # really "cloned"
+ # Clone children specified at class level. No need for a
+ # multidict here since we will be cloning everything.
+ # Do children before parameter values so that children that
+ # are also param values get cloned properly.
+ self._children = {}
+ for key,val in ancestor._children.iteritems():
+ self.add_child(key, val(_memo=memo_dict))
+
# Inherit parameter values from class using multidict so
# individual value settings can be overridden but we still
# inherit late changes to non-overridden class values.
if val is not None:
self._values[key] = val(_memo=memo_dict)
- # Clone children specified at class level. No need for a
- # multidict here since we will be cloning everything.
- self._children = {}
- for key,val in ancestor._children.iteritems():
- self.add_child(key, val(_memo=memo_dict))
-
# clone port references. no need to use a multidict here
# since we will be creating new references for all ports.
self._port_refs = {}
# If the attribute exists on the C++ object, transparently
# forward the reference there. This is typically used for
# SWIG-wrapped methods such as init(), regStats(),
- # regFormulas(), resetStats(), startup(), drain(), and
+ # resetStats(), startup(), drain(), and
# resume().
if self._ccObject and hasattr(self._ccObject, attr):
return getattr(self._ccObject, attr)
e.args = (msg, )
raise
self._values[attr] = value
+ # implicitly parent unparented objects assigned as params
+ if isSimObjectOrVector(value) and not value.has_parent():
+ self.add_child(attr, value)
return
# if RHS is a SimObject, it's an implicit child assignment
def get_name(self):
return self._name
- # use this rather than directly accessing _parent for symmetry
- # with SimObjectVector
- def get_parent(self):
- return self._parent
+ # Also implemented by SimObjectVector
+ def has_parent(self):
+ return self._parent is not None
- # clear out child with given name
+ # clear out child with given name. This code is not likely to be exercised.
+ # See comment in add_child.
def clear_child(self, name):
child = self._children[name]
child.clear_parent(self)
# Add a new child to this object.
def add_child(self, name, child):
child = coerceSimObjectOrVector(child)
- if child.get_parent():
- raise RuntimeError, \
- "add_child('%s'): child '%s' already has parent '%s'" % \
- (name, child._name, child._parent)
+ if child.has_parent():
+ print "warning: add_child('%s'): child '%s' already has parent" % \
+ (name, child.get_name())
if self._children.has_key(name):
- clear_child(name)
+ # This code path had an undiscovered bug that would make it fail
+ # at runtime. It had been here for a long time and was only
+ # exposed by a buggy script. Changes here will probably not be
+ # exercised without specialized testing.
+ self.clear_child(name)
child.set_parent(self, name)
self._children[name] = child
for key,val in self._values.iteritems():
if not isSimObjectVector(val) and isSimObjectSequence(val):
# need to convert raw SimObject sequences to
- # SimObjectVector class so we can call get_parent()
+ # SimObjectVector class so we can call has_parent()
val = SimObjectVector(val)
self._values[key] = val
- if isSimObjectOrVector(val) and not val.get_parent():
+ if isSimObjectOrVector(val) and not val.has_parent():
+ print "warning: %s adopting orphan SimObject param '%s'" \
+ % (self, key)
self.add_child(key, val)
def path(self):
if not self._parent:
- return '(orphan)'
+ return '<orphan %s>' % self.__class__
ppath = self._parent.path()
if ppath == 'root':
return self._name
found_obj = match_obj
return found_obj, found_obj != None
+ def find_all(self, ptype):
+ all = {}
+ # search children
+ for child in self._children.itervalues():
+ # a child could be a list, so ensure we visit each item
+ if isinstance(child, list):
+ children = child
+ else:
+ children = [child]
+
+ for child in children:
+ if isinstance(child, ptype) and not isproxy(child) and \
+ not isNullPointer(child):
+ all[child] = True
+ if isSimObject(child):
+ # also add results from the child itself
+ child_all, done = child.find_all(ptype)
+ all.update(dict(zip(child_all, [done] * len(child_all))))
+ # search param space
+ for pname,pdesc in self._params.iteritems():
+ if issubclass(pdesc.ptype, ptype):
+ match_obj = self._values[pname]
+ if not isproxy(match_obj) and not isNullPointer(match_obj):
+ all[match_obj] = True
+ return all.keys(), True
+
def unproxy(self, base):
return self
if hasattr(self, 'type'):
print >>ini_file, 'type=%s' % self.type
- child_names = self._children.keys()
- child_names.sort()
- if len(child_names):
+ if len(self._children.keys()):
print >>ini_file, 'children=%s' % \
- ' '.join(self._children[n].get_name() for n in child_names)
+ ' '.join(self._children[n].get_name() \
+ for n in sorted(self._children.keys()))
- param_names = self._params.keys()
- param_names.sort()
- for param in param_names:
+ for param in sorted(self._params.keys()):
value = self._values.get(param)
if value != None:
print >>ini_file, '%s=%s' % (param,
self._values[param].ini_str())
- port_names = self._ports.keys()
- port_names.sort()
- for port_name in port_names:
+ for port_name in sorted(self._ports.keys()):
port = self._port_refs.get(port_name, None)
if port != None:
print >>ini_file, '%s=%s' % (port_name, port.ini_str())
print >>ini_file # blank line between objects
+ # generate a tree of dictionaries expressing all the parameters in the
+ # instantiated system for use by scripts that want to do power, thermal
+ # visualization, and other similar tasks
+ def get_config_as_dict(self):
+ d = attrdict()
+ if hasattr(self, 'type'):
+ d.type = self.type
+ if hasattr(self, 'cxx_class'):
+ d.cxx_class = self.cxx_class
+ # Add the name and path of this object to be able to link to
+ # the stats
+ d.name = self.get_name()
+ d.path = self.path()
+
+ for param in sorted(self._params.keys()):
+ value = self._values.get(param)
+ if value != None:
+ try:
+ # Use native type for those supported by JSON and
+ # strings for everything else. skipkeys=True seems
+ # to not work as well as one would hope
+ if type(self._values[param].value) in \
+ [str, unicode, int, long, float, bool, None]:
+ d[param] = self._values[param].value
+ else:
+ d[param] = str(self._values[param])
+
+ except AttributeError:
+ pass
+
+ for n in sorted(self._children.keys()):
+ child = self._children[n]
+ # Use the name of the attribute (and not get_name()) as
+ # the key in the JSON dictionary to capture the hierarchy
+ # in the Python code that assembled this system
+ d[n] = child.get_config_as_dict()
+
+ for port_name in sorted(self._ports.keys()):
+ port = self._port_refs.get(port_name, None)
+ if port != None:
+ # Represent each port with a dictionary containing the
+ # prominent attributes
+ d[port_name] = port.get_config_as_dict()
+
+ return d
+
def getCCParams(self):
if self._ccParams:
return self._ccParams
for port_name in port_names:
port = self._port_refs.get(port_name, None)
if port != None:
- setattr(cc_params, port_name, port)
+ port_count = len(port)
+ else:
+ port_count = 0
+ setattr(cc_params, 'port_' + port_name + '_connection_count',
+ port_count)
self._ccParams = cc_params
return self._ccParams
for portRef in self._port_refs.itervalues():
portRef.ccConnect()
- def getMemoryMode(self):
- if not isinstance(self, m5.objects.System):
- return None
-
- return self._ccObject.getMemoryMode()
-
- def changeTiming(self, mode):
- if isinstance(self, m5.objects.System):
- # i don't know if there's a better way to do this - calling
- # setMemoryMode directly from self._ccObject results in calling
- # SimObject::setMemoryMode, not the System::setMemoryMode
- self._ccObject.setMemoryMode(mode)
-
- def takeOverFrom(self, old_cpu):
- self._ccObject.takeOverFrom(old_cpu._ccObject)
-
- # generate output file for 'dot' to display as a pretty graph.
- # this code is currently broken.
- def outputDot(self, dot):
- label = "{%s|" % self.path
- if isSimObject(self.realtype):
- label += '%s|' % self.type
-
- if self.children:
- # instantiate children in same order they were added for
- # backward compatibility (else we can end up with cpu1
- # before cpu0).
- for c in self.children:
- dot.add_edge(pydot.Edge(self.path,c.path, style="bold"))
-
- simobjs = []
- for param in self.params:
- try:
- if param.value is None:
- raise AttributeError, 'Parameter with no value'
-
- value = param.value
- string = param.string(value)
- except Exception, e:
- msg = 'exception in %s:%s\n%s' % (self.name, param.name, e)
- e.args = (msg, )
- raise
-
- if isSimObject(param.ptype) and string != "Null":
- simobjs.append(string)
- else:
- label += '%s = %s\\n' % (param.name, string)
-
- for so in simobjs:
- label += "|<%s> %s" % (so, so)
- dot.add_edge(pydot.Edge("%s:%s" % (self.path, so), so,
- tailport="w"))
- label += '}'
- dot.add_node(pydot.Node(self.path,shape="Mrecord",label=label))
-
- # recursively dump out children
- for c in self.children:
- c.outputDot(dot)
-
# Function to provide to C++ so it can look up instances based on paths
def resolveSimObject(name):
obj = instanceDict[name]
baseInstances = instanceDict.copy()
def clear():
- global allClasses, instanceDict
+ global allClasses, instanceDict, noCxxHeader
allClasses = baseClasses.copy()
instanceDict = baseInstances.copy()
+ noCxxHeader = False
# __all__ defines the list of symbols that get exported when
# 'from config import *' is invoked. Try to keep this reasonably
projects / gem5.git / blobdiff