sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

scons: use code_formatter wherever we can in the build system

Browse source
This commit is contained in:
Nathan Binkert 2010-09-09 14:15:41 -07:00
parent c514ad9b09
commit 710ed8f492
4 changed files with 461 additions and 345 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

412
src/SConscript
View file

@ -259,10 +259,8 @@ for opt in export_vars:
env.ConfigFile(opt) env.ConfigFile(opt)
def makeTheISA(source, target, env): def makeTheISA(source, target, env):
f = file(str(target[0]), 'w')
isas = [ src.get_contents() for src in source ] isas = [ src.get_contents() for src in source ]
target = env['TARGET_ISA'] target_isa = env['TARGET_ISA']
def define(isa): def define(isa):
return isa.upper() + '_ISA' return isa.upper() + '_ISA'
@ -270,16 +268,24 @@ def makeTheISA(source, target, env):
return isa[0].upper() + isa[1:].lower() + 'ISA' return isa[0].upper() + isa[1:].lower() + 'ISA'
print >>f, '#ifndef __CONFIG_THE_ISA_HH__' code = code_formatter()
print >>f, '#define __CONFIG_THE_ISA_HH__' code('''\
print >>f #ifndef __CONFIG_THE_ISA_HH__
#define __CONFIG_THE_ISA_HH__
''')
for i,isa in enumerate(isas): for i,isa in enumerate(isas):
print >>f, '#define %s %d' % (define(isa), i + 1) code('#define $0 $1', define(isa), i + 1)
print >>f
print >>f, '#define THE_ISA %s' % (define(target)) code('''
print >>f, '#define TheISA %s' % (namespace(target))
print >>f #define THE_ISA ${{define(target_isa)}}
print >>f, '#endif // __CONFIG_THE_ISA_HH__' #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) env.Command('config/the_isa.hh', map(Value, all_isa_list), makeTheISA)
@ -347,6 +353,7 @@ class DictImporter(object):
import m5.SimObject import m5.SimObject
import m5.params import m5.params
from m5.util import code_formatter
m5.SimObject.clear() m5.SimObject.clear()
m5.params.clear() m5.params.clear()
@ -402,7 +409,7 @@ depends = [ PySource.modules[dep].tnode for dep in module_depends ]
def makeDefinesPyFile(target, source, env): def makeDefinesPyFile(target, source, env):
build_env, hg_info = [ x.get_contents() for x in source ] build_env, hg_info = [ x.get_contents() for x in source ]
code = m5.util.code_formatter() code = code_formatter()
code(""" code("""
import m5.internal import m5.internal
import m5.util import m5.util
@ -418,7 +425,7 @@ for key,val in m5.internal.core.__dict__.iteritems():
_globals[flag] = val _globals[flag] = val
del _globals del _globals
""") """)
code.write(str(target[0])) code.write(target[0].abspath)
defines_info = [ Value(build_env), Value(env['HG_INFO']) ] defines_info = [ Value(build_env), Value(env['HG_INFO']) ]
# Generate a file with all of the compile options in it # 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 # Generate python file containing info about the M5 source code
def makeInfoPyFile(target, source, env): def makeInfoPyFile(target, source, env):
f = file(str(target[0]), 'w') code = code_formatter()
for src in source: for src in source:
data = ''.join(file(src.srcnode().abspath, 'r').xreadlines()) data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
print >>f, "%s = %s" % (src, repr(data)) code('$src = ${{repr(data)}}')
f.close() code.write(str(target[0]))
# Generate a file that wraps the basic top level files # Generate a file that wraps the basic top level files
env.Command('python/m5/info.py', env.Command('python/m5/info.py',
@ -441,12 +448,15 @@ PySource('m5', 'python/m5/info.py')
# Generate the __init__.py file for m5.objects # Generate the __init__.py file for m5.objects
def makeObjectsInitFile(target, source, env): def makeObjectsInitFile(target, source, env):
f = file(str(target[0]), 'w') code = code_formatter()
print >>f, 'from params import *' code('''\
print >>f, 'from m5.SimObject import *' from params import *
from m5.SimObject import *
''')
for module in source: for module in source:
print >>f, 'from %s import *' % module.get_contents() code('from $0 import *', module.get_contents())
f.close() code.write(str(target[0]))
# Generate an __init__.py file for the objects package # Generate an __init__.py file for the objects package
env.Command('python/m5/objects/__init__.py', env.Command('python/m5/objects/__init__.py',
@ -462,43 +472,42 @@ PySource('m5.objects', 'python/m5/objects/__init__.py')
def createSimObjectParam(target, source, env): def createSimObjectParam(target, source, env):
assert len(target) == 1 and len(source) == 1 assert len(target) == 1 and len(source) == 1
hh_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents()) name = str(source[0].get_contents())
obj = sim_objects[name] obj = sim_objects[name]
print >>hh_file, obj.cxx_decl() code = code_formatter()
hh_file.close() obj.cxx_decl(code)
code.write(target[0].abspath)
def createSwigParam(target, source, env): def createSwigParam(target, source, env):
assert len(target) == 1 and len(source) == 1 assert len(target) == 1 and len(source) == 1
i_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents()) name = str(source[0].get_contents())
param = all_params[name] param = all_params[name]
for line in param.swig_decl(): code = code_formatter()
print >>i_file, line param.swig_decl(code)
i_file.close() code.write(target[0].abspath)
def createEnumStrings(target, source, env): def createEnumStrings(target, source, env):
assert len(target) == 1 and len(source) == 1 assert len(target) == 1 and len(source) == 1
cc_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents()) name = str(source[0].get_contents())
obj = all_enums[name] obj = all_enums[name]
print >>cc_file, obj.cxx_def() code = code_formatter()
cc_file.close() obj.cxx_def(code)
code.write(target[0].abspath)
def createEnumParam(target, source, env): def createEnumParam(target, source, env):
assert len(target) == 1 and len(source) == 1 assert len(target) == 1 and len(source) == 1
hh_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents()) name = str(source[0].get_contents())
obj = all_enums[name] obj = all_enums[name]
print >>hh_file, obj.cxx_decl() code = code_formatter()
hh_file.close() obj.cxx_decl(code)
code.write(target[0].abspath)
# Generate all of the SimObject param struct header files # Generate all of the SimObject param struct header files
params_hh_files = [] params_hh_files = []
@ -538,7 +547,6 @@ for name,enum in sorted(all_enums.iteritems()):
def buildParams(target, source, env): def buildParams(target, source, env):
names = [ s.get_contents() for s in source ] names = [ s.get_contents() for s in source ]
objs = [ sim_objects[name] for name in names ] objs = [ sim_objects[name] for name in names ]
out = file(target[0].abspath, 'w')
ordered_objs = [] ordered_objs = []
obj_seen = set() obj_seen = set()
@ -556,82 +564,67 @@ def buildParams(target, source, env):
for obj in objs: for obj in objs:
order_obj(obj) order_obj(obj)
enums = set() code = code_formatter()
predecls = [] code('%module params')
pd_seen = set()
def add_pds(*pds): code('%{')
for pd in pds: for obj in ordered_objs:
if pd not in pd_seen: code('#include "params/$obj.hh"')
predecls.append(pd) code('%}')
pd_seen.add(pd)
for obj in ordered_objs:
params = obj._params.local.values()
for param in params:
param.swig_predecls(code)
enums = set()
for obj in ordered_objs: for obj in ordered_objs:
params = obj._params.local.values() params = obj._params.local.values()
for param in params: for param in params:
ptype = param.ptype ptype = param.ptype
if issubclass(ptype, m5.params.Enum): if issubclass(ptype, m5.params.Enum) and ptype not in enums:
if ptype not in enums: enums.add(ptype)
enums.add(ptype) code('%include "enums/$0.hh"', ptype.__name__)
pds = param.swig_predecls()
if isinstance(pds, (list, tuple)):
add_pds(*pds)
else:
add_pds(pds)
print >>out, '%module params'
print >>out, '%{'
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
for obj in ordered_objs: for obj in ordered_objs:
obj.swig_objdecls(code)
code()
for obj in ordered_objs:
continue
if obj.swig_objdecls: if obj.swig_objdecls:
for decl in obj.swig_objdecls: obj.swig_objdecls(code)
print >>out, decl
continue continue
class_path = obj.cxx_class.split('::') class_path = obj.cxx_class.split('::')
classname = class_path[-1] classname = class_path[-1]
namespaces = class_path[:-1] namespaces = class_path[:-1]
namespaces.reverse()
code = ''
if namespaces:
code += '// avoid name conflicts\n'
sep_string = '_COLONS_'
flat_name = sep_string.join(class_path)
code += '%%rename(%s) %s;\n' % (flat_name, classname)
code += '// stop swig from creating/wrapping default ctor/dtor\n'
code += '%%nodefault %s;\n' % classname
code += 'class %s ' % classname
if obj._base:
code += ': public %s' % obj._base.cxx_class
code += ' {};\n'
for ns in namespaces: for ns in namespaces:
new_code = 'namespace %s {\n' % ns code('namespace $ns {')
new_code += code
new_code += '}\n'
code = new_code
print >>out, code if namespaces:
code('// avoid name conflicts')
sep_string = '_COLONS_'
flat_name = sep_string.join(class_path)
code('%rename($flat_name) $classname;')
print >>out, '%%include "src/sim/sim_object_params.hh"' % obj code('// stop swig from creating/wrapping default ctor/dtor')
code('%nodefault $classname;')
if obj._base:
code('class $classname : public ${{obj._base.cxx_class}} {};')
else:
code('class $classname {};')
for ns in reversed(namespaces):
code('/* namespace $ns */ }')
code()
code('%include "src/sim/sim_object_params.hh"')
for obj in ordered_objs: 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') params_file = File('params/params.i')
names = sorted(sim_objects.keys()) names = sorted(sim_objects.keys())
@ -649,16 +642,23 @@ for swig in SwigSource.all:
# Generate the main swig init file # Generate the main swig init file
def makeSwigInit(target, source, env): def makeSwigInit(target, source, env):
f = file(str(target[0]), 'w') code = code_formatter()
print >>f, 'extern "C" {'
code('extern "C" {')
code.indent()
for module in source: for module in source:
print >>f, ' void init_%s();' % module.get_contents() code('void init_$0();', module.get_contents())
print >>f, '}' code.dedent()
print >>f, 'void initSwig() {' code('}')
code('void initSwig() {')
code.indent()
for module in source: for module in source:
print >>f, ' init_%s();' % module.get_contents() code('init_$0();', module.get_contents())
print >>f, '}' code.dedent()
f.close() code('}')
code.write(str(target[0]))
env.Command('python/swig/init.cc', env.Command('python/swig/init.cc',
map(Value, sorted(s.module for s in SwigSource.all)), map(Value, sorted(s.module for s in SwigSource.all)),
@ -689,55 +689,61 @@ def getFlags(source_flags):
# Generate traceflags.py # Generate traceflags.py
def traceFlagsPy(target, source, env): def traceFlagsPy(target, source, env):
assert(len(target) == 1) assert(len(target) == 1)
code = code_formatter()
f = file(str(target[0]), 'w')
allFlags = getFlags(source) allFlags = getFlags(source)
print >>f, 'basic = [' code('basic = [')
code.indent()
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if not compound: if not compound:
print >>f, " '%s'," % flag code("'$flag',")
print >>f, " ]" code(']')
print >>f code.dedent()
code()
print >>f, 'compound = [' code('compound = [')
print >>f, " 'All'," code.indent()
code("'All',")
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if compound: if compound:
print >>f, " '%s'," % flag code("'$flag',")
print >>f, " ]" code("]")
print >>f code.dedent()
code()
print >>f, "all = frozenset(basic + compound)" code("all = frozenset(basic + compound)")
print >>f code()
print >>f, 'compoundMap = {' code('compoundMap = {')
code.indent()
all = tuple([flag for flag,compound,desc in allFlags if not compound]) 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: for flag, compound, desc in allFlags:
if compound: if compound:
print >>f, " '%s' : %s," % (flag, compound) code("'$flag' : $compound,")
print >>f, " }" code('}')
print >>f code.dedent()
code()
print >>f, 'descriptions = {' code('descriptions = {')
print >>f, " 'All' : 'All flags'," code.indent()
code("'All' : 'All flags',")
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
print >>f, " '%s' : '%s'," % (flag, desc) code("'$flag' : '$desc',")
print >>f, " }" code("}")
code.dedent()
f.close() code.write(str(target[0]))
def traceFlagsCC(target, source, env): def traceFlagsCC(target, source, env):
assert(len(target) == 1) assert(len(target) == 1)
f = file(str(target[0]), 'w')
allFlags = getFlags(source) allFlags = getFlags(source)
code = code_formatter()
# file header # file header
print >>f, ''' code('''
/* /*
* DO NOT EDIT THIS FILE! Automatically generated * DO NOT EDIT THIS FILE! Automatically generated
*/ */
@ -747,70 +753,74 @@ def traceFlagsCC(target, source, env):
using namespace Trace; using namespace Trace;
const char *Trace::flagStrings[] = const char *Trace::flagStrings[] =
{''' {''')
code.indent()
# The string array is used by SimpleEnumParam to map the strings # The string array is used by SimpleEnumParam to map the strings
# provided by the user to enum values. # provided by the user to enum values.
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if not compound: if not compound:
print >>f, ' "%s",' % flag code('"$flag",')
print >>f, ' "All",' code('"All",')
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if compound: if compound:
print >>f, ' "%s",' % flag code('"$flag",')
code.dedent()
print >>f, '};' code('''\
print >>f };
print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1)
print >>f const int Trace::numFlagStrings = ${{len(allFlags) + 1}};
''')
#
# Now define the individual compound flag arrays. There is an array # Now define the individual compound flag arrays. There is an array
# for each compound flag listing the component base flags. # for each compound flag listing the component base flags.
#
all = tuple([flag for flag,compound,desc in allFlags if not compound]) 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: for flag, compound, desc in allFlags:
if not compound: if not compound:
print >>f, " %s," % flag code('$flag,')
print >>f, '};' code.dedent()
print >>f code('};')
code()
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if not compound: if not compound:
continue continue
print >>f, 'static const Flags %sMap[] = {' % flag code('static const Flags ${flag}Map[] = {')
code.indent()
for flag in compound: for flag in compound:
print >>f, " %s," % flag code('$flag,')
print >>f, " (Flags)-1" code('(Flags)-1')
print >>f, '};' code.dedent()
print >>f code('};')
code()
#
# Finally the compoundFlags[] array maps the compound flags # Finally the compoundFlags[] array maps the compound flags
# to their individual arrays/ # to their individual arrays/
# code('const Flags *Trace::compoundFlags[] = {')
print >>f, 'const Flags *Trace::compoundFlags[] =' code.indent()
print >>f, '{' code('AllMap,')
print >>f, ' AllMap,'
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if compound: if compound:
print >>f, ' %sMap,' % flag code('${flag}Map,')
# file trailer # file trailer
print >>f, '};' code.dedent()
code('};')
f.close() code.write(str(target[0]))
def traceFlagsHH(target, source, env): def traceFlagsHH(target, source, env):
assert(len(target) == 1) assert(len(target) == 1)
f = file(str(target[0]), 'w')
allFlags = getFlags(source) allFlags = getFlags(source)
code = code_formatter()
# file header boilerplate # file header boilerplate
print >>f, ''' code('''\
/* /*
* DO NOT EDIT THIS FILE! * DO NOT EDIT THIS FILE!
* *
@ -822,36 +832,41 @@ def traceFlagsHH(target, source, env):
namespace Trace { namespace Trace {
enum Flags {''' enum Flags {''')
# Generate the enum. Base flags come first, then compound flags. # Generate the enum. Base flags come first, then compound flags.
idx = 0 idx = 0
code.indent()
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if not compound: if not compound:
print >>f, ' %s = %d,' % (flag, idx) code('$flag = $idx,')
idx += 1 idx += 1
numBaseFlags = idx numBaseFlags = idx
print >>f, ' NumFlags = %d,' % idx code('NumFlags = $idx,')
code.dedent()
code()
# put a comment in here to separate base from compound flags # 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. // The remaining enum values are *not* valid indices for Trace::flags.
// They are "compound" flags, which correspond to sets of base // 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 idx += 1
for flag, compound, desc in allFlags: for flag, compound, desc in allFlags:
if compound: if compound:
print >>f, ' %s = %d,' % (flag, idx) code('$flag = $idx,')
idx += 1 idx += 1
numCompoundFlags = idx - numBaseFlags numCompoundFlags = idx - numBaseFlags
print >>f, ' NumCompoundFlags = %d' % numCompoundFlags code('NumCompoundFlags = $numCompoundFlags')
code.dedent()
# trailer boilerplate # trailer boilerplate
print >>f, '''\ code('''\
}; // enum Flags }; // enum Flags
// Array of strings for SimpleEnumParam // Array of strings for SimpleEnumParam
@ -865,9 +880,9 @@ extern const Flags *compoundFlags[];
/* namespace Trace */ } /* namespace Trace */ }
#endif // __BASE_TRACE_FLAGS_HH__ #endif // __BASE_TRACE_FLAGS_HH__
''' ''')
f.close() code.write(str(target[0]))
flags = map(Value, trace_flags.values()) flags = map(Value, trace_flags.values())
env.Command('base/traceflags.py', flags, traceFlagsPy) 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''' as just bytes with a label in the data section'''
src = file(str(source[0]), 'r').read() src = file(str(source[0]), 'r').read()
dst = file(str(target[0]), 'w')
pysource = PySource.tnodes[source[0]] pysource = PySource.tnodes[source[0]]
compiled = compile(src, pysource.abspath, 'exec') compiled = compile(src, pysource.abspath, 'exec')
@ -906,15 +920,21 @@ def objectifyPyFile(target, source, env):
sym = pysource.symname sym = pysource.symname
step = 16 step = 16
print >>dst, ".data" code = code_formatter()
print >>dst, ".globl %s_beg" % sym code('''\
print >>dst, ".globl %s_end" % sym .data
print >>dst, "%s_beg:" % sym .globl ${sym}_beg
.globl ${sym}_end
${sym}_beg:''')
for i in xrange(0, len(data), step): for i in xrange(0, len(data), step):
x = array.array('B', data[i:i+step]) x = array.array('B', data[i:i+step])
print >>dst, ".byte", ','.join([str(d) for d in x]) bytes = ','.join([str(d) for d in x])
print >>dst, "%s_end:" % sym code('.byte $bytes')
print >>dst, ".long %d" % len(marshalled) code('${sym}_end:')
code('.long $0', len(marshalled))
code.write(str(target[0]))
for source in PySource.all: for source in PySource.all:
env.Command(source.assembly, source.tnode, objectifyPyFile) 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 embedded files, and then there's a list of all of the rest that
# the importer uses to load the rest on demand. # the importer uses to load the rest on demand.
def pythonInit(target, source, env): def pythonInit(target, source, env):
dst = file(str(target[0]), 'w') code = code_formatter()
def dump_mod(sym, endchar=','): def dump_mod(sym, endchar=','):
def c_str(string): def c_str(string):
if string is None: if string is None:
return "0" return "0"
return '"%s"' % string return '"%s"' % string
pysource = PySource.symnames[sym] pysource = PySource.symnames[sym]
print >>dst, ' { %s,' % c_str(pysource.arcname) arcname = c_str(pysource.arcname)
print >>dst, ' %s,' % c_str(pysource.abspath) abspath = c_str(pysource.abspath)
print >>dst, ' %s,' % c_str(pysource.modpath) modpath = c_str(pysource.modpath)
print >>dst, ' %s_beg, %s_end,' % (sym, sym) code.indent()
print >>dst, ' %s_end - %s_beg,' % (sym, sym) code('''\
print >>dst, ' *(int *)%s_end }%s' % (sym, endchar) { $arcname,
$abspath,
print >>dst, '#include "sim/init.hh"' $modpath,
${sym}_beg, ${sym}_end,
${sym}_end - ${sym}_beg,
*(int *)${sym}_end }$endchar
''')
code.dedent()
code('#include "sim/init.hh"')
for sym in source: for sym in source:
sym = sym.get_contents() 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 = " code('const EmbeddedPyModule embeddedPyImporter = ')
dump_mod("PyEMB_importer", endchar=';'); dump_mod("PyEMB_importer", endchar=';')
print >>dst code()
print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {" code('const EmbeddedPyModule embeddedPyModules[] = {')
for i,sym in enumerate(source): for i,sym in enumerate(source):
sym = sym.get_contents() sym = sym.get_contents()
if sym == "PyEMB_importer": if sym == "PyEMB_importer":
# Skip the importer since we've already exported it # Skip the importer since we've already exported it
continue continue
dump_mod(sym) dump_mod(sym)
print >>dst, " { 0, 0, 0, 0, 0, 0, 0 }" code(' { 0, 0, 0, 0, 0, 0, 0 }')
print >>dst, "};" code('};')
code.write(str(target[0]))
env.Command('sim/init_python.cc', env.Command('sim/init_python.cc',
map(Value, (s.symname for s in PySource.all)), map(Value, (s.symname for s in PySource.all)),

187
src/python/m5/SimObject.py
View file

@ -29,7 +29,7 @@
# Nathan Binkert # Nathan Binkert
import sys import sys
from types import FunctionType from types import FunctionType, MethodType
try: try:
import pydot import pydot
@ -97,6 +97,46 @@ allClasses = {}
# dict to look up SimObjects based on path # dict to look up SimObjects based on path
instanceDict = {} 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 # The metaclass for SimObject. This class controls how new classes
# that derive from SimObject are instantiated, and provides inherited # that derive from SimObject are instantiated, and provides inherited
# class behavior (just like a class controls how instances of that # class behavior (just like a class controls how instances of that
@ -106,9 +146,9 @@ class MetaSimObject(type):
init_keywords = { 'abstract' : bool, init_keywords = { 'abstract' : bool,
'cxx_class' : str, 'cxx_class' : str,
'cxx_type' : str, 'cxx_type' : str,
'cxx_predecls' : list, 'cxx_predecls' : MethodType,
'swig_objdecls' : list, 'swig_objdecls' : MethodType,
'swig_predecls' : list, 'swig_predecls' : MethodType,
'type' : str } 'type' : str }
# Attributes that can be set any time # Attributes that can be set any time
keywords = { 'check' : FunctionType } keywords = { 'check' : FunctionType }
@ -127,9 +167,7 @@ class MetaSimObject(type):
cls_dict = {} cls_dict = {}
value_dict = {} value_dict = {}
for key,val in dict.items(): for key,val in dict.items():
if key.startswith('_') or isinstance(val, (FunctionType, if public_value(key, val):
classmethod,
type)):
cls_dict[key] = val cls_dict[key] = val
else: else:
# must be a param/port setting # must be a param/port setting
@ -190,24 +228,16 @@ class MetaSimObject(type):
cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class'] cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class']
if 'cxx_predecls' not in cls._value_dict: if 'cxx_predecls' not in cls.__dict__:
# A forward class declaration is sufficient since we are m = MethodType(default_cxx_predecls, cls, MetaSimObject)
# just declaring a pointer. setattr(cls, 'cxx_predecls', m)
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: if 'swig_predecls' not in cls.__dict__:
# A forward class declaration is sufficient since we are setattr(cls, 'swig_predecls', getattr(cls, 'cxx_predecls'))
# just declaring a pointer.
cls._value_dict['swig_predecls'] = \
cls._value_dict['cxx_predecls']
if 'swig_objdecls' not in cls._value_dict: if 'swig_objdecls' not in cls.__dict__:
cls._value_dict['swig_objdecls'] = [] m = MethodType(default_swig_objdecls, cls, MetaSimObject)
setattr(cls, 'swig_objdecls', m)
# Now process the _value_dict items. They could be defining # Now process the _value_dict items. They could be defining
# new (or overriding existing) parameters or ports, setting # new (or overriding existing) parameters or ports, setting
@ -282,7 +312,7 @@ class MetaSimObject(type):
# instance of class cls). # instance of class cls).
def __setattr__(cls, attr, value): def __setattr__(cls, attr, value):
# normal processing for private attributes # normal processing for private attributes
if attr.startswith('_'): if public_value(attr, value):
type.__setattr__(cls, attr, value) type.__setattr__(cls, attr, value)
return return
@ -328,9 +358,12 @@ class MetaSimObject(type):
def __str__(cls): def __str__(cls):
return cls.__name__ return cls.__name__
def cxx_decl(cls): def cxx_decl(cls, code):
code = "#ifndef __PARAMS__%s\n" % cls code('''\
code += "#define __PARAMS__%s\n\n" % cls #ifndef __PARAMS__${cls}__
#define __PARAMS__${cls}__
''')
# The 'dict' attribute restricts us to the params declared in # The 'dict' attribute restricts us to the params declared in
# the object itself, not including inherited params (which # the object itself, not including inherited params (which
@ -344,59 +377,57 @@ class MetaSimObject(type):
print params print params
raise raise
# get a list of lists of predeclaration lines # get all predeclarations
predecls = [] cls.cxx_predecls(code)
predecls.extend(cls.cxx_predecls) for param in params:
for p in params: param.cxx_predecls(code)
predecls.extend(p.cxx_predecls()) code()
# 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";
if cls._base: 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: for ptype in ptypes:
if issubclass(ptype, Enum): if issubclass(ptype, Enum):
code += '#include "enums/%s.hh"\n' % ptype.__name__ code('#include "enums/${{ptype.__name__}}.hh"')
code += "\n\n" code()
code += cls.cxx_struct(cls._base, params) cls.cxx_struct(code, cls._base, params)
# close #ifndef __PARAMS__* guard # close #ifndef __PARAMS__* guard
code += "\n#endif\n" code()
code('#endif // __PARAMS__${cls}__')
return code return code
def cxx_struct(cls, base, params): def cxx_struct(cls, code, base, params):
if cls == SimObject: 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 # now generate the actual param struct
code = "struct %sParams" % cls code("struct ${cls}Params")
if base: if base:
code += " : public %sParams" % base.type code(" : public ${{base.type}}Params")
code += "\n{\n" code("{")
if not hasattr(cls, 'abstract') or not cls.abstract: if not hasattr(cls, 'abstract') or not cls.abstract:
if 'type' in cls.__dict__: if 'type' in cls.__dict__:
code += " %s create();\n" % cls.cxx_type code(" ${{cls.cxx_type}} create();")
decls = [p.cxx_decl() for p in params]
decls.sort()
code += "".join([" %s\n" % d for d in decls])
code += "};\n"
return code code.indent()
for param in params:
param.cxx_decl(code)
code.dedent()
code('};')
def swig_decl(cls): def swig_decl(cls, code):
code = '%%module %s\n' % cls code('''\
%module $cls
code += '%{\n' %{
code += '#include "params/%s.hh"\n' % cls #include "params/$cls.hh"
code += '%}\n\n' %}
''')
# The 'dict' attribute restricts us to the params declared in # The 'dict' attribute restricts us to the params declared in
# the object itself, not including inherited params (which # the object itself, not including inherited params (which
@ -405,32 +436,22 @@ class MetaSimObject(type):
params = cls._params.local.values() params = cls._params.local.values()
ptypes = [p.ptype for p in params] ptypes = [p.ptype for p in params]
# get a list of lists of predeclaration lines # get all predeclarations
predecls = [] for param in params:
predecls.extend([ p.swig_predecls() for p in params ]) param.swig_predecls(code)
# flatten code()
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";
if cls._base: 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: for ptype in ptypes:
if issubclass(ptype, Enum): if issubclass(ptype, Enum):
code += '%%import "enums/%s.hh"\n' % ptype.__name__ code('%import "enums/${{ptype.__name__}}.hh"')
code += "\n\n" code()
code += '%%import "params/%s_type.hh"\n\n' % cls code('%import "params/${cls}_type.hh"')
code += '%%include "params/%s.hh"\n\n' % cls code('%include "params/${cls}.hh"')
return code
# The SimObject class is the root of the special hierarchy. Most of # The SimObject class is the root of the special hierarchy. Most of
# the code in this class deals with the configuration hierarchy itself # the code in this class deals with the configuration hierarchy itself
@ -442,7 +463,9 @@ class SimObject(object):
type = 'SimObject' type = 'SimObject'
abstract = True 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 # Initialize new instance. For objects with SimObject-valued
# children, we need to recursively clone the classes represented # children, we need to recursively clone the classes represented

202
src/python/m5/params.py
View file

@ -80,8 +80,13 @@ class MetaParamValue(type):
class ParamValue(object): class ParamValue(object):
__metaclass__ = MetaParamValue __metaclass__ = MetaParamValue
cxx_predecls = [] @classmethod
swig_predecls = [] def cxx_predecls(cls, code):
pass
@classmethod
def swig_predecls(cls, code):
pass
# default for printing to .ini file is regular string conversion. # default for printing to .ini file is regular string conversion.
# will be overridden in some cases # will be overridden in some cases
@ -152,14 +157,14 @@ class ParamDesc(object):
return value return value
return self.ptype(value) return self.ptype(value)
def cxx_predecls(self): def cxx_predecls(self, code):
return self.ptype.cxx_predecls self.ptype.cxx_predecls(code)
def swig_predecls(self): def swig_predecls(self, code):
return self.ptype.swig_predecls self.ptype.swig_predecls(code)
def cxx_decl(self): def cxx_decl(self, code):
return '%s %s;' % (self.ptype.cxx_type, self.name) code('${{self.ptype.cxx_type}} ${{self.name}};')
# Vector-valued parameter description. Just like ParamDesc, except # Vector-valued parameter description. Just like ParamDesc, except
# that the value is a vector (list) of the specified type instead of a # that the value is a vector (list) of the specified type instead of a
@ -235,20 +240,25 @@ class VectorParamDesc(ParamDesc):
else: else:
return VectorParamValue(tmp_list) return VectorParamValue(tmp_list)
def swig_predecls(self): def swig_predecls(self, code):
return ['%%include "%s_vptype.i"' % self.ptype_str] 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) cxx_type = re.sub('std::', '', self.ptype.cxx_type)
vdecl = 'namespace std { %%template(vector_%s) vector< %s >; }' % \ code('%include "std_vector.i"')
(self.ptype_str, cxx_type) self.ptype.swig_predecls(code)
return ['%include "std_vector.i"'] + self.ptype.swig_predecls + [vdecl] code('''\
namespace std {
%template(vector_${{self.ptype_str}}) vector< $cxx_type >;
}
''')
def cxx_predecls(self): def cxx_predecls(self, code):
return ['#include <vector>'] + self.ptype.cxx_predecls code('#include <vector>')
self.ptype.cxx_predecls(code)
def cxx_decl(self): def cxx_decl(self, code):
return 'std::vector< %s > %s;' % (self.ptype.cxx_type, self.name) code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
class ParamFactory(object): class ParamFactory(object):
def __init__(self, param_desc_class, ptype_str = None): def __init__(self, param_desc_class, ptype_str = None):
@ -291,10 +301,14 @@ VectorParam = ParamFactory(VectorParamDesc)
# built-in str class. # built-in str class.
class String(ParamValue,str): class String(ParamValue,str):
cxx_type = 'std::string' cxx_type = 'std::string'
cxx_predecls = ['#include <string>']
swig_predecls = ['%include "std_string.i"\n' + @classmethod
'%apply const std::string& {std::string *};'] def cxx_predecls(self, code):
swig_predecls = ['%include "std_string.i"' ] code('#include <string>')
@classmethod
def swig_predecls(cls, code):
code('%include "std_string.i"')
def getValue(self): def getValue(self):
return self return self
@ -350,15 +364,6 @@ class CheckedIntType(MetaParamValue):
if name == 'CheckedInt': if name == 'CheckedInt':
return 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, 'min') and hasattr(cls, 'max')):
if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')): if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')):
panic("CheckedInt subclass %s must define either\n" \ panic("CheckedInt subclass %s must define either\n" \
@ -393,6 +398,17 @@ class CheckedInt(NumericParamValue):
% type(value).__name__ % type(value).__name__
self._check() 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): def getValue(self):
return long(self.value) return long(self.value)
@ -476,8 +492,6 @@ class MetaRange(MetaParamValue):
if name == 'Range': if name == 'Range':
return return
cls.cxx_type = 'Range< %s >' % cls.type.cxx_type cls.cxx_type = 'Range< %s >' % cls.type.cxx_type
cls.cxx_predecls = \
['#include "base/range.hh"'] + cls.type.cxx_predecls
class Range(ParamValue): class Range(ParamValue):
__metaclass__ = MetaRange __metaclass__ = MetaRange
@ -521,9 +535,17 @@ class Range(ParamValue):
def __str__(self): def __str__(self):
return '%s:%s' % (self.first, self.second) 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): class AddrRange(Range):
type = Addr type = Addr
swig_predecls = ['%include "python/swig/range.i"']
@classmethod
def swig_predecls(cls, code):
code('%include "python/swig/range.i"')
def getValue(self): def getValue(self):
from m5.objects.params import AddrRange from m5.objects.params import AddrRange
@ -535,7 +557,10 @@ class AddrRange(Range):
class TickRange(Range): class TickRange(Range):
type = Tick type = Tick
swig_predecls = ['%include "python/swig/range.i"']
@classmethod
def swig_predecls(cls, code):
code('%include "python/swig/range.i"')
def getValue(self): def getValue(self):
from m5.objects.params import TickRange from m5.objects.params import TickRange
@ -589,8 +614,15 @@ def NextEthernetAddr():
class EthernetAddr(ParamValue): class EthernetAddr(ParamValue):
cxx_type = 'Net::EthAddr' 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): def __init__(self, value):
if value == NextEthernetAddr: if value == NextEthernetAddr:
self.value = value self.value = value
@ -661,8 +693,15 @@ def parse_time(value):
class Time(ParamValue): class Time(ParamValue):
cxx_type = 'tm' 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): def __init__(self, value):
self.value = parse_time(value) self.value = parse_time(value)
@ -749,34 +788,44 @@ class MetaEnum(MetaParamValue):
# Generate C++ class declaration for this enum type. # Generate C++ class declaration for this enum type.
# Note that we wrap the enum in a class/struct to act as a namespace, # 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. # 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__ name = cls.__name__
code = "#ifndef __ENUM__%s\n" % name code('''\
code += '#define __ENUM__%s\n' % name #ifndef __ENUM__${name}__
code += '\n' #define __ENUM__${name}__
code += 'namespace Enums {\n'
code += ' enum %s {\n' % name
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): namespace Enums {
name = cls.__name__ enum $name {
code = '#include "enums/%s.hh"\n' % name ''')
code += 'namespace Enums {\n' code.indent(2)
code += ' const char *%sStrings[Num_%s] =\n' % (name, name)
code += ' {\n'
for val in cls.vals: for val in cls.vals:
code += ' "%s",\n' % val code('$val = ${{cls.map[val]}},')
code += ' };\n' code('Num_$name = ${{len(cls.vals)}},')
code += '}\n' code.dedent(2)
return code code('''\
};
extern const char *${name}Strings[Num_${name}];
}
#endif // __ENUM__${name}__
''')
def cxx_def(cls, code):
name = cls.__name__
code('''\
#include "enums/${name}.hh"
namespace Enums {
const char *${name}Strings[Num_${name}] =
{
''')
code.indent(2)
for val in cls.vals:
code('"$val",')
code.dedent(2)
code('''
};
/* namespace Enums */ }
''')
# Base class for enum types. # Base class for enum types.
class Enum(ParamValue): class Enum(ParamValue):
@ -800,9 +849,15 @@ frequency_tolerance = 0.001 # 0.1%
class TickParamValue(NumericParamValue): class TickParamValue(NumericParamValue):
cxx_type = 'Tick' cxx_type = 'Tick'
cxx_predecls = ['#include "base/types.hh"']
swig_predecls = ['%import "stdint.i"\n' + @classmethod
'%import "base/types.hh"'] 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): def getValue(self):
return long(self.value) return long(self.value)
@ -878,9 +933,16 @@ class Frequency(TickParamValue):
# An explicit conversion to a Latency or Frequency must be made first. # An explicit conversion to a Latency or Frequency must be made first.
class Clock(ParamValue): class Clock(ParamValue):
cxx_type = 'Tick' cxx_type = 'Tick'
cxx_predecls = ['#include "base/types.hh"']
swig_predecls = ['%import "stdint.i"\n' + @classmethod
'%import "base/types.hh"'] 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): def __init__(self, value):
if isinstance(value, (Latency, Clock)): if isinstance(value, (Latency, Clock)):
self.ticks = value.ticks self.ticks = value.ticks

5
src/sim/System.py
View file

@ -37,7 +37,10 @@ class MemoryMode(Enum): vals = ['invalid', 'atomic', 'timing']
class System(SimObject): class System(SimObject):
type = 'System' 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") physmem = Param.PhysicalMemory(Parent.any, "physical memory")
mem_mode = Param.MemoryMode('atomic', "The mode the memory system is in") mem_mode = Param.MemoryMode('atomic', "The mode the memory system is in")