derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge with main repository.

Browse Source
This commit is contained in:
Gabe Black
2012-01-07 02:10:34 -08:00
parent 85424bef19 f171a29118
commit 36a822f08e
155 changed files with 5002 additions and 4251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/python/SConscript
View File

@@ -66,6 +66,7 @@ PySource('m5.util', 'm5/util/terminal.py')
SwigSource('m5.internal', 'swig/core.i')
SwigSource('m5.internal', 'swig/debug.i')
SwigSource('m5.internal', 'swig/event.i')
SwigSource('m5.internal', 'swig/pyobject.i')
SwigSource('m5.internal', 'swig/range.i')
SwigSource('m5.internal', 'swig/stats.i')
SwigSource('m5.internal', 'swig/trace.i')

265
src/python/m5/SimObject.py
View File

@@ -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

1
src/python/m5/internal/__init__.py
View File

@@ -29,6 +29,5 @@
import core
import debug
import event
import random
import stats
import trace

33
src/python/m5/params.py
View File

@@ -81,10 +81,17 @@ class MetaParamValue(type):
class ParamValue(object):
__metaclass__ = MetaParamValue
# Generate the code needed as a prerequisite for declaring a C++
# object of this type. Typically generates one or more #include
# statements. Used when declaring parameters of this type.
@classmethod
def cxx_predecls(cls, code):
pass
# Generate the code needed as a prerequisite for including a
# reference to a C++ object of this type in a SWIG .i file.
# Typically generates one or more %import or %include statements.
@classmethod
def swig_predecls(cls, code):
pass
@@ -101,8 +108,6 @@ class ParamValue(object):
# Regular parameter description.
class ParamDesc(object):
file_ext = 'ptype'
def __init__(self, ptype_str, ptype, *args, **kwargs):
self.ptype_str = ptype_str
# remember ptype only if it is provided
@@ -159,6 +164,7 @@ class ParamDesc(object):
return self.ptype(value)
def cxx_predecls(self, code):
code('#include <cstddef>')
self.ptype.cxx_predecls(code)
def swig_predecls(self, code):
@@ -223,8 +229,6 @@ class SimObjectVector(VectorParamValue):
yield obj
class VectorParamDesc(ParamDesc):
file_ext = 'vptype'
# Convert assigned value to appropriate type. If the RHS is not a
# list or tuple, it generates a single-element list.
def convert(self, value):
@@ -240,10 +244,14 @@ class VectorParamDesc(ParamDesc):
else:
return VectorParamValue(tmp_list)
def swig_module_name(self):
return "%s_vector" % self.ptype_str
def swig_predecls(self, code):
code('%import "vptype_${{self.ptype_str}}.i"')
code('%import "${{self.swig_module_name()}}.i"')
def swig_decl(self, code):
code('%module(package="m5.internal") ${{self.swig_module_name()}}')
code('%{')
self.ptype.cxx_predecls(code)
code('%}')
@@ -1043,6 +1051,19 @@ namespace Enums {
} // namespace Enums
''')
def swig_decl(cls, code):
name = cls.__name__
code('''\
%module(package="m5.internal") enum_$name
%{
#include "enums/$name.hh"
%}
%include "enums/$name.hh"
''')
# Base class for enum types.
class Enum(ParamValue):
__metaclass__ = MetaEnum
@@ -1362,7 +1383,7 @@ class PortRef(object):
# Call C++ to create corresponding port connection between C++ objects
def ccConnect(self):
from m5.internal.params import connectPorts
from m5.internal.pyobject import connectPorts
if self.ccConnected: # already done this
return

5
src/python/swig/pyobject.cc
View File

@@ -88,16 +88,11 @@ int
connectPorts(SimObject *o1, const std::string &name1, int i1,
SimObject *o2, const std::string &name2, int i2)
{
MemObject *mo1, *mo2;
mo1 = dynamic_cast<MemObject*>(o1);
mo2 = dynamic_cast<MemObject*>(o2);
if (FullSystem) {
EtherObject *eo1, *eo2;
EtherDevice *ed1, *ed2;
eo1 = dynamic_cast<EtherObject*>(o1);
ed1 = dynamic_cast<EtherDevice*>(o1);
eo2 = dynamic_cast<EtherObject*>(o2);
ed2 = dynamic_cast<EtherDevice*>(o2);

30
src/python/swig/sim_object.i → src/python/swig/pyobject.i
View File

@@ -28,6 +28,8 @@
* Authors: Nathan Binkert
*/
%module(package="m5.internal") pyobject
%{
#include "python/swig/pyobject.hh"
%}
@@ -36,34 +38,6 @@
%include <std_string.i>
%include <stdint.i>
%include "base/types.hh"
%include "sim/sim_object_params.hh"
class BaseCPU;
class SimObject {
public:
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);
SimObject(const SimObjectParams *p);
};
int connectPorts(SimObject *o1, const std::string &name1, int i1,
SimObject *o2, const std::string &name2, int i2);

46
src/python/swig/system.i
View File

@@ -1,46 +0,0 @@
/*
* Copyright (c) 2006 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
*/
%{
#include "sim/system.hh"
%}
%import "enums/MemoryMode.hh"
%import "python/swig/sim_object.i"
class System : public SimObject
{
private:
System();
public:
Enums::MemoryMode getMemoryMode();
void setMemoryMode(Enums::MemoryMode mode);
};