# 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: Andreas Sandberg
-# Daniel Carvalho
from __future__ import print_function
from __future__ import absolute_import
def get(self, name):
"""Get a sub class from a user provided class name or alias."""
+ real_name = self._aliases.get(name, name)
try:
- sub_cls = self._sub_classes[name]
+ sub_cls = self._sub_classes[real_name]
return sub_cls
except KeyError:
print("{} is not a valid sub-class of {}.".format(name, \
raise
def print(self):
- """Print the list of available sub-classes."""
+ """Print a list of available sub-classes and aliases."""
print("Available {} classes:".format(self.base_cls))
doc_wrapper = TextWrapper(initial_indent="\t\t",
subsequent_indent="\t\t")
- for name, cls in self._sub_classes.items():
+ for name, cls in list(self._sub_classes.items()):
print("\t{}".format(name))
# Try to extract the class documentation from the class help
for line in doc_wrapper.wrap(doc):
print(line)
+ if self._aliases:
+ print("\Aliases:")
+ for alias, target in list(self._aliases.items()):
+ print("\t{} => {}".format(alias, target))
+
def get_names(self):
- """Return a list of valid sub-class names."""
- return list(self._sub_classes.keys())
+ """Return a list of valid sub-class names and aliases."""
+ return list(self._sub_classes.keys()) + list(self._aliases.keys())
def _add_objects(self):
"""Add all sub-classes of the base class in the object hierarchy."""
for name, cls in inspect.getmembers(m5.objects, self._is_obj_class):
self._sub_classes[name] = cls
- def __init__(self, base_cls):
+ def _add_aliases(self, aliases):
+ """Add all aliases of the sub-classes."""
+ if aliases is not None:
+ for alias, target in aliases:
+ if target in self._sub_classes:
+ self._aliases[alias] = target
+
+ def __init__(self, base_cls, aliases=None):
# Base class that will be used to determine if models are of this
# object class
self.base_cls = base_cls
self._sub_classes = {}
self._add_objects()
+ # Filtered list of aliases. Only aliases for existing objects exist
+ # in this list.
+ self._aliases = {}
+ self._add_aliases(aliases)
+
class CPUList(ObjectList):
def _is_obj_class(self, cls):
"""Determine if a class is a CPU that can be instantiated"""
self._is_obj_class):
self._sub_classes[name] = cls
-bp_list = ObjectList(m5.objects.BranchPredictor)
-cpu_list = CPUList(m5.objects.BaseCPU)
-indirect_bp_list = ObjectList(m5.objects.IndirectPredictor)
+class EnumList(ObjectList):
+ """ Creates a list of possible values for a given enum class. """
+
+ def _add_objects(self):
+ """ Add all enum values to the ObjectList """
+ self._sub_classes = {}
+ for (key, value) in list(self.base_cls.__members__.items()):
+ # All Enums have a value Num_NAME at the end which we
+ # do not want to include
+ if not key.startswith("Num_"):
+ self._sub_classes[key] = value
+
+
+bp_list = ObjectList(getattr(m5.objects, 'BranchPredictor', None))
+cpu_list = CPUList(getattr(m5.objects, 'BaseCPU', None))
+hwp_list = ObjectList(getattr(m5.objects, 'BasePrefetcher', None))
+indirect_bp_list = ObjectList(getattr(m5.objects, 'IndirectPredictor', None))
+mem_list = ObjectList(getattr(m5.objects, 'AbstractMemory', None))
+dram_addr_map_list = EnumList(getattr(m5.internal.params, 'enum_AddrMap',
+ None))
+
+# Platform aliases. The platforms listed here might not be compiled,
+# we make sure they exist before we add them to the platform list.
+_platform_aliases_all = [
+ ("VExpress_GEM5", "VExpress_GEM5_V1"),
+ ]
+platform_list = ObjectList(getattr(m5.objects, 'Platform', None), \
+ _platform_aliases_all)
def _subclass_tester(name):
sub_class = getattr(m5.objects, name, None)