summaryrefslogtreecommitdiff
path: root/src/python
diff options
context:
space:
mode:
Diffstat (limited to 'src/python')
-rw-r--r--src/python/m5/config.py196
-rw-r--r--src/python/m5/multidict.py24
2 files changed, 163 insertions, 57 deletions
diff --git a/src/python/m5/config.py b/src/python/m5/config.py
index f6a2a84fb..9de768d18 100644
--- a/src/python/m5/config.py
+++ b/src/python/m5/config.py
@@ -27,11 +27,10 @@
# Authors: Steve Reinhardt
# Nathan Binkert
-from __future__ import generators
import os, re, sys, types, inspect
import m5
-panic = m5.panic
+from m5 import panic
from convert import *
from multidict import multidict
@@ -137,6 +136,13 @@ class Singleton(type):
def isSimObject(value):
return isinstance(value, SimObject)
+def isSimObjectClass(value):
+ try:
+ return issubclass(value, SimObject)
+ except TypeError:
+ # happens if value is not a class at all
+ return False
+
def isSimObjSequence(value):
if not isinstance(value, (list, tuple)):
return False
@@ -147,6 +153,16 @@ def isSimObjSequence(value):
return True
+def isSimObjClassSequence(value):
+ if not isinstance(value, (list, tuple)):
+ return False
+
+ for val in value:
+ if not isNullPointer(val) and not isSimObjectClass(val):
+ return False
+
+ return True
+
def isNullPointer(value):
return isinstance(value, NullSimObject)
@@ -170,19 +186,26 @@ class MetaSimObject(type):
# and only allow "private" attributes to be passed to the base
# __new__ (starting with underscore).
def __new__(mcls, name, bases, dict):
- # Copy "private" attributes (including special methods such as __new__)
- # to the official dict. Everything else goes in _init_dict to be
- # filtered in __init__.
- cls_dict = {}
- for key,val in dict.items():
- if key.startswith('_'):
- cls_dict[key] = val
- del dict[key]
- cls_dict['_init_dict'] = dict
+ if dict.has_key('_init_dict'):
+ # must have been called from makeSubclass() rather than
+ # via Python class declaration; bypass filtering process.
+ cls_dict = dict
+ else:
+ # Copy "private" attributes (including special methods
+ # such as __new__) to the official dict. Everything else
+ # goes in _init_dict to be filtered in __init__.
+ cls_dict = {}
+ for key,val in dict.items():
+ if key.startswith('_'):
+ cls_dict[key] = val
+ del dict[key]
+ cls_dict['_init_dict'] = dict
return super(MetaSimObject, mcls).__new__(mcls, name, bases, cls_dict)
- # initialization
+ # subclass initialization
def __init__(cls, name, bases, dict):
+ # calls type.__init__()... I think that's a no-op, but leave
+ # it here just in case it's not.
super(MetaSimObject, cls).__init__(name, bases, dict)
# initialize required attributes
@@ -197,27 +220,13 @@ class MetaSimObject(type):
base = bases[0]
+ # the only time the following is not true is when we define
+ # the SimObject class itself
if isinstance(base, MetaSimObject):
cls._params.parent = base._params
cls._values.parent = base._values
- # If your parent has a value in it that's a config node, clone
- # it. Do this now so if we update any of the values'
- # attributes we are updating the clone and not the original.
- for key,val in base._values.iteritems():
-
- # don't clone if (1) we're about to overwrite it with
- # a local setting or (2) we've already cloned a copy
- # from an earlier (more derived) base
- if cls._init_dict.has_key(key) or cls._values.has_key(key):
- continue
-
- if isSimObject(val):
- cls._values[key] = val()
- elif isSimObjSequence(val) and len(val):
- cls._values[key] = [ v() for v in val ]
-
- # now process remaining _init_dict items
+ # now process the _init_dict items
for key,val in cls._init_dict.items():
if isinstance(val, (types.FunctionType, types.TypeType)):
type.__setattr__(cls, key, val)
@@ -234,6 +243,33 @@ class MetaSimObject(type):
else:
setattr(cls, key, val)
+ # Pull the deep-copy memoization dict out of the class dict if
+ # it's there...
+ memo = cls.__dict__.get('_memo', {})
+
+ # Handle SimObject values
+ for key,val in cls._values.iteritems():
+ # SimObject instances need to be promoted to classes.
+ # Existing classes should not have any instance values, so
+ # these can only occur at the lowest level dict (the
+ # parameters just being set in this class definition).
+ if isSimObject(val):
+ assert(val == cls._values.local[key])
+ cls._values[key] = val.makeClass(memo)
+ elif isSimObjSequence(val) and len(val):
+ assert(val == cls._values.local[key])
+ cls._values[key] = [ v.makeClass(memo) for v in val ]
+ # SimObject classes need to be subclassed so that
+ # parameters that get set at this level only affect this
+ # level and derivatives.
+ elif isSimObjectClass(val):
+ assert(not cls._values.local.has_key(key))
+ cls._values[key] = val.makeSubclass({}, memo)
+ elif isSimObjClassSequence(val) and len(val):
+ assert(not cls._values.local.has_key(key))
+ cls._values[key] = [ v.makeSubclass({}, memo) for v in val ]
+
+
def _set_keyword(cls, keyword, val, kwtype):
if not isinstance(val, kwtype):
raise TypeError, 'keyword %s has bad type %s (expecting %s)' % \
@@ -284,6 +320,22 @@ class MetaSimObject(type):
raise AttributeError, \
"object '%s' has no attribute '%s'" % (cls.__name__, attr)
+ # Create a subclass of this class. Basically a function interface
+ # to the standard Python class definition mechanism, primarily for
+ # internal use. 'memo' dict param supports "deep copy" (really
+ # "deep subclass") operations... within a given operation,
+ # multiple references to a class should result in a single
+ # subclass object with multiple references to it (as opposed to
+ # mutiple unique subclasses).
+ def makeSubclass(cls, init_dict, memo = {}):
+ subcls = memo.get(cls)
+ if not subcls:
+ name = cls.__name__ + '_' + str(cls._anon_subclass_counter)
+ cls._anon_subclass_counter += 1
+ subcls = MetaSimObject(name, (cls,),
+ { '_init_dict': init_dict, '_memo': memo })
+ return subcls
+
# The ConfigNode class is the root of the special hierarchy. Most of
# the code in this class deals with the configuration hierarchy itself
# (parent/child node relationships).
@@ -292,27 +344,78 @@ class SimObject(object):
# get this metaclass.
__metaclass__ = MetaSimObject
- def __init__(self, _value_parent = None, **kwargs):
+ # __new__ operator allocates new instances of the class. We
+ # override it here just to support "deep instantiation" operation
+ # via the _memo dict. When recursively instantiating an object
+ # hierarchy we want to make sure that each class is instantiated
+ # only once, and that if there are multiple references to the same
+ # original class, we end up with the corresponding instantiated
+ # references all pointing to the same instance.
+ def __new__(cls, _memo = None, **kwargs):
+ if _memo is not None and _memo.has_key(cls):
+ # return previously instantiated object
+ assert(len(kwargs) == 0)
+ return _memo[cls]
+ else:
+ # Need a new one... if it needs to be memoized, this will
+ # happen in __init__. We defer the insertion until then
+ # so __init__ can use the memo dict to tell whether or not
+ # to perform the initialization.
+ return super(SimObject, cls).__new__(cls, **kwargs)
+
+ # Initialize new instance previously allocated by __new__. For
+ # objects with SimObject-valued params, we need to recursively
+ # instantiate the classes represented by those param values as
+ # well (in a consistent "deep copy"-style fashion; see comment
+ # above).
+ def __init__(self, _memo = None, **kwargs):
+ if _memo is not None:
+ # We're inside a "deep instantiation"
+ assert(isinstance(_memo, dict))
+ assert(len(kwargs) == 0)
+ if _memo.has_key(self.__class__):
+ # __new__ returned an existing, already initialized
+ # instance, so there's nothing to do here
+ assert(_memo[self.__class__] == self)
+ return
+ # no pre-existing object, so remember this one here
+ _memo[self.__class__] = self
+ else:
+ # This is a new top-level instantiation... don't memoize
+ # this objcet, but prepare to memoize any recursively
+ # instantiated objects.
+ _memo = {}
+
self._children = {}
- if _value_parent and type(_value_parent) != type(self):
- # this was called as a type conversion rather than a clone
- raise TypeError, "Cannot convert %s to %s" % \
- (_value_parent.__class__.__name__, self.__class__.__name__)
- if not _value_parent:
- _value_parent = self.__class__
- # clone values
- self._values = multidict(_value_parent._values)
- for key,val in _value_parent._values.iteritems():
- if isSimObject(val):
- setattr(self, key, val())
- elif isSimObjSequence(val) and len(val):
- setattr(self, key, [ v() for v in val ])
+ # Inherit parameter values from class using multidict so
+ # individual value settings can be overridden.
+ self._values = multidict(self.__class__._values)
+ # For SimObject-valued parameters, the class should have
+ # classes (not instances) for the values. We need to
+ # instantiate these classes rather than just inheriting the
+ # class object.
+ for key,val in self.__class__._values.iteritems():
+ if isSimObjectClass(val):
+ setattr(self, key, val(_memo))
+ elif isSimObjClassSequence(val) and len(val):
+ setattr(self, key, [ v(_memo) for v in val ])
# apply attribute assignments from keyword args, if any
for key,val in kwargs.iteritems():
setattr(self, key, val)
+ # Use this instance as a template to create a new class.
+ def makeClass(self, memo = {}):
+ cls = memo.get(self)
+ if not cls:
+ cls = self.__class__.makeSubclass(self._values.local)
+ memo[self] = cls
+ return cls
+
+ # Direct instantiation of instances (cloning) is no longer
+ # allowed; must generate class from instance first.
def __call__(self, **kwargs):
- return self.__class__(_value_parent = self, **kwargs)
+ raise TypeError, "cannot instantiate SimObject; "\
+ "use makeClass() to make class first"
def __getattr__(self, attr):
if self._values.has_key(attr):
@@ -1069,7 +1172,10 @@ class EthernetAddr(ParamValue):
def __str__(self):
if self.value == NextEthernetAddr:
- return self.addr
+ if hasattr(self, 'addr'):
+ return self.addr
+ else:
+ return "NextEthernetAddr (unresolved)"
else:
return self.value
diff --git a/src/python/m5/multidict.py b/src/python/m5/multidict.py
index 698e85b26..34fc3139b 100644
--- a/src/python/m5/multidict.py
+++ b/src/python/m5/multidict.py
@@ -31,7 +31,7 @@ __all__ = [ 'multidict' ]
class multidict(object):
__nodefault = object()
def __init__(self, parent = {}, **kwargs):
- self.dict = dict(**kwargs)
+ self.local = dict(**kwargs)
self.parent = parent
self.deleted = {}
@@ -42,11 +42,11 @@ class multidict(object):
return `dict(self.items())`
def __contains__(self, key):
- return self.dict.has_key(key) or self.parent.has_key(key)
+ return self.local.has_key(key) or self.parent.has_key(key)
def __delitem__(self, key):
try:
- del self.dict[key]
+ del self.local[key]
except KeyError, e:
if key in self.parent:
self.deleted[key] = True
@@ -55,11 +55,11 @@ class multidict(object):
def __setitem__(self, key, value):
self.deleted.pop(key, False)
- self.dict[key] = value
+ self.local[key] = value
def __getitem__(self, key):
try:
- return self.dict[key]
+ return self.local[key]
except KeyError, e:
if not self.deleted.get(key, False) and key in self.parent:
return self.parent[key]
@@ -67,15 +67,15 @@ class multidict(object):
raise KeyError, e
def __len__(self):
- return len(self.dict) + len(self.parent)
+ return len(self.local) + len(self.parent)
def next(self):
- for key,value in self.dict.items():
+ for key,value in self.local.items():
yield key,value
if self.parent:
for key,value in self.parent.next():
- if key not in self.dict and key not in self.deleted:
+ if key not in self.local and key not in self.deleted:
yield key,value
def has_key(self, key):
@@ -116,22 +116,22 @@ class multidict(object):
return self[key]
except KeyError:
self.deleted.pop(key, False)
- self.dict[key] = default
+ self.local[key] = default
return default
def _dump(self):
print 'multidict dump'
node = self
while isinstance(node, multidict):
- print ' ', node.dict
+ print ' ', node.local
node = node.parent
def _dumpkey(self, key):
values = []
node = self
while isinstance(node, multidict):
- if key in node.dict:
- values.append(node.dict[key])
+ if key in node.local:
+ values.append(node.local[key])
node = node.parent
print key, values