X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fpython%2Fm5%2FSimObject.py;h=baeef73d9fb4ee8f020d0bec5cce86f5dec7efc4;hb=1ccc7025398a78e0483ec5a9706a8de019d83474;hp=3aea55f5ffb4ca7f439df2eb6d736bfa0047612b;hpb=b81a977e6ab7dbfd122cb778cfe3d40ca7451198;p=gem5.git diff --git a/src/python/m5/SimObject.py b/src/python/m5/SimObject.py index 3aea55f5f..baeef73d9 100644 --- a/src/python/m5/SimObject.py +++ b/src/python/m5/SimObject.py @@ -1,4 +1,4 @@ -# Copyright (c) 2012 ARM Limited +# Copyright (c) 2017 ARM Limited # All rights reserved. # # The license below extends only to copyright in the software and shall @@ -11,7 +11,8 @@ # 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. +# Copyright (c) 2010-20013 Advanced Micro Devices, Inc. +# Copyright (c) 2013 Mark D. Hill and David A. Wood # All rights reserved. # # Redistribution and use in source and binary forms, with or without @@ -40,12 +41,16 @@ # Authors: Steve Reinhardt # Nathan Binkert # Andreas Hansson +# Andreas Sandberg import sys from types import FunctionType, MethodType, ModuleType +from functools import wraps +import inspect import m5 from m5.util import * +from m5.util.pybind import * # Have to import params up top since Param is referenced on initial # load (when SimObject class references Param to create a class @@ -113,18 +118,294 @@ def public_value(key, value): isinstance(value, (FunctionType, MethodType, ModuleType, classmethod, type)) +def createCxxConfigDirectoryEntryFile(code, name, simobj, is_header): + entry_class = 'CxxConfigDirectoryEntry_%s' % name + param_class = '%sCxxConfigParams' % name + + code('#include "params/%s.hh"' % name) + + if not is_header: + for param in simobj._params.values(): + if isSimObjectClass(param.ptype): + code('#include "%s"' % param.ptype._value_dict['cxx_header']) + code('#include "params/%s.hh"' % param.ptype.__name__) + else: + param.ptype.cxx_ini_predecls(code) + + if is_header: + member_prefix = '' + end_of_decl = ';' + code('#include "sim/cxx_config.hh"') + code() + code('class ${param_class} : public CxxConfigParams,' + ' public ${name}Params') + code('{') + code(' private:') + code.indent() + code('class DirectoryEntry : public CxxConfigDirectoryEntry') + code('{') + code(' public:') + code.indent() + code('DirectoryEntry();'); + code() + code('CxxConfigParams *makeParamsObject() const') + code('{ return new ${param_class}; }') + code.dedent() + code('};') + code() + code.dedent() + code(' public:') + code.indent() + else: + member_prefix = '%s::' % param_class + end_of_decl = '' + code('#include "%s"' % simobj._value_dict['cxx_header']) + code('#include "base/str.hh"') + code('#include "cxx_config/${name}.hh"') + + if simobj._ports.values() != []: + code('#include "mem/mem_object.hh"') + code('#include "mem/port.hh"') + + code() + code('${member_prefix}DirectoryEntry::DirectoryEntry()'); + code('{') + + def cxx_bool(b): + return 'true' if b else 'false' + + code.indent() + for param in simobj._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + code('parameters["%s"] = new ParamDesc("%s", %s, %s);' % + (param.name, param.name, cxx_bool(is_vector), + cxx_bool(is_simobj))); + + for port in simobj._ports.values(): + is_vector = isinstance(port, m5.params.VectorPort) + is_master = port.role == 'MASTER' + + code('ports["%s"] = new PortDesc("%s", %s, %s);' % + (port.name, port.name, cxx_bool(is_vector), + cxx_bool(is_master))) + + code.dedent() + code('}') + code() + + code('bool ${member_prefix}setSimObject(const std::string &name,') + code(' SimObject *simObject)${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('bool ret = true;') + code() + code('if (false) {') + for param in simobj._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if is_simobj and not is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('this->${{param.name}} = ' + 'dynamic_cast<${{param.ptype.cxx_type}}>(simObject);') + code('if (simObject && !this->${{param.name}})') + code(' ret = false;') + code.dedent() + code('} else {') + code(' ret = false;') + code('}') + code() + code('return ret;') + code.dedent() + code('}') + + code() + code('bool ${member_prefix}setSimObjectVector(' + 'const std::string &name,') + code(' const std::vector &simObjects)${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('bool ret = true;') + code() + code('if (false) {') + for param in simobj._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if is_simobj and is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('this->${{param.name}}.clear();') + code('for (auto i = simObjects.begin(); ' + 'ret && i != simObjects.end(); i ++)') + code('{') + code.indent() + code('${{param.ptype.cxx_type}} object = ' + 'dynamic_cast<${{param.ptype.cxx_type}}>(*i);') + code('if (*i && !object)') + code(' ret = false;') + code('else') + code(' this->${{param.name}}.push_back(object);') + code.dedent() + code('}') + code.dedent() + code('} else {') + code(' ret = false;') + code('}') + code() + code('return ret;') + code.dedent() + code('}') + + code() + code('void ${member_prefix}setName(const std::string &name_)' + '${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('this->name = name_;') + code.dedent() + code('}') + + if is_header: + code('const std::string &${member_prefix}getName()') + code('{ return this->name; }') + + code() + code('bool ${member_prefix}setParam(const std::string &name,') + code(' const std::string &value, const Flags flags)${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('bool ret = true;') + code() + code('if (false) {') + for param in simobj._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if not is_simobj and not is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + param.ptype.cxx_ini_parse(code, + 'value', 'this->%s' % param.name, 'ret =') + code.dedent() + code('} else {') + code(' ret = false;') + code('}') + code() + code('return ret;') + code.dedent() + code('}') + + code() + code('bool ${member_prefix}setParamVector(' + 'const std::string &name,') + code(' const std::vector &values,') + code(' const Flags flags)${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('bool ret = true;') + code() + code('if (false) {') + for param in simobj._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if not is_simobj and is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('${{param.name}}.clear();') + code('for (auto i = values.begin(); ' + 'ret && i != values.end(); i ++)') + code('{') + code.indent() + code('${{param.ptype.cxx_type}} elem;') + param.ptype.cxx_ini_parse(code, + '*i', 'elem', 'ret =') + code('if (ret)') + code(' this->${{param.name}}.push_back(elem);') + code.dedent() + code('}') + code.dedent() + code('} else {') + code(' ret = false;') + code('}') + code() + code('return ret;') + code.dedent() + code('}') + + code() + code('bool ${member_prefix}setPortConnectionCount(' + 'const std::string &name,') + code(' unsigned int count)${end_of_decl}') + + if not is_header: + code('{') + code.indent() + code('bool ret = true;') + code() + code('if (false)') + code(' ;') + for port in simobj._ports.values(): + code('else if (name == "${{port.name}}")') + code(' this->port_${{port.name}}_connection_count = count;') + code('else') + code(' ret = false;') + code() + code('return ret;') + code.dedent() + code('}') + + code() + code('SimObject *${member_prefix}simObjectCreate()${end_of_decl}') + + if not is_header: + code('{') + if hasattr(simobj, 'abstract') and simobj.abstract: + code(' return NULL;') + else: + code(' return this->create();') + code('}') + + if is_header: + code() + code('static CxxConfigDirectoryEntry' + ' *${member_prefix}makeDirectoryEntry()') + code('{ return new DirectoryEntry; }') + + if is_header: + code.dedent() + code('};') + # The metaclass for SimObject. This class controls how new classes # that derive from SimObject are instantiated, and provides inherited # class behavior (just like a class controls how instances of that # class are instantiated, and provides inherited instance behavior). class MetaSimObject(type): # Attributes that can be set only at initialization time - init_keywords = { 'abstract' : bool, - 'cxx_class' : str, - 'cxx_type' : str, - 'cxx_header' : str, - 'type' : str, - 'cxx_bases' : list } + init_keywords = { + 'abstract' : bool, + 'cxx_class' : str, + 'cxx_type' : str, + 'cxx_header' : str, + 'type' : str, + 'cxx_bases' : list, + 'cxx_exports' : list, + 'cxx_param_exports' : list, + } # Attributes that can be set any time keywords = { 'check' : FunctionType } @@ -141,7 +422,13 @@ class MetaSimObject(type): # filtered in __init__. cls_dict = {} value_dict = {} + cxx_exports = [] for key,val in dict.items(): + try: + cxx_exports.append(getattr(val, "__pybind")) + except AttributeError: + pass + if public_value(key, val): cls_dict[key] = val else: @@ -151,6 +438,12 @@ class MetaSimObject(type): value_dict['abstract'] = False if 'cxx_bases' not in value_dict: value_dict['cxx_bases'] = [] + if 'cxx_exports' not in value_dict: + value_dict['cxx_exports'] = cxx_exports + else: + value_dict['cxx_exports'] += cxx_exports + if 'cxx_param_exports' not in value_dict: + value_dict['cxx_param_exports'] = [] cls_dict['_value_dict'] = value_dict cls = super(MetaSimObject, mcls).__new__(mcls, name, bases, cls_dict) if 'type' in value_dict: @@ -171,6 +464,7 @@ class MetaSimObject(type): # class or instance attributes cls._values = multidict() # param values + cls._hr_values = multidict() # human readable param values cls._children = multidict() # SimObject children cls._port_refs = multidict() # port ref objects cls._instantiated = False # really instantiated, cloned, or subclassed @@ -183,7 +477,8 @@ class MetaSimObject(type): if isinstance(c, MetaSimObject): bTotal += 1 if bTotal > 1: - raise TypeError, "SimObjects do not support multiple inheritance" + raise TypeError, \ + "SimObjects do not support multiple inheritance" base = bases[0] @@ -196,6 +491,7 @@ class MetaSimObject(type): cls._params.parent = base._params cls._ports.parent = base._ports cls._values.parent = base._values + cls._hr_values.parent = base._hr_values cls._children.parent = base._children cls._port_refs.parent = base._port_refs # mark base as having been subclassed @@ -213,22 +509,7 @@ class MetaSimObject(type): 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) + warn("No header file specified for SimObject: %s", name) # Now process the _value_dict items. They could be defining # new (or overriding existing) parameters or ports, setting @@ -273,6 +554,7 @@ class MetaSimObject(type): def _set_param(cls, name, value, param): assert(param.name == name) try: + hr_value = value value = param.convert(value) except Exception, e: msg = "%s\nError setting param %s.%s to %s\n" % \ @@ -284,6 +566,11 @@ class MetaSimObject(type): # it gets cloned properly when the class is instantiated if isSimObjectOrVector(value) and not value.has_parent(): cls._add_cls_child(name, value) + # update human-readable values of the param if it has a literal + # value and is not an object or proxy. + if not (isSimObjectOrVector(value) or\ + isinstance(value, m5.proxy.BaseProxy)): + cls._hr_values[name] = hr_value def _add_cls_child(cls, name, child): # It's a little funky to have a class as a parent, but these @@ -374,115 +661,95 @@ class MetaSimObject(type): 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 + def pybind_predecls(cls, code): + code('#include "${{cls.cxx_header}}"') - # 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): + def pybind_decl(cls, code): class_path = cls.cxx_class.split('::') - classname = class_path[-1] - namespaces = class_path[:-1] + namespaces, classname = class_path[:-1], class_path[-1] + py_class_name = '_COLONS_'.join(class_path) if namespaces else \ + classname; # 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() + # here). Sort the params based on their key + params = map(lambda (k, v): v, sorted(cls._params.local.items())) 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 -using std::ptrdiff_t; -''') - code('%}') - code() + code('''#include "pybind11/pybind11.h" +#include "pybind11/stl.h" - for param in params: - param.swig_predecls(code) - cls.export_method_swig_predecls(code) +#include "params/$cls.hh" +#include "python/pybind11/core.hh" +#include "sim/init.hh" +#include "sim/sim_object.hh" - code() - if cls._base: - code('%import "python/m5/internal/param_${{cls._base}}.i"') - code() +#include "${{cls.cxx_header}}" - 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;') + for param in params: + param.pybind_predecls(code) - code() - code('// stop swig from creating/wrapping default ctor/dtor') - code('%nodefault $classname;') - code('class $classname') + code('''namespace py = pybind11; + +static void +module_init(py::module &m_internal) +{ + py::module m = m_internal.def_submodule("param_${cls}"); +''') + code.indent() if cls._base: - bases = [ cls._base.cxx_class ] + cls.cxx_bases + code('py::class_<${cls}Params, ${{cls._base.type}}Params, ' \ + 'std::unique_ptr<${{cls}}Params, py::nodelete>>(' \ + 'm, "${cls}Params")') 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('py::class_<${cls}Params, ' \ + 'std::unique_ptr<${cls}Params, py::nodelete>>(' \ + 'm, "${cls}Params")') - code('{') - code(' public:') - cls.export_methods(code) - code('};') - - for ns in reversed(namespaces): - code('} // namespace $ns') + code.indent() + if not hasattr(cls, 'abstract') or not cls.abstract: + code('.def(py::init<>())') + code('.def("create", &${cls}Params::create)') + + param_exports = cls.cxx_param_exports + [ + PyBindProperty(k) + for k, v in sorted(cls._params.local.items()) + ] + [ + PyBindProperty("port_%s_connection_count" % port.name) + for port in ports.itervalues() + ] + for exp in param_exports: + exp.export(code, "%sParams" % cls) + + code(';') + code() + code.dedent() + bases = [ cls._base.cxx_class ] + cls.cxx_bases if cls._base else \ + cls.cxx_bases + if bases: + base_str = ", ".join(bases) + code('py::class_<${{cls.cxx_class}}, ${base_str}, ' \ + 'std::unique_ptr<${{cls.cxx_class}}, py::nodelete>>(' \ + 'm, "${py_class_name}")') + else: + code('py::class_<${{cls.cxx_class}}, ' \ + 'std::unique_ptr<${{cls.cxx_class}}, py::nodelete>>(' \ + 'm, "${py_class_name}")') + code.indent() + for exp in cls.cxx_exports: + exp.export(code, cls.cxx_class) + code(';') + code.dedent() + code() + code.dedent() + code('}') code() - code('%include "params/$cls.hh"') + code('static EmbeddedPyBind embed_obj("${0}", module_init, "${1}");', + cls, cls._base.type if cls._base else "") # Generate the C++ declaration (.hh file) for this SimObject's @@ -491,8 +758,8 @@ using std::ptrdiff_t; # 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() + # here). Sort the params based on their key + params = map(lambda (k, v): v, sorted(cls._params.local.items())) ports = cls._ports.local try: ptypes = [p.ptype for p in params] @@ -509,6 +776,14 @@ using std::ptrdiff_t; ''') + + # 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('''#include ''') + # A forward class declaration is sufficient since we are just # declaring a pointer. for ns in class_path[:-1]: @@ -518,20 +793,6 @@ using std::ptrdiff_t; 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 - -class EventQueue; -''') for param in params: param.cxx_predecls(code) for port in ports.itervalues(): @@ -559,17 +820,12 @@ class EventQueue; code.indent() if cls == SimObject: code(''' - SimObjectParams() - { - extern EventQueue mainEventQueue; - eventq = &mainEventQueue; - } + SimObjectParams() {} virtual ~SimObjectParams() {} std::string name; - PyObject *pyobj; - EventQueue *eventq; ''') + for param in params: param.cxx_decl(code) for port in ports.itervalues(): @@ -582,7 +838,83 @@ class EventQueue; code('#endif // __PARAMS__${cls}__') return code + # Generate the C++ declaration/definition files for this SimObject's + # param struct to allow C++ initialisation + def cxx_config_param_file(cls, code, is_header): + createCxxConfigDirectoryEntryFile(code, cls.__name__, cls, is_header) + return code +# This *temporary* definition is required to support calls from the +# SimObject class definition to the MetaSimObject methods (in +# particular _set_param, which gets called for parameters with default +# values defined on the SimObject class itself). It will get +# overridden by the permanent definition (which requires that +# SimObject be defined) lower in this file. +def isSimObjectOrVector(value): + return False + +def cxxMethod(*args, **kwargs): + """Decorator to export C++ functions to Python""" + + def decorate(func): + name = func.func_name + override = kwargs.get("override", False) + cxx_name = kwargs.get("cxx_name", name) + + args, varargs, keywords, defaults = inspect.getargspec(func) + if varargs or keywords: + raise ValueError("Wrapped methods must not contain variable " \ + "arguments") + + # Create tuples of (argument, default) + if defaults: + args = args[:-len(defaults)] + zip(args[-len(defaults):], defaults) + # Don't include self in the argument list to PyBind + args = args[1:] + + + @wraps(func) + def cxx_call(self, *args, **kwargs): + ccobj = self.getCCObject() + return getattr(ccobj, name)(*args, **kwargs) + + @wraps(func) + def py_call(self, *args, **kwargs): + return self.func(*args, **kwargs) + + f = py_call if override else cxx_call + f.__pybind = PyBindMethod(name, cxx_name=cxx_name, args=args) + + return f + + if len(args) == 0: + return decorate + elif len(args) == 1 and len(kwargs) == 0: + return decorate(*args) + else: + raise TypeError("One argument and no kwargs, or only kwargs expected") + +# This class holds information about each simobject parameter +# that should be displayed on the command line for use in the +# configuration system. +class ParamInfo(object): + def __init__(self, type, desc, type_str, example, default_val, access_str): + self.type = type + self.desc = desc + self.type_str = type_str + self.example_str = example + self.default_val = default_val + # The string representation used to access this param through python. + # The method to access this parameter presented on the command line may + # be different, so this needs to be stored for later use. + self.access_str = access_str + self.created = True + + # Make it so we can only set attributes at initialization time + # and effectively make this a const object. + def __setattr__(self, name, value): + if not "created" in self.__dict__: + self.__dict__[name] = value # The SimObject class is the root of the special hierarchy. Most of # the code in this class deals with the configuration hierarchy itself @@ -593,28 +925,90 @@ class SimObject(object): __metaclass__ = MetaSimObject type = 'SimObject' abstract = True - cxx_header = "sim/sim_object.hh" - - cxx_bases = [ "Drainable" ] - @classmethod - def export_method_swig_predecls(cls, code): - code(''' -%include - -%import "python/swig/drain.i" -''') + cxx_header = "sim/sim_object.hh" + cxx_bases = [ "Drainable", "Serializable" ] + eventq_index = Param.UInt32(Parent.eventq_index, "Event Queue Index") + + cxx_exports = [ + PyBindMethod("init"), + PyBindMethod("initState"), + PyBindMethod("memInvalidate"), + PyBindMethod("memWriteback"), + PyBindMethod("regStats"), + PyBindMethod("resetStats"), + PyBindMethod("regProbePoints"), + PyBindMethod("regProbeListeners"), + PyBindMethod("startup"), + ] + + cxx_param_exports = [ + PyBindProperty("name"), + ] + + @cxxMethod + def loadState(self, cp): + """Load SimObject state from a checkpoint""" + pass - @classmethod - def export_methods(cls, code): - code(''' - void init(); - void loadState(Checkpoint *cp); - void initState(); - void regStats(); - void resetStats(); - void startup(); -''') + # Returns a dict of all the option strings that can be + # generated as command line options for this simobject instance + # by tracing all reachable params in the top level instance and + # any children it contains. + def enumerateParams(self, flags_dict = {}, + cmd_line_str = "", access_str = ""): + if hasattr(self, "_paramEnumed"): + print "Cycle detected enumerating params" + else: + self._paramEnumed = True + # Scan the children first to pick up all the objects in this SimObj + for keys in self._children: + child = self._children[keys] + next_cmdline_str = cmd_line_str + keys + next_access_str = access_str + keys + if not isSimObjectVector(child): + next_cmdline_str = next_cmdline_str + "." + next_access_str = next_access_str + "." + flags_dict = child.enumerateParams(flags_dict, + next_cmdline_str, + next_access_str) + + # Go through the simple params in the simobject in this level + # of the simobject hierarchy and save information about the + # parameter to be used for generating and processing command line + # options to the simulator to set these parameters. + for keys,values in self._params.items(): + if values.isCmdLineSettable(): + type_str = '' + ex_str = values.example_str() + ptype = None + if isinstance(values, VectorParamDesc): + type_str = 'Vector_%s' % values.ptype_str + ptype = values + else: + type_str = '%s' % values.ptype_str + ptype = values.ptype + + if keys in self._hr_values\ + and keys in self._values\ + and not isinstance(self._values[keys], + m5.proxy.BaseProxy): + cmd_str = cmd_line_str + keys + acc_str = access_str + keys + flags_dict[cmd_str] = ParamInfo(ptype, + self._params[keys].desc, type_str, ex_str, + values.pretty_print(self._hr_values[keys]), + acc_str) + elif not keys in self._hr_values\ + and not keys in self._values: + # Empty param + cmd_str = cmd_line_str + keys + acc_str = access_str + keys + flags_dict[cmd_str] = ParamInfo(ptype, + self._params[keys].desc, + type_str, ex_str, '', acc_str) + + return flags_dict # Initialize new instance. For objects with SimObject-valued # children, we need to recursively clone the classes represented @@ -656,6 +1050,7 @@ class SimObject(object): # individual value settings can be overridden but we still # inherit late changes to non-overridden class values. self._values = multidict(ancestor._values) + self._hr_values = multidict(ancestor._hr_values) # clone SimObject-valued parameters for key,val in ancestor._values.iteritems(): val = tryAsSimObjectOrVector(val) @@ -698,7 +1093,7 @@ class SimObject(object): # via __setattr__. There is only ever one reference # object per port, but we create them lazily here. ref = self._port_refs.get(attr) - if not ref: + if ref == None: ref = self._ports[attr].makeRef(self) self._port_refs[attr] = ref return ref @@ -715,15 +1110,19 @@ class SimObject(object): # 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(), - # resetStats(), startup(), drain(), and - # resume(). + # methods exported to Python (e.g., init(), and startup()) if self._ccObject and hasattr(self._ccObject, attr): return getattr(self._ccObject, attr) - raise AttributeError, "object '%s' has no attribute '%s'" \ + err_string = "object '%s' has no attribute '%s'" \ % (self.__class__.__name__, attr) + if not self._ccObject: + err_string += "\n (C++ object is not yet constructed," \ + " so wrapped C++ methods are unavailable.)" + + raise AttributeError, err_string + # Set attribute (called on foo.attr = value when foo is an # instance of class cls). def __setattr__(self, attr, value): @@ -737,14 +1136,10 @@ class SimObject(object): self._get_port_ref(attr).connect(value) return - if isSimObjectOrSequence(value) and self._instantiated: - raise RuntimeError, \ - "cannot set SimObject parameter '%s' after\n" \ - " instance been cloned %s" % (attr, `self`) - param = self._params.get(attr) if param: try: + hr_value = value value = param.convert(value) except Exception, e: msg = "%s\nError setting param %s.%s to %s\n" % \ @@ -755,6 +1150,13 @@ class SimObject(object): # implicitly parent unparented objects assigned as params if isSimObjectOrVector(value) and not value.has_parent(): self.add_child(attr, value) + # set the human-readable value dict if this is a param + # with a literal value and is not being set as an object + # or proxy. + if not (isSimObjectOrVector(value) or\ + isinstance(value, m5.proxy.BaseProxy)): + self._hr_values[attr] = hr_value + return # if RHS is a SimObject, it's an implicit child assignment @@ -772,7 +1174,13 @@ class SimObject(object): def __getitem__(self, key): if key == 0: return self - raise TypeError, "Non-zero index '%s' to SimObject" % key + raise IndexError, "Non-zero index '%s' to SimObject" % key + + # this hack allows us to iterate over a SimObject that may + # not be a vector, so we can call a loop over it and get just one + # element. + def __len__(self): + return 1 # Also implemented by SimObjectVector def clear_parent(self, old_parent): @@ -784,6 +1192,12 @@ class SimObject(object): self._parent = parent self._name = name + # Return parent object of this SimObject, not implemented by + # SimObjectVector because the elements in a SimObjectVector may not share + # the same parent + def get_parent(self): + return self._parent + # Also implemented by SimObjectVector def get_name(self): return self._name @@ -803,8 +1217,8 @@ class SimObject(object): def add_child(self, name, child): child = coerceSimObjectOrVector(child) if child.has_parent(): - print "warning: add_child('%s'): child '%s' already has parent" % \ - (name, child.get_name()) + warn("add_child('%s'): child '%s' already has parent", name, + child.get_name()) if self._children.has_key(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 @@ -827,13 +1241,15 @@ class SimObject(object): val = SimObjectVector(val) self._values[key] = val if isSimObjectOrVector(val) and not val.has_parent(): - print "warning: %s adopting orphan SimObject param '%s'" \ - % (self, key) + warn("%s adopting orphan SimObject param '%s'", self, key) self.add_child(key, val) def path(self): if not self._parent: return '' % self.__class__ + elif isinstance(self._parent, MetaSimObject): + return str(self.__class__) + ppath = self._parent.path() if ppath == 'root': return self._name @@ -842,6 +1258,9 @@ class SimObject(object): def __str__(self): return self.path() + def config_value(self): + return self.path() + def ini_str(self): return self.path() @@ -851,7 +1270,11 @@ class SimObject(object): found_obj = None for child in self._children.itervalues(): - if isinstance(child, ptype): + visited = False + if hasattr(child, '_visited'): + visited = getattr(child, '_visited') + + if isinstance(child, ptype) and not visited: if found_obj != None and child != found_obj: raise AttributeError, \ 'parent.any matched more than one: %s %s' % \ @@ -863,7 +1286,8 @@ class SimObject(object): match_obj = self._values[pname] if found_obj != None and found_obj != match_obj: raise AttributeError, \ - 'parent.any matched more than one: %s and %s' % (found_obj.path, match_obj.path) + 'parent.any matched more than one: %s and %s' % \ + (found_obj.path, match_obj.path) found_obj = match_obj return found_obj, found_obj != None @@ -871,20 +1295,29 @@ class SimObject(object): all = {} # search children for child in self._children.itervalues(): - 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)))) + # 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 + # Also make sure to sort the keys based on the objects' path to + # ensure that the order is the same on all hosts + return sorted(all.keys(), key = lambda o: o.path()), True def unproxy(self, base): return self @@ -953,18 +1386,7 @@ class SimObject(object): 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 + d[param] = value.config_value() for n in sorted(self._children.keys()): child = self._children[n] @@ -988,7 +1410,6 @@ class SimObject(object): cc_params_struct = getattr(m5.internal.params, '%sParams' % self.type) cc_params = cc_params_struct() - cc_params.pyobj = self cc_params.name = str(self) param_names = self._params.keys() @@ -1004,8 +1425,14 @@ class SimObject(object): assert isinstance(value, list) vec = getattr(cc_params, param) assert not len(vec) - for v in value: - vec.append(v) + # Some types are exposed as opaque types. They support + # the append operation unlike the automatically + # wrapped types. + if isinstance(vec, list): + setattr(cc_params, param, list(value)) + else: + for v in value: + getattr(cc_params, param).append(v) else: setattr(cc_params, param, value) @@ -1033,8 +1460,9 @@ class SimObject(object): # Cycles in the configuration hierarchy are not supported. This # will catch the resulting recursion and stop. self._ccObject = -1 - params = self.getCCParams() - self._ccObject = params.create() + if not self.abstract: + params = self.getCCParams() + self._ccObject = params.create() elif self._ccObject == -1: raise RuntimeError, "%s: Cycle found in configuration hierarchy." \ % self.path() @@ -1042,7 +1470,10 @@ class SimObject(object): def descendants(self): yield self - for child in self._children.itervalues(): + # The order of the dict is implementation dependent, so sort + # it based on the key (name) to ensure the order is the same + # on all hosts + for (name, child) in sorted(self._children.iteritems()): for obj in child.descendants(): yield obj @@ -1057,7 +1488,9 @@ class SimObject(object): # Create C++ port connections corresponding to the connections in # _port_refs def connectPorts(self): - for portRef in self._port_refs.itervalues(): + # Sort the ports based on their attribute name to ensure the + # order is the same on all hosts + for (attr, portRef) in sorted(self._port_refs.iteritems()): portRef.ccConnect() # Function to provide to C++ so it can look up instances based on paths @@ -1120,4 +1553,9 @@ def clear(): # __all__ defines the list of symbols that get exported when # 'from config import *' is invoked. Try to keep this reasonably # short to avoid polluting other namespaces. -__all__ = [ 'SimObject' ] +__all__ = [ + 'SimObject', + 'cxxMethod', + 'PyBindMethod', + 'PyBindProperty', +]