summaryrefslogtreecommitdiff
path: root/src/python/m5/SimObject.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/python/m5/SimObject.py')
-rw-r--r--src/python/m5/SimObject.py265
1 files changed, 173 insertions, 92 deletions
diff --git a/src/python/m5/SimObject.py b/src/python/m5/SimObject.py
index 9729fd30f..60693758c 100644
--- a/src/python/m5/SimObject.py
+++ b/src/python/m5/SimObject.py
@@ -97,37 +97,6 @@ allClasses = {}
# 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')
-
def public_value(key, value):
return key.startswith('_') or \
isinstance(value, (FunctionType, MethodType, ModuleType,
@@ -142,9 +111,6 @@ class MetaSimObject(type):
init_keywords = { 'abstract' : bool,
'cxx_class' : str,
'cxx_type' : str,
- 'cxx_predecls' : MethodType,
- 'swig_objdecls' : MethodType,
- 'swig_predecls' : MethodType,
'type' : str }
# Attributes that can be set any time
keywords = { 'check' : FunctionType }
@@ -223,18 +189,20 @@ class MetaSimObject(type):
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)
+ # 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
@@ -378,8 +346,99 @@ class MetaSimObject(type):
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()
+
+ code('%module(package="m5.internal") param_$cls')
+ code()
+ code('%{')
+ code('#include "params/$cls.hh"')
+ for param in params:
+ param.cxx_predecls(code)
+ cls.export_method_cxx_predecls(code)
+ 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:
+ code(' : public ${{cls._base.cxx_class}}')
+ 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).
@@ -408,6 +467,20 @@ class MetaSimObject(type):
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>
+
+struct EventQueue;
+''')
for param in params:
param.cxx_predecls(code)
code()
@@ -421,65 +494,39 @@ class MetaSimObject(type):
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)
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
@@ -492,8 +539,42 @@ class SimObject(object):
abstract = True
@classmethod
- def swig_objdecls(cls, code):
- code('%include "python/swig/sim_object.i"')
+ def export_method_cxx_predecls(cls, code):
+ code('''
+#include <Python.h>
+
+#include "sim/serialize.hh"
+#include "sim/sim_object.hh"
+''')
+
+ @classmethod
+ def export_method_swig_predecls(cls, code):
+ code('''
+%include <std_string.i>
+''')
+
+ @classmethod
+ def export_methods(cls, code):
+ code('''
+ enum State {
+ Running,
+ Draining,
+ Drained
+ };
+
+ void init();
+ void loadState(Checkpoint *cp);
+ void initState();
+ void regStats();
+ void regFormulas();
+ void resetStats();
+ void startup();
+
+ unsigned int drain(Event *drain_event);
+ void resume();
+ void switchOut();
+ void takeOverFrom(BaseCPU *cpu);
+''')
# Initialize new instance. For objects with SimObject-valued
# children, we need to recursively clone the classes represented