diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/SConscript | 406 | ||||
| -rw-r--r-- | src/python/m5/SimObject.py | 191 | ||||
| -rw-r--r-- | src/python/m5/params.py | 200 | ||||
| -rw-r--r-- | src/sim/System.py | 5 |
4 files changed, 459 insertions, 343 deletions
diff --git a/src/SConscript b/src/SConscript index 5879fbc93..67d285016 100644 --- a/src/SConscript +++ b/src/SConscript @@ -259,10 +259,8 @@ for opt in export_vars: env.ConfigFile(opt) def makeTheISA(source, target, env): - f = file(str(target[0]), 'w') - isas = [ src.get_contents() for src in source ] - target = env['TARGET_ISA'] + target_isa = env['TARGET_ISA'] def define(isa): return isa.upper() + '_ISA' @@ -270,16 +268,24 @@ def makeTheISA(source, target, env): return isa[0].upper() + isa[1:].lower() + 'ISA' - print >>f, '#ifndef __CONFIG_THE_ISA_HH__' - print >>f, '#define __CONFIG_THE_ISA_HH__' - print >>f + code = code_formatter() + code('''\ +#ifndef __CONFIG_THE_ISA_HH__ +#define __CONFIG_THE_ISA_HH__ + +''') + for i,isa in enumerate(isas): - print >>f, '#define %s %d' % (define(isa), i + 1) - print >>f - print >>f, '#define THE_ISA %s' % (define(target)) - print >>f, '#define TheISA %s' % (namespace(target)) - print >>f - print >>f, '#endif // __CONFIG_THE_ISA_HH__' + code('#define $0 $1', define(isa), i + 1) + + code(''' + +#define THE_ISA ${{define(target_isa)}} +#define TheISA ${{namespace(target_isa)}} + +#endif // __CONFIG_THE_ISA_HH__''') + + code.write(str(target[0])) env.Command('config/the_isa.hh', map(Value, all_isa_list), makeTheISA) @@ -347,6 +353,7 @@ class DictImporter(object): import m5.SimObject import m5.params +from m5.util import code_formatter m5.SimObject.clear() m5.params.clear() @@ -402,7 +409,7 @@ depends = [ PySource.modules[dep].tnode for dep in module_depends ] def makeDefinesPyFile(target, source, env): build_env, hg_info = [ x.get_contents() for x in source ] - code = m5.util.code_formatter() + code = code_formatter() code(""" import m5.internal import m5.util @@ -418,7 +425,7 @@ for key,val in m5.internal.core.__dict__.iteritems(): _globals[flag] = val del _globals """) - code.write(str(target[0])) + code.write(target[0].abspath) defines_info = [ Value(build_env), Value(env['HG_INFO']) ] # Generate a file with all of the compile options in it @@ -427,11 +434,11 @@ PySource('m5', 'python/m5/defines.py') # Generate python file containing info about the M5 source code def makeInfoPyFile(target, source, env): - f = file(str(target[0]), 'w') + code = code_formatter() for src in source: data = ''.join(file(src.srcnode().abspath, 'r').xreadlines()) - print >>f, "%s = %s" % (src, repr(data)) - f.close() + code('$src = ${{repr(data)}}') + code.write(str(target[0])) # Generate a file that wraps the basic top level files env.Command('python/m5/info.py', @@ -441,12 +448,15 @@ PySource('m5', 'python/m5/info.py') # Generate the __init__.py file for m5.objects def makeObjectsInitFile(target, source, env): - f = file(str(target[0]), 'w') - print >>f, 'from params import *' - print >>f, 'from m5.SimObject import *' + code = code_formatter() + code('''\ +from params import * +from m5.SimObject import * +''') + for module in source: - print >>f, 'from %s import *' % module.get_contents() - f.close() + code('from $0 import *', module.get_contents()) + code.write(str(target[0])) # Generate an __init__.py file for the objects package env.Command('python/m5/objects/__init__.py', @@ -462,43 +472,42 @@ PySource('m5.objects', 'python/m5/objects/__init__.py') def createSimObjectParam(target, source, env): assert len(target) == 1 and len(source) == 1 - hh_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = sim_objects[name] - print >>hh_file, obj.cxx_decl() - hh_file.close() + code = code_formatter() + obj.cxx_decl(code) + code.write(target[0].abspath) def createSwigParam(target, source, env): assert len(target) == 1 and len(source) == 1 - i_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) param = all_params[name] - for line in param.swig_decl(): - print >>i_file, line - i_file.close() + code = code_formatter() + param.swig_decl(code) + code.write(target[0].abspath) def createEnumStrings(target, source, env): assert len(target) == 1 and len(source) == 1 - cc_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = all_enums[name] - print >>cc_file, obj.cxx_def() - cc_file.close() + code = code_formatter() + obj.cxx_def(code) + code.write(target[0].abspath) def createEnumParam(target, source, env): assert len(target) == 1 and len(source) == 1 - hh_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = all_enums[name] - print >>hh_file, obj.cxx_decl() - hh_file.close() + code = code_formatter() + obj.cxx_decl(code) + code.write(target[0].abspath) # Generate all of the SimObject param struct header files params_hh_files = [] @@ -538,7 +547,6 @@ for name,enum in sorted(all_enums.iteritems()): def buildParams(target, source, env): names = [ s.get_contents() for s in source ] objs = [ sim_objects[name] for name in names ] - out = file(target[0].abspath, 'w') ordered_objs = [] obj_seen = set() @@ -556,82 +564,67 @@ def buildParams(target, source, env): for obj in objs: order_obj(obj) - enums = set() - predecls = [] - pd_seen = set() + code = code_formatter() + code('%module params') - def add_pds(*pds): - for pd in pds: - if pd not in pd_seen: - predecls.append(pd) - pd_seen.add(pd) + code('%{') + for obj in ordered_objs: + code('#include "params/$obj.hh"') + code('%}') for obj in ordered_objs: params = obj._params.local.values() for param in params: - ptype = param.ptype - if issubclass(ptype, m5.params.Enum): - if ptype not in enums: - enums.add(ptype) - pds = param.swig_predecls() - if isinstance(pds, (list, tuple)): - add_pds(*pds) - else: - add_pds(pds) - - print >>out, '%module params' + param.swig_predecls(code) - print >>out, '%{' + enums = set() for obj in ordered_objs: - print >>out, '#include "params/%s.hh"' % obj - print >>out, '%}' - - for pd in predecls: - print >>out, pd - - enums = list(enums) - enums.sort() - for enum in enums: - print >>out, '%%include "enums/%s.hh"' % enum.__name__ - print >>out + params = obj._params.local.values() + for param in params: + ptype = param.ptype + if issubclass(ptype, m5.params.Enum) and ptype not in enums: + enums.add(ptype) + code('%include "enums/$0.hh"', ptype.__name__) + + for obj in ordered_objs: + obj.swig_objdecls(code) + code() for obj in ordered_objs: + continue if obj.swig_objdecls: - for decl in obj.swig_objdecls: - print >>out, decl + obj.swig_objdecls(code) continue class_path = obj.cxx_class.split('::') classname = class_path[-1] namespaces = class_path[:-1] - namespaces.reverse() - code = '' + for ns in namespaces: + code('namespace $ns {') if namespaces: - code += '// avoid name conflicts\n' + code('// avoid name conflicts') sep_string = '_COLONS_' flat_name = sep_string.join(class_path) - code += '%%rename(%s) %s;\n' % (flat_name, classname) + code('%rename($flat_name) $classname;') - code += '// stop swig from creating/wrapping default ctor/dtor\n' - code += '%%nodefault %s;\n' % classname - code += 'class %s ' % classname + code('// stop swig from creating/wrapping default ctor/dtor') + code('%nodefault $classname;') if obj._base: - code += ': public %s' % obj._base.cxx_class - code += ' {};\n' - - for ns in namespaces: - new_code = 'namespace %s {\n' % ns - new_code += code - new_code += '}\n' - code = new_code + code('class $classname : public ${{obj._base.cxx_class}} {};') + else: + code('class $classname {};') - print >>out, code + for ns in reversed(namespaces): + code('/* namespace $ns */ }') + code() - print >>out, '%%include "src/sim/sim_object_params.hh"' % obj + code('%include "src/sim/sim_object_params.hh"') for obj in ordered_objs: - print >>out, '%%include "params/%s.hh"' % obj + code('%include "params/$obj.hh"') + + code.write(target[0].abspath) params_file = File('params/params.i') names = sorted(sim_objects.keys()) @@ -649,16 +642,23 @@ for swig in SwigSource.all: # Generate the main swig init file def makeSwigInit(target, source, env): - f = file(str(target[0]), 'w') - print >>f, 'extern "C" {' + code = code_formatter() + + code('extern "C" {') + code.indent() for module in source: - print >>f, ' void init_%s();' % module.get_contents() - print >>f, '}' - print >>f, 'void initSwig() {' + code('void init_$0();', module.get_contents()) + code.dedent() + code('}') + + code('void initSwig() {') + code.indent() for module in source: - print >>f, ' init_%s();' % module.get_contents() - print >>f, '}' - f.close() + code('init_$0();', module.get_contents()) + code.dedent() + code('}') + + code.write(str(target[0])) env.Command('python/swig/init.cc', map(Value, sorted(s.module for s in SwigSource.all)), @@ -689,55 +689,61 @@ def getFlags(source_flags): # Generate traceflags.py def traceFlagsPy(target, source, env): assert(len(target) == 1) + code = code_formatter() - f = file(str(target[0]), 'w') - allFlags = getFlags(source) - print >>f, 'basic = [' + code('basic = [') + code.indent() for flag, compound, desc in allFlags: if not compound: - print >>f, " '%s'," % flag - print >>f, " ]" - print >>f - - print >>f, 'compound = [' - print >>f, " 'All'," + code("'$flag',") + code(']') + code.dedent() + code() + + code('compound = [') + code.indent() + code("'All',") for flag, compound, desc in allFlags: if compound: - print >>f, " '%s'," % flag - print >>f, " ]" - print >>f + code("'$flag',") + code("]") + code.dedent() + code() - print >>f, "all = frozenset(basic + compound)" - print >>f + code("all = frozenset(basic + compound)") + code() - print >>f, 'compoundMap = {' + code('compoundMap = {') + code.indent() all = tuple([flag for flag,compound,desc in allFlags if not compound]) - print >>f, " 'All' : %s," % (all, ) + code("'All' : $all,") for flag, compound, desc in allFlags: if compound: - print >>f, " '%s' : %s," % (flag, compound) - print >>f, " }" - print >>f - - print >>f, 'descriptions = {' - print >>f, " 'All' : 'All flags'," + code("'$flag' : $compound,") + code('}') + code.dedent() + code() + + code('descriptions = {') + code.indent() + code("'All' : 'All flags',") for flag, compound, desc in allFlags: - print >>f, " '%s' : '%s'," % (flag, desc) - print >>f, " }" + code("'$flag' : '$desc',") + code("}") + code.dedent() - f.close() + code.write(str(target[0])) def traceFlagsCC(target, source, env): assert(len(target) == 1) - f = file(str(target[0]), 'w') - allFlags = getFlags(source) + code = code_formatter() # file header - print >>f, ''' + code(''' /* * DO NOT EDIT THIS FILE! Automatically generated */ @@ -747,70 +753,74 @@ def traceFlagsCC(target, source, env): using namespace Trace; const char *Trace::flagStrings[] = -{''' +{''') + code.indent() # The string array is used by SimpleEnumParam to map the strings # provided by the user to enum values. for flag, compound, desc in allFlags: if not compound: - print >>f, ' "%s",' % flag + code('"$flag",') - print >>f, ' "All",' + code('"All",') for flag, compound, desc in allFlags: if compound: - print >>f, ' "%s",' % flag + code('"$flag",') + code.dedent() - print >>f, '};' - print >>f - print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1) - print >>f + code('''\ +}; + +const int Trace::numFlagStrings = ${{len(allFlags) + 1}}; + +''') - # # Now define the individual compound flag arrays. There is an array # for each compound flag listing the component base flags. - # all = tuple([flag for flag,compound,desc in allFlags if not compound]) - print >>f, 'static const Flags AllMap[] = {' + code('static const Flags AllMap[] = {') + code.indent() for flag, compound, desc in allFlags: if not compound: - print >>f, " %s," % flag - print >>f, '};' - print >>f + code('$flag,') + code.dedent() + code('};') + code() for flag, compound, desc in allFlags: if not compound: continue - print >>f, 'static const Flags %sMap[] = {' % flag + code('static const Flags ${flag}Map[] = {') + code.indent() for flag in compound: - print >>f, " %s," % flag - print >>f, " (Flags)-1" - print >>f, '};' - print >>f + code('$flag,') + code('(Flags)-1') + code.dedent() + code('};') + code() - # # Finally the compoundFlags[] array maps the compound flags # to their individual arrays/ - # - print >>f, 'const Flags *Trace::compoundFlags[] =' - print >>f, '{' - print >>f, ' AllMap,' + code('const Flags *Trace::compoundFlags[] = {') + code.indent() + code('AllMap,') for flag, compound, desc in allFlags: if compound: - print >>f, ' %sMap,' % flag + code('${flag}Map,') # file trailer - print >>f, '};' + code.dedent() + code('};') - f.close() + code.write(str(target[0])) def traceFlagsHH(target, source, env): assert(len(target) == 1) - f = file(str(target[0]), 'w') - allFlags = getFlags(source) + code = code_formatter() # file header boilerplate - print >>f, ''' + code('''\ /* * DO NOT EDIT THIS FILE! * @@ -822,36 +832,41 @@ def traceFlagsHH(target, source, env): namespace Trace { -enum Flags {''' +enum Flags {''') # Generate the enum. Base flags come first, then compound flags. idx = 0 + code.indent() for flag, compound, desc in allFlags: if not compound: - print >>f, ' %s = %d,' % (flag, idx) + code('$flag = $idx,') idx += 1 numBaseFlags = idx - print >>f, ' NumFlags = %d,' % idx + code('NumFlags = $idx,') + code.dedent() + code() # put a comment in here to separate base from compound flags - print >>f, ''' + code(''' // The remaining enum values are *not* valid indices for Trace::flags. // They are "compound" flags, which correspond to sets of base -// flags, and are used by changeFlag.''' +// flags, and are used by changeFlag.''') - print >>f, ' All = %d,' % idx + code.indent() + code('All = $idx,') idx += 1 for flag, compound, desc in allFlags: if compound: - print >>f, ' %s = %d,' % (flag, idx) + code('$flag = $idx,') idx += 1 numCompoundFlags = idx - numBaseFlags - print >>f, ' NumCompoundFlags = %d' % numCompoundFlags + code('NumCompoundFlags = $numCompoundFlags') + code.dedent() # trailer boilerplate - print >>f, '''\ + code('''\ }; // enum Flags // Array of strings for SimpleEnumParam @@ -865,9 +880,9 @@ extern const Flags *compoundFlags[]; /* namespace Trace */ } #endif // __BASE_TRACE_FLAGS_HH__ -''' +''') - f.close() + code.write(str(target[0])) flags = map(Value, trace_flags.values()) env.Command('base/traceflags.py', flags, traceFlagsPy) @@ -889,7 +904,6 @@ def objectifyPyFile(target, source, env): as just bytes with a label in the data section''' src = file(str(source[0]), 'r').read() - dst = file(str(target[0]), 'w') pysource = PySource.tnodes[source[0]] compiled = compile(src, pysource.abspath, 'exec') @@ -906,15 +920,21 @@ def objectifyPyFile(target, source, env): sym = pysource.symname step = 16 - print >>dst, ".data" - print >>dst, ".globl %s_beg" % sym - print >>dst, ".globl %s_end" % sym - print >>dst, "%s_beg:" % sym + code = code_formatter() + code('''\ +.data +.globl ${sym}_beg +.globl ${sym}_end +${sym}_beg:''') + for i in xrange(0, len(data), step): x = array.array('B', data[i:i+step]) - print >>dst, ".byte", ','.join([str(d) for d in x]) - print >>dst, "%s_end:" % sym - print >>dst, ".long %d" % len(marshalled) + bytes = ','.join([str(d) for d in x]) + code('.byte $bytes') + code('${sym}_end:') + code('.long $0', len(marshalled)) + + code.write(str(target[0])) for source in PySource.all: env.Command(source.assembly, source.tnode, objectifyPyFile) @@ -926,41 +946,49 @@ for source in PySource.all: # the embedded files, and then there's a list of all of the rest that # the importer uses to load the rest on demand. def pythonInit(target, source, env): - dst = file(str(target[0]), 'w') + code = code_formatter() def dump_mod(sym, endchar=','): def c_str(string): if string is None: return "0" return '"%s"' % string - pysource = PySource.symnames[sym] - print >>dst, ' { %s,' % c_str(pysource.arcname) - print >>dst, ' %s,' % c_str(pysource.abspath) - print >>dst, ' %s,' % c_str(pysource.modpath) - print >>dst, ' %s_beg, %s_end,' % (sym, sym) - print >>dst, ' %s_end - %s_beg,' % (sym, sym) - print >>dst, ' *(int *)%s_end }%s' % (sym, endchar) - - print >>dst, '#include "sim/init.hh"' + pysource = PySource.symnames[sym] + arcname = c_str(pysource.arcname) + abspath = c_str(pysource.abspath) + modpath = c_str(pysource.modpath) + code.indent() + code('''\ +{ $arcname, + $abspath, + $modpath, + ${sym}_beg, ${sym}_end, + ${sym}_end - ${sym}_beg, + *(int *)${sym}_end }$endchar +''') + code.dedent() + + code('#include "sim/init.hh"') for sym in source: sym = sym.get_contents() - print >>dst, "extern const char %s_beg[], %s_end[];" % (sym, sym) + code('extern const char ${sym}_beg[], ${sym}_end[];') - print >>dst, "const EmbeddedPyModule embeddedPyImporter = " - dump_mod("PyEMB_importer", endchar=';'); - print >>dst + code('const EmbeddedPyModule embeddedPyImporter = ') + dump_mod("PyEMB_importer", endchar=';') + code() - print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {" + code('const EmbeddedPyModule embeddedPyModules[] = {') for i,sym in enumerate(source): sym = sym.get_contents() if sym == "PyEMB_importer": # Skip the importer since we've already exported it continue dump_mod(sym) - print >>dst, " { 0, 0, 0, 0, 0, 0, 0 }" - print >>dst, "};" + code(' { 0, 0, 0, 0, 0, 0, 0 }') + code('};') + code.write(str(target[0])) env.Command('sim/init_python.cc', map(Value, (s.symname for s in PySource.all)), diff --git a/src/python/m5/SimObject.py b/src/python/m5/SimObject.py index ab0c39543..d26a99051 100644 --- a/src/python/m5/SimObject.py +++ b/src/python/m5/SimObject.py @@ -29,7 +29,7 @@ # Nathan Binkert import sys -from types import FunctionType +from types import FunctionType, MethodType try: import pydot @@ -97,6 +97,46 @@ allClasses = {} # dict to look up SimObjects based on path instanceDict = {} +def default_cxx_predecls(cls, code): + '''A forward class declaration is sufficient since we are + just declaring a pointer.''' + + class_path = cls._value_dict['cxx_class'].split('::') + for ns in class_path[:-1]: + code('namespace $ns {') + code('class $0;', class_path[-1]) + for ns in reversed(class_path[:-1]): + code('/* namespace $ns */ }') + +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, classmethod, type)) + # 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 @@ -106,9 +146,9 @@ class MetaSimObject(type): init_keywords = { 'abstract' : bool, 'cxx_class' : str, 'cxx_type' : str, - 'cxx_predecls' : list, - 'swig_objdecls' : list, - 'swig_predecls' : list, + 'cxx_predecls' : MethodType, + 'swig_objdecls' : MethodType, + 'swig_predecls' : MethodType, 'type' : str } # Attributes that can be set any time keywords = { 'check' : FunctionType } @@ -127,9 +167,7 @@ class MetaSimObject(type): cls_dict = {} value_dict = {} for key,val in dict.items(): - if key.startswith('_') or isinstance(val, (FunctionType, - classmethod, - type)): + if public_value(key, val): cls_dict[key] = val else: # must be a param/port setting @@ -190,24 +228,16 @@ class MetaSimObject(type): cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class'] - if 'cxx_predecls' not in cls._value_dict: - # A forward class declaration is sufficient since we are - # just declaring a pointer. - class_path = cls._value_dict['cxx_class'].split('::') - class_path.reverse() - decl = 'class %s;' % class_path[0] - for ns in class_path[1:]: - decl = 'namespace %s { %s }' % (ns, decl) - cls._value_dict['cxx_predecls'] = [decl] - - if 'swig_predecls' not in cls._value_dict: - # A forward class declaration is sufficient since we are - # just declaring a pointer. - cls._value_dict['swig_predecls'] = \ - cls._value_dict['cxx_predecls'] - - if 'swig_objdecls' not in cls._value_dict: - cls._value_dict['swig_objdecls'] = [] + 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__: + setattr(cls, 'swig_predecls', getattr(cls, 'cxx_predecls')) + + if 'swig_objdecls' not in cls.__dict__: + m = MethodType(default_swig_objdecls, cls, MetaSimObject) + setattr(cls, 'swig_objdecls', m) # Now process the _value_dict items. They could be defining # new (or overriding existing) parameters or ports, setting @@ -282,7 +312,7 @@ class MetaSimObject(type): # instance of class cls). def __setattr__(cls, attr, value): # normal processing for private attributes - if attr.startswith('_'): + if public_value(attr, value): type.__setattr__(cls, attr, value) return @@ -328,9 +358,12 @@ class MetaSimObject(type): def __str__(cls): return cls.__name__ - def cxx_decl(cls): - code = "#ifndef __PARAMS__%s\n" % cls - code += "#define __PARAMS__%s\n\n" % cls + def cxx_decl(cls, code): + code('''\ +#ifndef __PARAMS__${cls}__ +#define __PARAMS__${cls}__ + +''') # The 'dict' attribute restricts us to the params declared in # the object itself, not including inherited params (which @@ -344,59 +377,57 @@ class MetaSimObject(type): print params raise - # get a list of lists of predeclaration lines - predecls = [] - predecls.extend(cls.cxx_predecls) - for p in params: - predecls.extend(p.cxx_predecls()) - # remove redundant lines - predecls2 = [] - for pd in predecls: - if pd not in predecls2: - predecls2.append(pd) - predecls2.sort() - code += "\n".join(predecls2) - code += "\n\n"; + # get all predeclarations + cls.cxx_predecls(code) + for param in params: + param.cxx_predecls(code) + code() if cls._base: - code += '#include "params/%s.hh"\n\n' % cls._base.type + code('#include "params/${{cls._base.type}}.hh"') + code() for ptype in ptypes: if issubclass(ptype, Enum): - code += '#include "enums/%s.hh"\n' % ptype.__name__ - code += "\n\n" + code('#include "enums/${{ptype.__name__}}.hh"') + code() - code += cls.cxx_struct(cls._base, params) + cls.cxx_struct(code, cls._base, params) # close #ifndef __PARAMS__* guard - code += "\n#endif\n" + code() + code('#endif // __PARAMS__${cls}__') return code - def cxx_struct(cls, base, params): + def cxx_struct(cls, code, base, params): if cls == SimObject: - return '#include "sim/sim_object_params.hh"\n' + code('#include "sim/sim_object_params.hh"') + return # now generate the actual param struct - code = "struct %sParams" % cls + code("struct ${cls}Params") if base: - code += " : public %sParams" % base.type - code += "\n{\n" + code(" : public ${{base.type}}Params") + code("{") if not hasattr(cls, 'abstract') or not cls.abstract: if 'type' in cls.__dict__: - code += " %s create();\n" % cls.cxx_type - decls = [p.cxx_decl() for p in params] - decls.sort() - code += "".join([" %s\n" % d for d in decls]) - code += "};\n" + code(" ${{cls.cxx_type}} create();") - return code + code.indent() + for param in params: + param.cxx_decl(code) + code.dedent() + code('};') + + def swig_decl(cls, code): + code('''\ +%module $cls - def swig_decl(cls): - code = '%%module %s\n' % cls +%{ +#include "params/$cls.hh" +%} - code += '%{\n' - code += '#include "params/%s.hh"\n' % cls - code += '%}\n\n' +''') # The 'dict' attribute restricts us to the params declared in # the object itself, not including inherited params (which @@ -405,32 +436,22 @@ class MetaSimObject(type): params = cls._params.local.values() ptypes = [p.ptype for p in params] - # get a list of lists of predeclaration lines - predecls = [] - predecls.extend([ p.swig_predecls() for p in params ]) - # flatten - predecls = reduce(lambda x,y:x+y, predecls, []) - # remove redundant lines - predecls2 = [] - for pd in predecls: - if pd not in predecls2: - predecls2.append(pd) - predecls2.sort() - code += "\n".join(predecls2) - code += "\n\n"; + # get all predeclarations + for param in params: + param.swig_predecls(code) + code() if cls._base: - code += '%%import "params/%s.i"\n\n' % cls._base.type + code('%import "params/${{cls._base.type}}.i"') + code() for ptype in ptypes: if issubclass(ptype, Enum): - code += '%%import "enums/%s.hh"\n' % ptype.__name__ - code += "\n\n" + code('%import "enums/${{ptype.__name__}}.hh"') + code() - code += '%%import "params/%s_type.hh"\n\n' % cls - code += '%%include "params/%s.hh"\n\n' % cls - - return 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 @@ -442,7 +463,9 @@ class SimObject(object): type = 'SimObject' abstract = True - swig_objdecls = [ '%include "python/swig/sim_object.i"' ] + @classmethod + def swig_objdecls(cls, code): + code('%include "python/swig/sim_object.i"') # Initialize new instance. For objects with SimObject-valued # children, we need to recursively clone the classes represented diff --git a/src/python/m5/params.py b/src/python/m5/params.py index 38e320b53..00bba636b 100644 --- a/src/python/m5/params.py +++ b/src/python/m5/params.py @@ -80,8 +80,13 @@ class MetaParamValue(type): class ParamValue(object): __metaclass__ = MetaParamValue - cxx_predecls = [] - swig_predecls = [] + @classmethod + def cxx_predecls(cls, code): + pass + + @classmethod + def swig_predecls(cls, code): + pass # default for printing to .ini file is regular string conversion. # will be overridden in some cases @@ -152,14 +157,14 @@ class ParamDesc(object): return value return self.ptype(value) - def cxx_predecls(self): - return self.ptype.cxx_predecls + def cxx_predecls(self, code): + self.ptype.cxx_predecls(code) - def swig_predecls(self): - return self.ptype.swig_predecls + def swig_predecls(self, code): + self.ptype.swig_predecls(code) - def cxx_decl(self): - return '%s %s;' % (self.ptype.cxx_type, self.name) + def cxx_decl(self, code): + code('${{self.ptype.cxx_type}} ${{self.name}};') # Vector-valued parameter description. Just like ParamDesc, except # that the value is a vector (list) of the specified type instead of a @@ -235,20 +240,25 @@ class VectorParamDesc(ParamDesc): else: return VectorParamValue(tmp_list) - def swig_predecls(self): - return ['%%include "%s_vptype.i"' % self.ptype_str] + def swig_predecls(self, code): + code('%include "${{self.ptype_str}}_vptype.i"') - def swig_decl(self): + def swig_decl(self, code): cxx_type = re.sub('std::', '', self.ptype.cxx_type) - vdecl = 'namespace std { %%template(vector_%s) vector< %s >; }' % \ - (self.ptype_str, cxx_type) - return ['%include "std_vector.i"'] + self.ptype.swig_predecls + [vdecl] + code('%include "std_vector.i"') + self.ptype.swig_predecls(code) + code('''\ +namespace std { +%template(vector_${{self.ptype_str}}) vector< $cxx_type >; +} +''') - def cxx_predecls(self): - return ['#include <vector>'] + self.ptype.cxx_predecls + def cxx_predecls(self, code): + code('#include <vector>') + self.ptype.cxx_predecls(code) - def cxx_decl(self): - return 'std::vector< %s > %s;' % (self.ptype.cxx_type, self.name) + def cxx_decl(self, code): + code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};') class ParamFactory(object): def __init__(self, param_desc_class, ptype_str = None): @@ -291,10 +301,14 @@ VectorParam = ParamFactory(VectorParamDesc) # built-in str class. class String(ParamValue,str): cxx_type = 'std::string' - cxx_predecls = ['#include <string>'] - swig_predecls = ['%include "std_string.i"\n' + - '%apply const std::string& {std::string *};'] - swig_predecls = ['%include "std_string.i"' ] + + @classmethod + def cxx_predecls(self, code): + code('#include <string>') + + @classmethod + def swig_predecls(cls, code): + code('%include "std_string.i"') def getValue(self): return self @@ -350,15 +364,6 @@ class CheckedIntType(MetaParamValue): if name == 'CheckedInt': return - if not cls.cxx_predecls: - # most derived types require this, so we just do it here once - cls.cxx_predecls = ['#include "base/types.hh"'] - - if not cls.swig_predecls: - # most derived types require this, so we just do it here once - cls.swig_predecls = ['%import "stdint.i"\n' + - '%import "base/types.hh"'] - if not (hasattr(cls, 'min') and hasattr(cls, 'max')): if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')): panic("CheckedInt subclass %s must define either\n" \ @@ -393,6 +398,17 @@ class CheckedInt(NumericParamValue): % type(value).__name__ self._check() + @classmethod + def cxx_predecls(cls, code): + # most derived types require this, so we just do it here once + code('#include "base/types.hh"') + + @classmethod + def swig_predecls(cls, code): + # most derived types require this, so we just do it here once + code('%import "stdint.i"') + code('%import "base/types.hh"') + def getValue(self): return long(self.value) @@ -476,8 +492,6 @@ class MetaRange(MetaParamValue): if name == 'Range': return cls.cxx_type = 'Range< %s >' % cls.type.cxx_type - cls.cxx_predecls = \ - ['#include "base/range.hh"'] + cls.type.cxx_predecls class Range(ParamValue): __metaclass__ = MetaRange @@ -521,9 +535,17 @@ class Range(ParamValue): def __str__(self): return '%s:%s' % (self.first, self.second) + @classmethod + def cxx_predecls(cls, code): + code('#include "base/range.hh"') + cls.type.cxx_predecls(code) + class AddrRange(Range): type = Addr - swig_predecls = ['%include "python/swig/range.i"'] + + @classmethod + def swig_predecls(cls, code): + code('%include "python/swig/range.i"') def getValue(self): from m5.objects.params import AddrRange @@ -535,7 +557,10 @@ class AddrRange(Range): class TickRange(Range): type = Tick - swig_predecls = ['%include "python/swig/range.i"'] + + @classmethod + def swig_predecls(cls, code): + code('%include "python/swig/range.i"') def getValue(self): from m5.objects.params import TickRange @@ -589,8 +614,15 @@ def NextEthernetAddr(): class EthernetAddr(ParamValue): cxx_type = 'Net::EthAddr' - cxx_predecls = ['#include "base/inet.hh"'] - swig_predecls = ['%include "python/swig/inet.i"'] + + @classmethod + def cxx_predecls(cls, code): + code('#include "base/inet.hh"') + + @classmethod + def swig_predecls(cls, code): + code('%include "python/swig/inet.i"') + def __init__(self, value): if value == NextEthernetAddr: self.value = value @@ -661,8 +693,15 @@ def parse_time(value): class Time(ParamValue): cxx_type = 'tm' - cxx_predecls = [ '#include <time.h>' ] - swig_predecls = [ '%include "python/swig/time.i"' ] + + @classmethod + def cxx_predecls(cls, code): + code('#include <time.h>') + + @classmethod + def swig_predecls(cls, code): + code('%include "python/swig/time.i"') + def __init__(self, value): self.value = parse_time(value) @@ -749,34 +788,44 @@ class MetaEnum(MetaParamValue): # Generate C++ class declaration for this enum type. # Note that we wrap the enum in a class/struct to act as a namespace, # so that the enum strings can be brief w/o worrying about collisions. - def cxx_decl(cls): + def cxx_decl(cls, code): name = cls.__name__ - code = "#ifndef __ENUM__%s\n" % name - code += '#define __ENUM__%s\n' % name - code += '\n' - code += 'namespace Enums {\n' - code += ' enum %s {\n' % name + code('''\ +#ifndef __ENUM__${name}__ +#define __ENUM__${name}__ + +namespace Enums { + enum $name { +''') + code.indent(2) for val in cls.vals: - code += ' %s = %d,\n' % (val, cls.map[val]) - code += ' Num_%s = %d,\n' % (name, len(cls.vals)) - code += ' };\n' - code += ' extern const char *%sStrings[Num_%s];\n' % (name, name) - code += '}\n' - code += '\n' - code += '#endif\n' - return code - - def cxx_def(cls): + code('$val = ${{cls.map[val]}},') + code('Num_$name = ${{len(cls.vals)}},') + code.dedent(2) + code('''\ + }; +extern const char *${name}Strings[Num_${name}]; +} + +#endif // __ENUM__${name}__ +''') + + def cxx_def(cls, code): name = cls.__name__ - code = '#include "enums/%s.hh"\n' % name - code += 'namespace Enums {\n' - code += ' const char *%sStrings[Num_%s] =\n' % (name, name) - code += ' {\n' + code('''\ +#include "enums/${name}.hh" +namespace Enums { + const char *${name}Strings[Num_${name}] = + { +''') + code.indent(2) for val in cls.vals: - code += ' "%s",\n' % val - code += ' };\n' - code += '}\n' - return code + code('"$val",') + code.dedent(2) + code(''' + }; +/* namespace Enums */ } +''') # Base class for enum types. class Enum(ParamValue): @@ -800,9 +849,15 @@ frequency_tolerance = 0.001 # 0.1% class TickParamValue(NumericParamValue): cxx_type = 'Tick' - cxx_predecls = ['#include "base/types.hh"'] - swig_predecls = ['%import "stdint.i"\n' + - '%import "base/types.hh"'] + + @classmethod + def cxx_predecls(cls, code): + code('#include "base/types.hh"') + + @classmethod + def swig_predecls(cls, code): + code('%import "stdint.i"') + code('%import "base/types.hh"') def getValue(self): return long(self.value) @@ -878,9 +933,16 @@ class Frequency(TickParamValue): # An explicit conversion to a Latency or Frequency must be made first. class Clock(ParamValue): cxx_type = 'Tick' - cxx_predecls = ['#include "base/types.hh"'] - swig_predecls = ['%import "stdint.i"\n' + - '%import "base/types.hh"'] + + @classmethod + def cxx_predecls(cls, code): + code('#include "base/types.hh"') + + @classmethod + def swig_predecls(cls, code): + code('%import "stdint.i"') + code('%import "base/types.hh"') + def __init__(self, value): if isinstance(value, (Latency, Clock)): self.ticks = value.ticks diff --git a/src/sim/System.py b/src/sim/System.py index 5cf46ad75..eec7b4ae5 100644 --- a/src/sim/System.py +++ b/src/sim/System.py @@ -37,7 +37,10 @@ class MemoryMode(Enum): vals = ['invalid', 'atomic', 'timing'] class System(SimObject): type = 'System' - swig_objdecls = [ '%include "python/swig/system.i"' ] + + @classmethod + def swig_objdecls(cls, code): + code('%include "python/swig/system.i"') physmem = Param.PhysicalMemory(Parent.any, "physical memory") mem_mode = Param.MemoryMode('atomic', "The mode the memory system is in") |