f4b9605bab
The wrapper_name parameter was not properly handled. Enums were always generated in the enums namespace even if required differently by wrapper_name. Change-Id: I366846ce39dfe10effc2cc145e7772a3fd171b92 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/67662 Tested-by: kokoro <noreply+kokoro@google.com> Reviewed-by: Bobby Bruce <bbruce@ucdavis.edu> Maintainer: Bobby Bruce <bbruce@ucdavis.edu>
2516 lines
73 KiB
Python
2516 lines
73 KiB
Python
# Copyright (c) 2012-2014, 2017-2019, 2021 Arm Limited
|
|
# All rights reserved.
|
|
#
|
|
# The license below extends only to copyright in the software and shall
|
|
# not be construed as granting a license to any other intellectual
|
|
# property including but not limited to intellectual property relating
|
|
# to a hardware implementation of the functionality of the software
|
|
# licensed hereunder. You may use the software subject to the license
|
|
# terms below provided that you ensure that this notice is replicated
|
|
# unmodified and in its entirety in all distributions of the software,
|
|
# modified or unmodified, in source code or in binary form.
|
|
#
|
|
# Copyright (c) 2004-2006 The Regents of The University of Michigan
|
|
# Copyright (c) 2010-2011 Advanced Micro Devices, Inc.
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met: redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer;
|
|
# redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution;
|
|
# neither the name of the copyright holders nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#####################################################################
|
|
#
|
|
# Parameter description classes
|
|
#
|
|
# The _params dictionary in each class maps parameter names to either
|
|
# a Param or a VectorParam object. These objects contain the
|
|
# parameter description string, the parameter type, and the default
|
|
# value (if any). The convert() method on these objects is used to
|
|
# force whatever value is assigned to the parameter to the appropriate
|
|
# type.
|
|
#
|
|
# Note that the default values are loaded into the class's attribute
|
|
# space when the parameter dictionary is initialized (in
|
|
# MetaSimObject._new_param()); after that point they aren't used.
|
|
#
|
|
#####################################################################
|
|
|
|
import copy
|
|
import datetime
|
|
import re
|
|
import sys
|
|
import time
|
|
import math
|
|
|
|
from . import proxy
|
|
from . import ticks
|
|
from .util import *
|
|
|
|
|
|
def isSimObject(*args, **kwargs):
|
|
from . import SimObject
|
|
|
|
return SimObject.isSimObject(*args, **kwargs)
|
|
|
|
|
|
def isSimObjectSequence(*args, **kwargs):
|
|
from . import SimObject
|
|
|
|
return SimObject.isSimObjectSequence(*args, **kwargs)
|
|
|
|
|
|
def isSimObjectClass(*args, **kwargs):
|
|
from . import SimObject
|
|
|
|
return SimObject.isSimObjectClass(*args, **kwargs)
|
|
|
|
|
|
allParams = {}
|
|
|
|
|
|
class MetaParamValue(type):
|
|
def __new__(mcls, name, bases, dct):
|
|
cls = super().__new__(mcls, name, bases, dct)
|
|
if name in allParams:
|
|
warn(
|
|
"%s already exists in allParams. This may be caused by the "
|
|
"Python 2.7 compatibility layer." % (name,)
|
|
)
|
|
allParams[name] = cls
|
|
return cls
|
|
|
|
|
|
# Dummy base class to identify types that are legitimate for SimObject
|
|
# parameters.
|
|
class ParamValue(object, metaclass=MetaParamValue):
|
|
cmd_line_settable = False
|
|
|
|
# Generate the code needed as a prerequisite for declaring a C++
|
|
# object of this type. Typically generates one or more #include
|
|
# statements. Used when declaring parameters of this type.
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
pass
|
|
|
|
@classmethod
|
|
def pybind_predecls(cls, code):
|
|
cls.cxx_predecls(code)
|
|
|
|
# default for printing to .ini file is regular string conversion.
|
|
# will be overridden in some cases
|
|
def ini_str(self):
|
|
return str(self)
|
|
|
|
# default for printing to .json file is regular string conversion.
|
|
# will be overridden in some cases, mostly to use native Python
|
|
# types where there are similar JSON types
|
|
def config_value(self):
|
|
return str(self)
|
|
|
|
# Prerequisites for .ini parsing with cxx_ini_parse
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
pass
|
|
|
|
# parse a .ini file entry for this param from string expression
|
|
# src into lvalue dest (of the param's C++ type)
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code(f"// Unhandled param type: {cls.__name__}")
|
|
code(f"{ret} false;")
|
|
|
|
# allows us to blithely call unproxy() on things without checking
|
|
# if they're really proxies or not
|
|
def unproxy(self, base):
|
|
return self
|
|
|
|
# Produce a human readable version of the stored value
|
|
def pretty_print(self, value):
|
|
return str(value)
|
|
|
|
|
|
# Regular parameter description.
|
|
class ParamDesc(object):
|
|
def __init__(self, ptype_str, ptype, *args, **kwargs):
|
|
self.ptype_str = ptype_str
|
|
# remember ptype only if it is provided
|
|
if ptype != None:
|
|
self.ptype = ptype
|
|
|
|
if args:
|
|
if len(args) == 1:
|
|
self.desc = args[0]
|
|
elif len(args) == 2:
|
|
self.default = args[0]
|
|
self.desc = args[1]
|
|
else:
|
|
raise TypeError("too many arguments")
|
|
|
|
if "desc" in kwargs:
|
|
assert not hasattr(self, "desc")
|
|
self.desc = kwargs["desc"]
|
|
del kwargs["desc"]
|
|
|
|
if "default" in kwargs:
|
|
assert not hasattr(self, "default")
|
|
self.default = kwargs["default"]
|
|
del kwargs["default"]
|
|
|
|
if kwargs:
|
|
raise TypeError(f"extra unknown kwargs {kwargs}")
|
|
|
|
if not hasattr(self, "desc"):
|
|
raise TypeError("desc attribute missing")
|
|
|
|
def __getattr__(self, attr):
|
|
if attr == "ptype":
|
|
from . import SimObject
|
|
|
|
ptype = SimObject.allClasses[self.ptype_str]
|
|
assert isSimObjectClass(ptype)
|
|
self.ptype = ptype
|
|
return ptype
|
|
|
|
raise AttributeError(
|
|
f"'{type(self).__name__}' object has no attribute '{attr}'"
|
|
)
|
|
|
|
def example_str(self):
|
|
if hasattr(self.ptype, "ex_str"):
|
|
return self.ptype.ex_str
|
|
else:
|
|
return self.ptype_str
|
|
|
|
# Is the param available to be exposed on the command line
|
|
def isCmdLineSettable(self):
|
|
if hasattr(self.ptype, "cmd_line_settable"):
|
|
return self.ptype.cmd_line_settable
|
|
else:
|
|
return False
|
|
|
|
def convert(self, value):
|
|
if isinstance(value, proxy.BaseProxy):
|
|
value.set_param_desc(self)
|
|
return value
|
|
if "ptype" not in self.__dict__ and isNullPointer(value):
|
|
# deferred evaluation of SimObject; continue to defer if
|
|
# we're just assigning a null pointer
|
|
return value
|
|
if isinstance(value, self.ptype):
|
|
return value
|
|
if isNullPointer(value) and isSimObjectClass(self.ptype):
|
|
return value
|
|
return self.ptype(value)
|
|
|
|
def pretty_print(self, value):
|
|
if isinstance(value, proxy.BaseProxy):
|
|
return str(value)
|
|
if isNullPointer(value):
|
|
return NULL
|
|
return self.ptype(value).pretty_print(value)
|
|
|
|
def cxx_predecls(self, code):
|
|
code("#include <cstddef>")
|
|
self.ptype.cxx_predecls(code)
|
|
|
|
def pybind_predecls(self, code):
|
|
self.ptype.pybind_predecls(code)
|
|
|
|
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
|
|
# single value.
|
|
|
|
|
|
class VectorParamValue(list, metaclass=MetaParamValue):
|
|
def __setattr__(self, attr, value):
|
|
raise AttributeError(
|
|
f"Not allowed to set {attr} on '{type(self).__name__}'"
|
|
)
|
|
|
|
def config_value(self):
|
|
return [v.config_value() for v in self]
|
|
|
|
def ini_str(self):
|
|
return " ".join([v.ini_str() for v in self])
|
|
|
|
def getValue(self):
|
|
return [v.getValue() for v in self]
|
|
|
|
def unproxy(self, base):
|
|
if len(self) == 1 and isinstance(self[0], proxy.BaseProxy):
|
|
# The value is a proxy (e.g. Parent.any, Parent.all or
|
|
# Parent.x) therefore try resolve it
|
|
return self[0].unproxy(base)
|
|
else:
|
|
return [v.unproxy(base) for v in self]
|
|
|
|
|
|
class SimObjectVector(VectorParamValue):
|
|
# support clone operation
|
|
def __call__(self, **kwargs):
|
|
return SimObjectVector([v(**kwargs) for v in self])
|
|
|
|
def clear_parent(self, old_parent):
|
|
for v in self:
|
|
v.clear_parent(old_parent)
|
|
|
|
def set_parent(self, parent, name):
|
|
if len(self) == 1:
|
|
self[0].set_parent(parent, name)
|
|
else:
|
|
width = int(math.ceil(math.log(len(self)) / math.log(10)))
|
|
for i, v in enumerate(self):
|
|
v.set_parent(parent, "%s%0*d" % (name, width, i))
|
|
|
|
def has_parent(self):
|
|
return any([e.has_parent() for e in self if not isNullPointer(e)])
|
|
|
|
# return 'cpu0 cpu1' etc. for print_ini()
|
|
def get_name(self):
|
|
return " ".join([v._name for v in self])
|
|
|
|
# By iterating through the constituent members of the vector here
|
|
# we can nicely handle iterating over all a SimObject's children
|
|
# without having to provide lots of special functions on
|
|
# SimObjectVector directly.
|
|
def descendants(self):
|
|
for v in self:
|
|
for obj in v.descendants():
|
|
yield obj
|
|
|
|
def get_config_as_dict(self):
|
|
a = []
|
|
for v in self:
|
|
a.append(v.get_config_as_dict())
|
|
return a
|
|
|
|
# If we are replacing an item in the vector, make sure to set the
|
|
# parent reference of the new SimObject to be the same as the parent
|
|
# of the SimObject being replaced. Useful to have if we created
|
|
# a SimObjectVector of temporary objects that will be modified later in
|
|
# configuration scripts.
|
|
def __setitem__(self, key, value):
|
|
val = self[key]
|
|
if value.has_parent():
|
|
warn(
|
|
f"SimObject {value.get_name()} already has a parent"
|
|
+ " that is being overwritten by a SimObjectVector"
|
|
)
|
|
value.set_parent(val.get_parent(), val._name)
|
|
super().__setitem__(key, value)
|
|
|
|
# Enumerate the params of each member of the SimObject vector. Creates
|
|
# strings that will allow indexing into the vector by the python code and
|
|
# allow it to be specified on the command line.
|
|
def enumerateParams(self, flags_dict={}, cmd_line_str="", access_str=""):
|
|
if hasattr(self, "_paramEnumed"):
|
|
print(f"Cycle detected enumerating params at {cmd_line_str}?!")
|
|
else:
|
|
x = 0
|
|
for vals in self:
|
|
# Each entry in the SimObjectVector should be an
|
|
# instance of a SimObject
|
|
flags_dict = vals.enumerateParams(
|
|
flags_dict,
|
|
cmd_line_str + "%d." % x,
|
|
access_str + "[%d]." % x,
|
|
)
|
|
x = x + 1
|
|
|
|
return flags_dict
|
|
|
|
|
|
class VectorParamDesc(ParamDesc):
|
|
# Convert assigned value to appropriate type. If the RHS is not a
|
|
# list or tuple, it generates a single-element list.
|
|
def convert(self, value):
|
|
if isinstance(value, (list, tuple)):
|
|
# list: coerce each element into new list
|
|
tmp_list = [ParamDesc.convert(self, v) for v in value]
|
|
elif isinstance(value, str):
|
|
# If input is a csv string
|
|
tmp_list = [
|
|
ParamDesc.convert(self, v)
|
|
for v in value.strip("[").strip("]").split(",")
|
|
]
|
|
else:
|
|
# singleton: coerce to a single-element list
|
|
tmp_list = [ParamDesc.convert(self, value)]
|
|
|
|
if isSimObjectSequence(tmp_list):
|
|
return SimObjectVector(tmp_list)
|
|
else:
|
|
return VectorParamValue(tmp_list)
|
|
|
|
# Produce a human readable example string that describes
|
|
# how to set this vector parameter in the absence of a default
|
|
# value.
|
|
def example_str(self):
|
|
s = super().example_str()
|
|
help_str = "[" + s + "," + s + ", ...]"
|
|
return help_str
|
|
|
|
# Produce a human readable representation of the value of this vector param.
|
|
def pretty_print(self, value):
|
|
if isinstance(value, (list, tuple)):
|
|
tmp_list = [ParamDesc.pretty_print(self, v) for v in value]
|
|
elif isinstance(value, str):
|
|
tmp_list = [
|
|
ParamDesc.pretty_print(self, v) for v in value.split(",")
|
|
]
|
|
else:
|
|
tmp_list = [ParamDesc.pretty_print(self, value)]
|
|
|
|
return tmp_list
|
|
|
|
# This is a helper function for the new config system
|
|
def __call__(self, value):
|
|
if isinstance(value, (list, tuple)):
|
|
# list: coerce each element into new list
|
|
tmp_list = [ParamDesc.convert(self, v) for v in value]
|
|
elif isinstance(value, str):
|
|
# If input is a csv string
|
|
tmp_list = [
|
|
ParamDesc.convert(self, v)
|
|
for v in value.strip("[").strip("]").split(",")
|
|
]
|
|
else:
|
|
# singleton: coerce to a single-element list
|
|
tmp_list = [ParamDesc.convert(self, value)]
|
|
|
|
return VectorParamValue(tmp_list)
|
|
|
|
def cxx_predecls(self, code):
|
|
code("#include <vector>")
|
|
self.ptype.cxx_predecls(code)
|
|
|
|
def pybind_predecls(self, code):
|
|
code("#include <vector>")
|
|
self.ptype.pybind_predecls(code)
|
|
|
|
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):
|
|
self.param_desc_class = param_desc_class
|
|
self.ptype_str = ptype_str
|
|
|
|
def __getattr__(self, attr):
|
|
if self.ptype_str:
|
|
attr = self.ptype_str + "." + attr
|
|
return ParamFactory(self.param_desc_class, attr)
|
|
|
|
# E.g., Param.Int(5, "number of widgets")
|
|
def __call__(self, *args, **kwargs):
|
|
ptype = None
|
|
try:
|
|
ptype = allParams[self.ptype_str]
|
|
except KeyError:
|
|
# if name isn't defined yet, assume it's a SimObject, and
|
|
# try to resolve it later
|
|
pass
|
|
return self.param_desc_class(self.ptype_str, ptype, *args, **kwargs)
|
|
|
|
|
|
Param = ParamFactory(ParamDesc)
|
|
VectorParam = ParamFactory(VectorParamDesc)
|
|
|
|
#####################################################################
|
|
#
|
|
# Parameter Types
|
|
#
|
|
# Though native Python types could be used to specify parameter types
|
|
# (the 'ptype' field of the Param and VectorParam classes), it's more
|
|
# flexible to define our own set of types. This gives us more control
|
|
# over how Python expressions are converted to values (via the
|
|
# __init__() constructor) and how these values are printed out (via
|
|
# the __str__() conversion method).
|
|
#
|
|
#####################################################################
|
|
|
|
# String-valued parameter. Just mixin the ParamValue class with the
|
|
# built-in str class.
|
|
class String(ParamValue, str):
|
|
cxx_type = "std::string"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(self, code):
|
|
code("#include <string>")
|
|
|
|
def __call__(self, value):
|
|
self = value
|
|
return value
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{dest} = {src};")
|
|
code(f"{ret} true;")
|
|
|
|
def getValue(self):
|
|
return self
|
|
|
|
|
|
# superclass for "numeric" parameter values, to emulate math
|
|
# operations in a type-safe way. e.g., a Latency times an int returns
|
|
# a new Latency object.
|
|
class NumericParamValue(ParamValue):
|
|
@staticmethod
|
|
def unwrap(v):
|
|
return v.value if isinstance(v, NumericParamValue) else v
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
def __float__(self):
|
|
return float(self.value)
|
|
|
|
def __int__(self):
|
|
return int(self.value)
|
|
|
|
# hook for bounds checking
|
|
def _check(self):
|
|
return
|
|
|
|
def __mul__(self, other):
|
|
newobj = self.__class__(self)
|
|
newobj.value *= NumericParamValue.unwrap(other)
|
|
newobj._check()
|
|
return newobj
|
|
|
|
__rmul__ = __mul__
|
|
|
|
def __truediv__(self, other):
|
|
newobj = self.__class__(self)
|
|
newobj.value /= NumericParamValue.unwrap(other)
|
|
newobj._check()
|
|
return newobj
|
|
|
|
def __floordiv__(self, other):
|
|
newobj = self.__class__(self)
|
|
newobj.value //= NumericParamValue.unwrap(other)
|
|
newobj._check()
|
|
return newobj
|
|
|
|
def __add__(self, other):
|
|
newobj = self.__class__(self)
|
|
newobj.value += NumericParamValue.unwrap(other)
|
|
newobj._check()
|
|
return newobj
|
|
|
|
def __sub__(self, other):
|
|
newobj = self.__class__(self)
|
|
newobj.value -= NumericParamValue.unwrap(other)
|
|
newobj._check()
|
|
return newobj
|
|
|
|
def __iadd__(self, other):
|
|
self.value += NumericParamValue.unwrap(other)
|
|
self._check()
|
|
return self
|
|
|
|
def __isub__(self, other):
|
|
self.value -= NumericParamValue.unwrap(other)
|
|
self._check()
|
|
return self
|
|
|
|
def __imul__(self, other):
|
|
self.value *= NumericParamValue.unwrap(other)
|
|
self._check()
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
self.value /= NumericParamValue.unwrap(other)
|
|
self._check()
|
|
return self
|
|
|
|
def __ifloordiv__(self, other):
|
|
self.value //= NumericParamValue.unwrap(other)
|
|
self._check()
|
|
return self
|
|
|
|
def __lt__(self, other):
|
|
return self.value < NumericParamValue.unwrap(other)
|
|
|
|
def config_value(self):
|
|
return self.value
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
# Assume that base/str.hh will be included anyway
|
|
# code('#include "base/str.hh"')
|
|
pass
|
|
|
|
# The default for parsing PODs from an .ini entry is to extract from an
|
|
# istringstream and let overloading choose the right type according to
|
|
# the dest type.
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{ret} to_number({src}, {dest});")
|
|
|
|
|
|
# Metaclass for bounds-checked integer parameters. See CheckedInt.
|
|
class CheckedIntType(MetaParamValue):
|
|
def __init__(cls, name, bases, dict):
|
|
super().__init__(name, bases, dict)
|
|
|
|
# CheckedInt is an abstract base class, so we actually don't
|
|
# want to do any processing on it... the rest of this code is
|
|
# just for classes that derive from CheckedInt.
|
|
if name == "CheckedInt":
|
|
return
|
|
|
|
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"
|
|
" 'min' and 'max' or 'size' and 'unsigned'\n",
|
|
name,
|
|
)
|
|
if cls.unsigned:
|
|
cls.min = 0
|
|
cls.max = 2**cls.size - 1
|
|
else:
|
|
cls.min = -(2 ** (cls.size - 1))
|
|
cls.max = (2 ** (cls.size - 1)) - 1
|
|
|
|
|
|
# Abstract superclass for bounds-checked integer parameters. This
|
|
# class is subclassed to generate parameter classes with specific
|
|
# bounds. Initialization of the min and max bounds is done in the
|
|
# metaclass CheckedIntType.__init__.
|
|
class CheckedInt(NumericParamValue, metaclass=CheckedIntType):
|
|
cmd_line_settable = True
|
|
|
|
def _check(self):
|
|
if not self.min <= self.value <= self.max:
|
|
raise TypeError(
|
|
"Integer param out of bounds %d < %d < %d"
|
|
% (self.min, self.value, self.max)
|
|
)
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, str):
|
|
self.value = convert.toInteger(value)
|
|
elif isinstance(value, (int, float, NumericParamValue)):
|
|
self.value = int(value)
|
|
else:
|
|
raise TypeError(
|
|
f"Can't convert object of type {type(value).__name__} to CheckedInt"
|
|
)
|
|
self._check()
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __index__(self):
|
|
return int(self.value)
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
# most derived types require this, so we just do it here once
|
|
code('#include "base/types.hh"')
|
|
|
|
def getValue(self):
|
|
return int(self.value)
|
|
|
|
|
|
class Int(CheckedInt):
|
|
cxx_type = "int"
|
|
size = 32
|
|
unsigned = False
|
|
|
|
|
|
class Unsigned(CheckedInt):
|
|
cxx_type = "unsigned"
|
|
size = 32
|
|
unsigned = True
|
|
|
|
|
|
class Int8(CheckedInt):
|
|
cxx_type = "int8_t"
|
|
size = 8
|
|
unsigned = False
|
|
|
|
|
|
class UInt8(CheckedInt):
|
|
cxx_type = "uint8_t"
|
|
size = 8
|
|
unsigned = True
|
|
|
|
|
|
class Int16(CheckedInt):
|
|
cxx_type = "int16_t"
|
|
size = 16
|
|
unsigned = False
|
|
|
|
|
|
class UInt16(CheckedInt):
|
|
cxx_type = "uint16_t"
|
|
size = 16
|
|
unsigned = True
|
|
|
|
|
|
class Int32(CheckedInt):
|
|
cxx_type = "int32_t"
|
|
size = 32
|
|
unsigned = False
|
|
|
|
|
|
class UInt32(CheckedInt):
|
|
cxx_type = "uint32_t"
|
|
size = 32
|
|
unsigned = True
|
|
|
|
|
|
class Int64(CheckedInt):
|
|
cxx_type = "int64_t"
|
|
size = 64
|
|
unsigned = False
|
|
|
|
|
|
class UInt64(CheckedInt):
|
|
cxx_type = "uint64_t"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
|
|
class Counter(CheckedInt):
|
|
cxx_type = "Counter"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
|
|
class Tick(CheckedInt):
|
|
cxx_type = "Tick"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
|
|
class TcpPort(CheckedInt):
|
|
cxx_type = "uint16_t"
|
|
size = 16
|
|
unsigned = True
|
|
|
|
|
|
class UdpPort(CheckedInt):
|
|
cxx_type = "uint16_t"
|
|
size = 16
|
|
unsigned = True
|
|
|
|
|
|
class Percent(CheckedInt):
|
|
cxx_type = "int"
|
|
min = 0
|
|
max = 100
|
|
|
|
|
|
class Cycles(CheckedInt):
|
|
cxx_type = "Cycles"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
def getValue(self):
|
|
from _m5.core import Cycles
|
|
|
|
return Cycles(self.value)
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
# Assume that base/str.hh will be included anyway
|
|
# code('#include "base/str.hh"')
|
|
pass
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code("uint64_t _temp;")
|
|
code(f"bool _ret = to_number({src}, _temp);")
|
|
code("if (_ret)")
|
|
code(f" {dest} = Cycles(_temp);")
|
|
code(f"{ret} _ret;")
|
|
|
|
|
|
class Float(ParamValue, float):
|
|
cxx_type = "double"
|
|
cmd_line_settable = True
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, (int, float, NumericParamValue, Float, str)):
|
|
self.value = float(value)
|
|
else:
|
|
raise TypeError(
|
|
f"Can't convert object of type {type(value).__name__} to Float"
|
|
)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def getValue(self):
|
|
return float(self.value)
|
|
|
|
def config_value(self):
|
|
return self
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <sstream>")
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{ret} (std::istringstream({src}) >> {dest}).eof();")
|
|
|
|
|
|
class MemorySize(CheckedInt):
|
|
cxx_type = "uint64_t"
|
|
ex_str = "512MiB"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, MemorySize):
|
|
self.value = value.value
|
|
else:
|
|
self.value = convert.toMemorySize(value)
|
|
self._check()
|
|
|
|
|
|
class MemorySize32(CheckedInt):
|
|
cxx_type = "uint32_t"
|
|
ex_str = "512MiB"
|
|
size = 32
|
|
unsigned = True
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, MemorySize):
|
|
self.value = value.value
|
|
else:
|
|
self.value = convert.toMemorySize(value)
|
|
self._check()
|
|
|
|
|
|
class Addr(CheckedInt):
|
|
cxx_type = "Addr"
|
|
size = 64
|
|
unsigned = True
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, Addr):
|
|
self.value = value.value
|
|
else:
|
|
try:
|
|
# Often addresses are referred to with sizes. Ex: A device
|
|
# base address is at "512MiB". Use toMemorySize() to convert
|
|
# these into addresses. If the address is not specified with a
|
|
# "size", an exception will occur and numeric translation will
|
|
# proceed below.
|
|
self.value = convert.toMemorySize(value)
|
|
except (TypeError, ValueError):
|
|
# Convert number to string and use long() to do automatic
|
|
# base conversion (requires base=0 for auto-conversion)
|
|
self.value = int(str(value), base=0)
|
|
|
|
self._check()
|
|
|
|
def __add__(self, other):
|
|
if isinstance(other, Addr):
|
|
return self.value + other.value
|
|
else:
|
|
return self.value + other
|
|
|
|
def pretty_print(self, value):
|
|
try:
|
|
val = convert.toMemorySize(value)
|
|
except TypeError:
|
|
val = int(value)
|
|
return f"0x{int(val):x}"
|
|
|
|
|
|
class PcCountPair(ParamValue):
|
|
# This parameter stores a Program Counter address and the a count value for
|
|
# the Program Counter address
|
|
cxx_type = "PcCountPair"
|
|
cmd_line_settable = True
|
|
|
|
def __init__(self, _pc, _count):
|
|
self.pc = _pc
|
|
self.count = _count
|
|
|
|
def get_pc(self):
|
|
return self.pc
|
|
|
|
def get_count(self):
|
|
return self.count
|
|
|
|
def getValue(self):
|
|
# convert Python PcCountPair into C++ PcCountPair
|
|
from _m5.pc import PcCountPair
|
|
|
|
return PcCountPair(self.pc, self.count)
|
|
|
|
def __str__(self):
|
|
return "(%i,%i)" % (self.pc, self.count)
|
|
|
|
def __eq__(self, other):
|
|
return self.pc == other.get_pc() and self.count == other.get_count()
|
|
|
|
def __hash__(self):
|
|
return hash((int(self.pc), int(self.count)))
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "cpu/probes/pc_count_pair.hh"')
|
|
|
|
@classmethod
|
|
def pybind_predecls(cls, code):
|
|
code('#include "cpu/probes/pc_count_pair.hh"')
|
|
|
|
|
|
class AddrRange(ParamValue):
|
|
cxx_type = "AddrRange"
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
# Disable interleaving and hashing by default
|
|
self.intlvBits = 0
|
|
self.intlvMatch = 0
|
|
self.masks = []
|
|
|
|
def handle_kwargs(self, kwargs):
|
|
# An address range needs to have an upper limit, specified
|
|
# either explicitly with an end, or as an offset using the
|
|
# size keyword.
|
|
if "end" in kwargs:
|
|
self.end = Addr(kwargs.pop("end"))
|
|
elif "size" in kwargs:
|
|
self.end = self.start + Addr(kwargs.pop("size"))
|
|
else:
|
|
raise TypeError("Either end or size must be specified")
|
|
|
|
# Now on to the optional bit
|
|
if "intlvMatch" in kwargs:
|
|
self.intlvMatch = int(kwargs.pop("intlvMatch"))
|
|
|
|
if "masks" in kwargs:
|
|
self.masks = [int(x) for x in list(kwargs.pop("masks"))]
|
|
self.intlvBits = len(self.masks)
|
|
else:
|
|
if "intlvBits" in kwargs:
|
|
self.intlvBits = int(kwargs.pop("intlvBits"))
|
|
self.masks = [0] * self.intlvBits
|
|
if "intlvHighBit" not in kwargs:
|
|
raise TypeError("No interleave bits specified")
|
|
intlv_high_bit = int(kwargs.pop("intlvHighBit"))
|
|
xor_high_bit = 0
|
|
if "xorHighBit" in kwargs:
|
|
xor_high_bit = int(kwargs.pop("xorHighBit"))
|
|
for i in range(0, self.intlvBits):
|
|
bit1 = intlv_high_bit - i
|
|
mask = 1 << bit1
|
|
if xor_high_bit != 0:
|
|
bit2 = xor_high_bit - i
|
|
mask |= 1 << bit2
|
|
self.masks[self.intlvBits - i - 1] = mask
|
|
|
|
if len(args) == 0:
|
|
self.start = Addr(kwargs.pop("start"))
|
|
handle_kwargs(self, kwargs)
|
|
|
|
elif len(args) == 1:
|
|
if kwargs:
|
|
self.start = Addr(args[0])
|
|
handle_kwargs(self, kwargs)
|
|
elif isinstance(args[0], (list, tuple)):
|
|
self.start = Addr(args[0][0])
|
|
self.end = Addr(args[0][1])
|
|
else:
|
|
self.start = Addr(0)
|
|
self.end = Addr(args[0])
|
|
|
|
elif len(args) == 2:
|
|
self.start = Addr(args[0])
|
|
self.end = Addr(args[1])
|
|
else:
|
|
raise TypeError("Too many arguments specified")
|
|
|
|
if kwargs:
|
|
raise TypeError(f"Too many keywords: {list(kwargs.keys())}")
|
|
|
|
def __str__(self):
|
|
if len(self.masks) == 0:
|
|
return f"{self.start}:{self.end}"
|
|
else:
|
|
return "%s:%s:%s:%s" % (
|
|
self.start,
|
|
self.end,
|
|
self.intlvMatch,
|
|
":".join(str(m) for m in self.masks),
|
|
)
|
|
|
|
def size(self):
|
|
# Divide the size by the size of the interleaving slice
|
|
return (int(self.end) - int(self.start)) >> self.intlvBits
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
Addr.cxx_predecls(code)
|
|
code('#include "base/addr_range.hh"')
|
|
|
|
@classmethod
|
|
def pybind_predecls(cls, code):
|
|
Addr.pybind_predecls(code)
|
|
code('#include "base/addr_range.hh"')
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <sstream>")
|
|
code("#include <vector>")
|
|
code('#include "base/types.hh"')
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code("bool _ret = true;")
|
|
code("uint64_t _start, _end, _intlvMatch = 0;")
|
|
code("std::vector<Addr> _masks;")
|
|
code("char _sep;")
|
|
code("std::istringstream _stream(${src});")
|
|
code("_stream >> _start;")
|
|
code("_stream.get(_sep);")
|
|
code("_ret = _sep == ':';")
|
|
code("_stream >> _end;")
|
|
code("if (!_stream.fail() && !_stream.eof()) {")
|
|
code(" _stream.get(_sep);")
|
|
code(" _ret = ret && _sep == ':';")
|
|
code(" _stream >> _intlvMatch;")
|
|
code(" while (!_stream.fail() && !_stream.eof()) {")
|
|
code(" _stream.get(_sep);")
|
|
code(" _ret = ret && _sep == ':';")
|
|
code(" Addr mask;")
|
|
code(" _stream >> mask;")
|
|
code(" _masks.push_back(mask);")
|
|
code(" }")
|
|
code("}")
|
|
code("_ret = _ret && !_stream.fail() && _stream.eof();")
|
|
code("if (_ret)")
|
|
code(" ${dest} = AddrRange(_start, _end, _masks, _intlvMatch);")
|
|
code("${ret} _ret;")
|
|
|
|
def getValue(self):
|
|
# Go from the Python class to the wrapped C++ class
|
|
from _m5.range import AddrRange
|
|
|
|
return AddrRange(
|
|
int(self.start), int(self.end), self.masks, int(self.intlvMatch)
|
|
)
|
|
|
|
def exclude(self, ranges):
|
|
pybind_exclude = list([r.getValue() for r in ranges])
|
|
pybind_include = self.getValue().exclude(pybind_exclude)
|
|
|
|
return list([AddrRange(r.start(), r.end()) for r in pybind_include])
|
|
|
|
|
|
# Boolean parameter type. Python doesn't let you subclass bool, since
|
|
# it doesn't want to let you create multiple instances of True and
|
|
# False. Thus this is a little more complicated than String.
|
|
class Bool(ParamValue):
|
|
cxx_type = "bool"
|
|
cmd_line_settable = True
|
|
|
|
def __init__(self, value):
|
|
try:
|
|
self.value = convert.toBool(value)
|
|
except TypeError:
|
|
self.value = bool(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def getValue(self):
|
|
return bool(self.value)
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
# implement truth value testing for Bool parameters so that these params
|
|
# evaluate correctly during the python configuration phase
|
|
def __bool__(self):
|
|
return bool(self.value)
|
|
|
|
# Python 2.7 uses __nonzero__ instead of __bool__
|
|
__nonzero__ = __bool__
|
|
|
|
def ini_str(self):
|
|
if self.value:
|
|
return "true"
|
|
return "false"
|
|
|
|
def config_value(self):
|
|
return self.value
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
# Assume that base/str.hh will be included anyway
|
|
# code('#include "base/str.hh"')
|
|
pass
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code(f"{ret} to_bool({src}, {dest});")
|
|
|
|
|
|
class HostSocket(ParamValue):
|
|
cxx_type = "ListenSocketConfig"
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/socket.hh"')
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, HostSocket):
|
|
self.value = value.value
|
|
else:
|
|
self.value = value
|
|
|
|
def getValue(self):
|
|
from _m5.socket import listenSocketEmptyConfig
|
|
from _m5.socket import listenSocketInetConfig
|
|
from _m5.socket import listenSocketUnixFileConfig
|
|
from _m5.socket import listenSocketUnixAbstractConfig
|
|
|
|
if isinstance(self.value, str):
|
|
if self.value[0] == "@":
|
|
return listenSocketUnixAbstractConfig(self.value[1:])
|
|
else:
|
|
d, f = os.path.split(self.value)
|
|
return listenSocketUnixFileConfig(d, f)
|
|
else:
|
|
if self.value == 0:
|
|
return listenSocketEmptyConfig()
|
|
else:
|
|
return listenSocketInetConfig(self.value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
if isinstance(self.value, str):
|
|
return self.value
|
|
else:
|
|
return "#" + str(self.value)
|
|
|
|
def ini_str(self):
|
|
if isinstance(self.value, str):
|
|
if self.value[0] == "@":
|
|
return self.value
|
|
else:
|
|
return "P" + self.value
|
|
else:
|
|
return "#" + str(self.value)
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code('#include "base/socket.hh"')
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code(f"{ret} ListenSocketConfig::parseIni({src}, {dest});")
|
|
|
|
|
|
def IncEthernetAddr(addr, val=1):
|
|
bytes = [int(x, 16) for x in addr.split(":")]
|
|
bytes[5] += val
|
|
for i in (5, 4, 3, 2, 1):
|
|
val, rem = divmod(bytes[i], 256)
|
|
bytes[i] = rem
|
|
if val == 0:
|
|
break
|
|
bytes[i - 1] += val
|
|
assert bytes[0] <= 255
|
|
return ":".join(map(lambda x: f"{x:02x}", bytes))
|
|
|
|
|
|
_NextEthernetAddr = "00:90:00:00:00:01"
|
|
|
|
|
|
def NextEthernetAddr():
|
|
global _NextEthernetAddr
|
|
|
|
value = _NextEthernetAddr
|
|
_NextEthernetAddr = IncEthernetAddr(_NextEthernetAddr, 1)
|
|
return value
|
|
|
|
|
|
class EthernetAddr(ParamValue):
|
|
cxx_type = "networking::EthAddr"
|
|
ex_str = "00:90:00:00:00:01"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/inet.hh"')
|
|
|
|
def __init__(self, value):
|
|
if value == NextEthernetAddr:
|
|
self.value = value
|
|
return
|
|
|
|
if not isinstance(value, str):
|
|
raise TypeError("expected an ethernet address and didn't get one")
|
|
|
|
bytes = value.split(":")
|
|
if len(bytes) != 6:
|
|
raise TypeError(f"invalid ethernet address {value}")
|
|
|
|
for byte in bytes:
|
|
if not 0 <= int(byte, base=16) <= 0xFF:
|
|
raise TypeError(f"invalid ethernet address {value}")
|
|
|
|
self.value = value
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def unproxy(self, base):
|
|
if self.value == NextEthernetAddr:
|
|
return EthernetAddr(self.value())
|
|
return self
|
|
|
|
def getValue(self):
|
|
from _m5.net import EthAddr
|
|
|
|
return EthAddr(self.value)
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
def ini_str(self):
|
|
return self.value
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{dest} = networking::EthAddr({src});")
|
|
code(f"{ret} true;")
|
|
|
|
|
|
# When initializing an IpAddress, pass in an existing IpAddress, a string of
|
|
# the form "a.b.c.d", or an integer representing an IP.
|
|
class IpAddress(ParamValue):
|
|
cxx_type = "networking::IpAddress"
|
|
ex_str = "127.0.0.1"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/inet.hh"')
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, IpAddress):
|
|
self.ip = value.ip
|
|
else:
|
|
try:
|
|
self.ip = convert.toIpAddress(value)
|
|
except TypeError:
|
|
self.ip = int(value)
|
|
self.verifyIp()
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
tup = [(self.ip >> i) & 0xFF for i in (24, 16, 8, 0)]
|
|
return "%d.%d.%d.%d" % tuple(tup)
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, IpAddress):
|
|
return self.ip == other.ip
|
|
elif isinstance(other, str):
|
|
try:
|
|
return self.ip == convert.toIpAddress(other)
|
|
except:
|
|
return False
|
|
else:
|
|
return self.ip == other
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
|
|
def verifyIp(self):
|
|
if self.ip < 0 or self.ip >= (1 << 32):
|
|
raise TypeError("invalid ip address %#08x" % self.ip)
|
|
|
|
def getValue(self):
|
|
from _m5.net import IpAddress
|
|
|
|
return IpAddress(self.ip)
|
|
|
|
|
|
# When initializing an IpNetmask, pass in an existing IpNetmask, a string of
|
|
# the form "a.b.c.d/n" or "a.b.c.d/e.f.g.h", or an ip and netmask as
|
|
# positional or keyword arguments.
|
|
class IpNetmask(IpAddress):
|
|
cxx_type = "networking::IpNetmask"
|
|
ex_str = "127.0.0.0/24"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/inet.hh"')
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
def handle_kwarg(self, kwargs, key, elseVal=None):
|
|
if key in kwargs:
|
|
setattr(self, key, kwargs.pop(key))
|
|
elif elseVal:
|
|
setattr(self, key, elseVal)
|
|
else:
|
|
raise TypeError(f"No value set for {key}")
|
|
|
|
if len(args) == 0:
|
|
handle_kwarg(self, kwargs, "ip")
|
|
handle_kwarg(self, kwargs, "netmask")
|
|
|
|
elif len(args) == 1:
|
|
if kwargs:
|
|
if not "ip" in kwargs and not "netmask" in kwargs:
|
|
raise TypeError("Invalid arguments")
|
|
handle_kwarg(self, kwargs, "ip", args[0])
|
|
handle_kwarg(self, kwargs, "netmask", args[0])
|
|
elif isinstance(args[0], IpNetmask):
|
|
self.ip = args[0].ip
|
|
self.netmask = args[0].netmask
|
|
else:
|
|
(self.ip, self.netmask) = convert.toIpNetmask(args[0])
|
|
|
|
elif len(args) == 2:
|
|
self.ip = args[0]
|
|
self.netmask = args[1]
|
|
else:
|
|
raise TypeError("Too many arguments specified")
|
|
|
|
if kwargs:
|
|
raise TypeError(f"Too many keywords: {list(kwargs.keys())}")
|
|
|
|
self.verify()
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
return "%s/%d" % (super().__str__(), self.netmask)
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, IpNetmask):
|
|
return self.ip == other.ip and self.netmask == other.netmask
|
|
elif isinstance(other, str):
|
|
try:
|
|
return (self.ip, self.netmask) == convert.toIpNetmask(other)
|
|
except:
|
|
return False
|
|
else:
|
|
return False
|
|
|
|
def verify(self):
|
|
self.verifyIp()
|
|
if self.netmask < 0 or self.netmask > 32:
|
|
raise TypeError("invalid netmask %d" % netmask)
|
|
|
|
def getValue(self):
|
|
from _m5.net import IpNetmask
|
|
|
|
return IpNetmask(self.ip, self.netmask)
|
|
|
|
|
|
# When initializing an IpWithPort, pass in an existing IpWithPort, a string of
|
|
# the form "a.b.c.d:p", or an ip and port as positional or keyword arguments.
|
|
class IpWithPort(IpAddress):
|
|
cxx_type = "networking::IpWithPort"
|
|
ex_str = "127.0.0.1:80"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/inet.hh"')
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
def handle_kwarg(self, kwargs, key, elseVal=None):
|
|
if key in kwargs:
|
|
setattr(self, key, kwargs.pop(key))
|
|
elif elseVal:
|
|
setattr(self, key, elseVal)
|
|
else:
|
|
raise TypeError(f"No value set for {key}")
|
|
|
|
if len(args) == 0:
|
|
handle_kwarg(self, kwargs, "ip")
|
|
handle_kwarg(self, kwargs, "port")
|
|
|
|
elif len(args) == 1:
|
|
if kwargs:
|
|
if not "ip" in kwargs and not "port" in kwargs:
|
|
raise TypeError("Invalid arguments")
|
|
handle_kwarg(self, kwargs, "ip", args[0])
|
|
handle_kwarg(self, kwargs, "port", args[0])
|
|
elif isinstance(args[0], IpWithPort):
|
|
self.ip = args[0].ip
|
|
self.port = args[0].port
|
|
else:
|
|
(self.ip, self.port) = convert.toIpWithPort(args[0])
|
|
|
|
elif len(args) == 2:
|
|
self.ip = args[0]
|
|
self.port = args[1]
|
|
else:
|
|
raise TypeError("Too many arguments specified")
|
|
|
|
if kwargs:
|
|
raise TypeError(f"Too many keywords: {list(kwargs.keys())}")
|
|
|
|
self.verify()
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
return "%s:%d" % (super().__str__(), self.port)
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, IpWithPort):
|
|
return self.ip == other.ip and self.port == other.port
|
|
elif isinstance(other, str):
|
|
try:
|
|
return (self.ip, self.port) == convert.toIpWithPort(other)
|
|
except:
|
|
return False
|
|
else:
|
|
return False
|
|
|
|
def verify(self):
|
|
self.verifyIp()
|
|
if self.port < 0 or self.port > 0xFFFF:
|
|
raise TypeError("invalid port %d" % self.port)
|
|
|
|
def getValue(self):
|
|
from _m5.net import IpWithPort
|
|
|
|
return IpWithPort(self.ip, self.port)
|
|
|
|
|
|
time_formats = [
|
|
"%a %b %d %H:%M:%S %Z %Y",
|
|
"%a %b %d %H:%M:%S %Y",
|
|
"%Y/%m/%d %H:%M:%S",
|
|
"%Y/%m/%d %H:%M",
|
|
"%Y/%m/%d",
|
|
"%m/%d/%Y %H:%M:%S",
|
|
"%m/%d/%Y %H:%M",
|
|
"%m/%d/%Y",
|
|
"%m/%d/%y %H:%M:%S",
|
|
"%m/%d/%y %H:%M",
|
|
"%m/%d/%y",
|
|
]
|
|
|
|
|
|
def parse_time(value):
|
|
from time import gmtime, strptime, struct_time, time
|
|
from datetime import datetime, date
|
|
|
|
if isinstance(value, struct_time):
|
|
return value
|
|
|
|
if isinstance(value, int):
|
|
return gmtime(value)
|
|
|
|
if isinstance(value, (datetime, date)):
|
|
return value.timetuple()
|
|
|
|
if isinstance(value, str):
|
|
if value in ("Now", "Today"):
|
|
return time.gmtime(time.time())
|
|
|
|
for format in time_formats:
|
|
try:
|
|
return strptime(value, format)
|
|
except ValueError:
|
|
pass
|
|
|
|
raise ValueError(f"Could not parse '{value}' as a time")
|
|
|
|
|
|
class Time(ParamValue):
|
|
cxx_type = "tm"
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code("#include <time.h>")
|
|
|
|
def __init__(self, value):
|
|
self.value = parse_time(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def getValue(self):
|
|
from _m5.core import tm
|
|
import calendar
|
|
|
|
return tm.gmtime(calendar.timegm(self.value))
|
|
|
|
def __str__(self):
|
|
return time.asctime(self.value)
|
|
|
|
def ini_str(self):
|
|
return str(self)
|
|
|
|
def get_config_as_dict(self):
|
|
assert false
|
|
return str(self)
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <time.h>")
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code("char *_parse_ret = strptime((${src}).c_str(),")
|
|
code(' "%a %b %d %H:%M:%S %Y", &(${dest}));')
|
|
code("${ret} _parse_ret && *_parse_ret == '\\0';")
|
|
|
|
|
|
# Enumerated types are a little more complex. The user specifies the
|
|
# type as Enum(foo) where foo is either a list or dictionary of
|
|
# alternatives (typically strings, but not necessarily so). (In the
|
|
# long run, the integer value of the parameter will be the list index
|
|
# or the corresponding dictionary value. For now, since we only check
|
|
# that the alternative is valid and then spit it into a .ini file,
|
|
# there's not much point in using the dictionary.)
|
|
|
|
# What Enum() must do is generate a new type encapsulating the
|
|
# provided list/dictionary so that specific values of the parameter
|
|
# can be instances of that type. We define two hidden internal
|
|
# classes (_ListEnum and _DictEnum) to serve as base classes, then
|
|
# derive the new type from the appropriate base class on the fly.
|
|
|
|
allEnums = {}
|
|
# Metaclass for Enum types
|
|
class MetaEnum(MetaParamValue):
|
|
def __new__(mcls, name, bases, dict):
|
|
|
|
cls = super().__new__(mcls, name, bases, dict)
|
|
allEnums[name] = cls
|
|
return cls
|
|
|
|
def __init__(cls, name, bases, init_dict):
|
|
if "map" in init_dict:
|
|
if not isinstance(cls.map, dict):
|
|
raise TypeError(
|
|
"Enum-derived class attribute 'map' "
|
|
"must be of type dict"
|
|
)
|
|
# build list of value strings from map
|
|
cls.vals = list(cls.map.keys())
|
|
cls.vals.sort()
|
|
elif "vals" in init_dict:
|
|
if not isinstance(cls.vals, list):
|
|
raise TypeError(
|
|
"Enum-derived class attribute 'vals' "
|
|
"must be of type list"
|
|
)
|
|
# build string->value map from vals sequence
|
|
cls.map = {}
|
|
for idx, val in enumerate(cls.vals):
|
|
cls.map[val] = idx
|
|
else:
|
|
raise TypeError(
|
|
"Enum-derived class must define attribute 'map' or 'vals'"
|
|
)
|
|
|
|
if cls.is_class:
|
|
cls.cxx_type = f"{name}"
|
|
else:
|
|
scope = init_dict.get("wrapper_name", "enums")
|
|
cls.cxx_type = f"{scope}::{name}"
|
|
super().__init__(name, bases, init_dict)
|
|
|
|
|
|
# Base class for enum types.
|
|
class Enum(ParamValue, metaclass=MetaEnum):
|
|
vals = []
|
|
cmd_line_settable = True
|
|
|
|
# The name of the wrapping namespace or struct
|
|
wrapper_name = "enums"
|
|
|
|
# If true, the enum is wrapped in a struct rather than a namespace
|
|
wrapper_is_struct = False
|
|
|
|
is_class = False
|
|
|
|
# If not None, use this as the enum name rather than this class name
|
|
enum_name = None
|
|
|
|
def __init__(self, value):
|
|
if value not in self.map:
|
|
raise TypeError(
|
|
f"Enum param got bad value '{value}' (not in {self.vals})"
|
|
)
|
|
self.value = value
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "enums/$0.hh"', cls.__name__)
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(cls, code, src, dest, ret):
|
|
code("if (false) {")
|
|
for elem_name in cls.map.keys():
|
|
code('} else if (%s == "%s") {' % (src, elem_name))
|
|
code.indent()
|
|
name = cls.__name__ if cls.enum_name is None else cls.enum_name
|
|
code(f"{dest} = {name if cls.is_class else 'enums'}::{elem_name};")
|
|
code(f"{ret} true;")
|
|
code.dedent()
|
|
code("} else {")
|
|
code(f" {ret} false;")
|
|
code("}")
|
|
|
|
def getValue(self):
|
|
import m5.internal.params
|
|
|
|
e = getattr(m5.internal.params, f"enum_{self.__class__.__name__}")
|
|
return e(self.map[self.value])
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
|
|
# This param will generate a scoped c++ enum and its python bindings.
|
|
class ScopedEnum(Enum):
|
|
vals = []
|
|
cmd_line_settable = True
|
|
|
|
# The name of the wrapping namespace or struct
|
|
wrapper_name = None
|
|
|
|
# If true, the enum is wrapped in a struct rather than a namespace
|
|
wrapper_is_struct = False
|
|
|
|
# If true, the generated enum is a scoped enum
|
|
is_class = True
|
|
|
|
# If not None, use this as the enum name rather than this class name
|
|
enum_name = None
|
|
|
|
|
|
class ByteOrder(ScopedEnum):
|
|
"""Enum representing component's byte order (endianness)"""
|
|
|
|
vals = ["big", "little"]
|
|
|
|
|
|
# how big does a rounding error need to be before we warn about it?
|
|
frequency_tolerance = 0.001 # 0.1%
|
|
|
|
|
|
class TickParamValue(NumericParamValue):
|
|
cxx_type = "Tick"
|
|
ex_str = "1MHz"
|
|
cmd_line_settable = True
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/types.hh"')
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def getValue(self):
|
|
return int(self.value)
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <sstream>")
|
|
|
|
# Ticks are expressed in seconds in JSON files and in plain
|
|
# Ticks in .ini files. Switch based on a config flag
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code("${ret} to_number(${src}, ${dest});")
|
|
|
|
|
|
class Latency(TickParamValue):
|
|
ex_str = "100ns"
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, (Latency, Clock)):
|
|
self.ticks = value.ticks
|
|
self.value = value.value
|
|
elif isinstance(value, Frequency):
|
|
self.ticks = value.ticks
|
|
self.value = 1.0 / value.value
|
|
elif value.endswith("t"):
|
|
self.ticks = True
|
|
self.value = int(value[:-1])
|
|
else:
|
|
self.ticks = False
|
|
self.value = convert.toLatency(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __getattr__(self, attr):
|
|
if attr in ("latency", "period"):
|
|
return self
|
|
if attr == "frequency":
|
|
return Frequency(self)
|
|
raise AttributeError(f"Latency object has no attribute '{attr}'")
|
|
|
|
def getValue(self):
|
|
if self.ticks or self.value == 0:
|
|
value = self.value
|
|
else:
|
|
value = ticks.fromSeconds(self.value)
|
|
return int(value)
|
|
|
|
def config_value(self):
|
|
return self.getValue()
|
|
|
|
# convert latency to ticks
|
|
def ini_str(self):
|
|
return "%d" % self.getValue()
|
|
|
|
|
|
class Frequency(TickParamValue):
|
|
ex_str = "1GHz"
|
|
|
|
def __init__(self, value):
|
|
if isinstance(value, (Latency, Clock)):
|
|
if value.value == 0:
|
|
self.value = 0
|
|
else:
|
|
self.value = 1.0 / value.value
|
|
self.ticks = value.ticks
|
|
elif isinstance(value, Frequency):
|
|
self.value = value.value
|
|
self.ticks = value.ticks
|
|
else:
|
|
self.ticks = False
|
|
self.value = convert.toFrequency(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __getattr__(self, attr):
|
|
if attr == "frequency":
|
|
return self
|
|
if attr in ("latency", "period"):
|
|
return Latency(self)
|
|
raise AttributeError(f"Frequency object has no attribute '{attr}'")
|
|
|
|
# convert latency to ticks
|
|
def getValue(self):
|
|
if self.ticks or self.value == 0:
|
|
value = self.value
|
|
else:
|
|
value = ticks.fromSeconds(1.0 / self.value)
|
|
return int(value)
|
|
|
|
def config_value(self):
|
|
return self.getValue()
|
|
|
|
def ini_str(self):
|
|
return "%d" % self.getValue()
|
|
|
|
|
|
# A generic Frequency and/or Latency value. Value is stored as a
|
|
# latency, just like Latency and Frequency.
|
|
class Clock(TickParamValue):
|
|
def __init__(self, value):
|
|
if isinstance(value, (Latency, Clock)):
|
|
self.ticks = value.ticks
|
|
self.value = value.value
|
|
elif isinstance(value, Frequency):
|
|
self.ticks = value.ticks
|
|
self.value = 1.0 / value.value
|
|
elif value.endswith("t"):
|
|
self.ticks = True
|
|
self.value = int(value[:-1])
|
|
else:
|
|
self.ticks = False
|
|
self.value = convert.anyToLatency(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
return f"{Latency(self)}"
|
|
|
|
def __getattr__(self, attr):
|
|
if attr == "frequency":
|
|
return Frequency(self)
|
|
if attr in ("latency", "period"):
|
|
return Latency(self)
|
|
raise AttributeError(f"Frequency object has no attribute '{attr}'")
|
|
|
|
def getValue(self):
|
|
return self.period.getValue()
|
|
|
|
def config_value(self):
|
|
return self.period.config_value()
|
|
|
|
def ini_str(self):
|
|
return self.period.ini_str()
|
|
|
|
|
|
class Voltage(Float):
|
|
ex_str = "1V"
|
|
|
|
def __new__(cls, value):
|
|
value = convert.toVoltage(value)
|
|
return super().__new__(cls, value)
|
|
|
|
def __init__(self, value):
|
|
value = convert.toVoltage(value)
|
|
super().__init__(value)
|
|
|
|
|
|
class Current(Float):
|
|
ex_str = "1mA"
|
|
|
|
def __new__(cls, value):
|
|
value = convert.toCurrent(value)
|
|
return super().__new__(cls, value)
|
|
|
|
def __init__(self, value):
|
|
value = convert.toCurrent(value)
|
|
super().__init__(value)
|
|
|
|
|
|
class Energy(Float):
|
|
ex_str = "1pJ"
|
|
|
|
def __new__(cls, value):
|
|
value = convert.toEnergy(value)
|
|
return super().__new__(cls, value)
|
|
|
|
def __init__(self, value):
|
|
value = convert.toEnergy(value)
|
|
super().__init__(value)
|
|
|
|
|
|
class Temperature(ParamValue):
|
|
cxx_type = "Temperature"
|
|
cmd_line_settable = True
|
|
ex_str = "1C"
|
|
|
|
def __init__(self, value):
|
|
self.value = convert.toTemperature(value)
|
|
|
|
def __call__(self, value):
|
|
self.__init__(value)
|
|
return value
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
def getValue(self):
|
|
from _m5.core import Temperature
|
|
|
|
return Temperature.from_kelvin(self.value)
|
|
|
|
def config_value(self):
|
|
return self.value
|
|
|
|
@classmethod
|
|
def cxx_predecls(cls, code):
|
|
code('#include "base/temperature.hh"')
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
# Assume that base/str.hh will be included anyway
|
|
# code('#include "base/str.hh"')
|
|
pass
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code("double _temp;")
|
|
code(f"bool _ret = to_number({src}, _temp);")
|
|
code("if (_ret)")
|
|
code(f" {dest} = Temperature(_temp);")
|
|
code(f"{ret} _ret;")
|
|
|
|
|
|
class NetworkBandwidth(float, ParamValue):
|
|
cxx_type = "float"
|
|
ex_str = "1Gbps"
|
|
cmd_line_settable = True
|
|
|
|
def __new__(cls, value):
|
|
# convert to bits per second
|
|
val = convert.toNetworkBandwidth(value)
|
|
return super().__new__(cls, val)
|
|
|
|
def __str__(self):
|
|
return str(self.val)
|
|
|
|
def __call__(self, value):
|
|
val = convert.toNetworkBandwidth(value)
|
|
self.__init__(val)
|
|
return value
|
|
|
|
def getValue(self):
|
|
# convert to seconds per byte
|
|
value = 8.0 / float(self)
|
|
# convert to ticks per byte
|
|
value = ticks.fromSeconds(value)
|
|
return float(value)
|
|
|
|
def ini_str(self):
|
|
return f"{self.getValue():f}"
|
|
|
|
def config_value(self):
|
|
return f"{self.getValue():f}"
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <sstream>")
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{ret} (std::istringstream({src}) >> {dest}).eof();")
|
|
|
|
|
|
class MemoryBandwidth(float, ParamValue):
|
|
cxx_type = "float"
|
|
ex_str = "1GiB/s"
|
|
cmd_line_settable = True
|
|
|
|
def __new__(cls, value):
|
|
# convert to bytes per second
|
|
val = convert.toMemoryBandwidth(value)
|
|
return super().__new__(cls, val)
|
|
|
|
def __call__(self, value):
|
|
val = convert.toMemoryBandwidth(value)
|
|
self.__init__(val)
|
|
return value
|
|
|
|
def getValue(self):
|
|
# convert to seconds per byte
|
|
value = float(self)
|
|
if value:
|
|
value = 1.0 / float(self)
|
|
# convert to ticks per byte
|
|
value = ticks.fromSeconds(value)
|
|
return float(value)
|
|
|
|
def ini_str(self):
|
|
return f"{self.getValue():f}"
|
|
|
|
def config_value(self):
|
|
return f"{self.getValue():f}"
|
|
|
|
@classmethod
|
|
def cxx_ini_predecls(cls, code):
|
|
code("#include <sstream>")
|
|
|
|
@classmethod
|
|
def cxx_ini_parse(self, code, src, dest, ret):
|
|
code(f"{ret} (std::istringstream({src}) >> {dest}).eof();")
|
|
|
|
|
|
#
|
|
# "Constants"... handy aliases for various values.
|
|
#
|
|
|
|
# Special class for NULL pointers. Note the special check in
|
|
# make_param_value() above that lets these be assigned where a
|
|
# SimObject is required.
|
|
# only one copy of a particular node
|
|
class NullSimObject(object, metaclass=Singleton):
|
|
_name = "Null"
|
|
|
|
def __call__(cls):
|
|
return cls
|
|
|
|
def _instantiate(self, parent=None, path=""):
|
|
pass
|
|
|
|
def ini_str(self):
|
|
return "Null"
|
|
|
|
def unproxy(self, base):
|
|
return self
|
|
|
|
def set_path(self, parent, name):
|
|
pass
|
|
|
|
def set_parent(self, parent, name):
|
|
pass
|
|
|
|
def clear_parent(self, old_parent):
|
|
pass
|
|
|
|
def descendants(self):
|
|
return
|
|
yield None
|
|
|
|
def get_config_as_dict(self):
|
|
return {}
|
|
|
|
def __str__(self):
|
|
return self._name
|
|
|
|
def config_value(self):
|
|
return None
|
|
|
|
def getValue(self):
|
|
return None
|
|
|
|
|
|
# The only instance you'll ever need...
|
|
NULL = NullSimObject()
|
|
|
|
|
|
def isNullPointer(value):
|
|
return isinstance(value, NullSimObject)
|
|
|
|
|
|
# Some memory range specifications use this as a default upper bound.
|
|
MaxAddr = Addr.max
|
|
MaxTick = Tick.max
|
|
AllMemory = AddrRange(0, MaxAddr)
|
|
|
|
|
|
#####################################################################
|
|
#
|
|
# Port objects
|
|
#
|
|
# Ports are used to interconnect objects in the memory system.
|
|
#
|
|
#####################################################################
|
|
|
|
# Port reference: encapsulates a reference to a particular port on a
|
|
# particular SimObject.
|
|
class PortRef(object):
|
|
def __init__(self, simobj, name, role, is_source):
|
|
assert isSimObject(simobj) or isSimObjectClass(simobj)
|
|
self.simobj = simobj
|
|
self.name = name
|
|
self.role = role
|
|
self.is_source = is_source
|
|
self.peer = None # not associated with another port yet
|
|
self.ccConnected = False # C++ port connection done?
|
|
self.index = -1 # always -1 for non-vector ports
|
|
|
|
def __str__(self):
|
|
return f"{self.simobj}.{self.name}"
|
|
|
|
def __len__(self):
|
|
# Return the number of connected ports, i.e. 0 is we have no
|
|
# peer and 1 if we do.
|
|
return int(self.peer != None)
|
|
|
|
# for config.ini, print peer's name (not ours)
|
|
def ini_str(self):
|
|
return str(self.peer)
|
|
|
|
# for config.json
|
|
def get_config_as_dict(self):
|
|
return {
|
|
"role": self.role,
|
|
"peer": str(self.peer),
|
|
"is_source": str(self.is_source),
|
|
}
|
|
|
|
def __getattr__(self, attr):
|
|
if attr == "peerObj":
|
|
# shorthand for proxies
|
|
return self.peer.simobj
|
|
raise AttributeError(
|
|
f"'{self.__class__.__name__}' object has no attribute '{attr}'"
|
|
)
|
|
|
|
# Full connection is symmetric (both ways). Called via
|
|
# SimObject.__setattr__ as a result of a port assignment, e.g.,
|
|
# "obj1.portA = obj2.portB", or via VectorPortElementRef.__setitem__,
|
|
# e.g., "obj1.portA[3] = obj2.portB".
|
|
def connect(self, other):
|
|
if isinstance(other, VectorPortRef):
|
|
# reference to plain VectorPort is implicit append
|
|
other = other._get_next()
|
|
if self.peer and not proxy.isproxy(self.peer):
|
|
fatal(
|
|
"Port %s is already connected to %s, cannot connect %s\n",
|
|
self,
|
|
self.peer,
|
|
other,
|
|
)
|
|
self.peer = other
|
|
|
|
if proxy.isproxy(other):
|
|
other.set_param_desc(PortParamDesc())
|
|
return
|
|
elif not isinstance(other, PortRef):
|
|
raise TypeError(
|
|
f"assigning non-port reference '{other}' to port '{self}'"
|
|
)
|
|
|
|
if not Port.is_compat(self, other):
|
|
fatal(
|
|
"Ports %s and %s with roles '%s' and '%s' "
|
|
"are not compatible",
|
|
self,
|
|
other,
|
|
self.role,
|
|
other.role,
|
|
)
|
|
|
|
if other.peer is not self:
|
|
other.connect(self)
|
|
|
|
# Allow a compatible port pair to be spliced between a port and its
|
|
# connected peer. Useful operation for connecting instrumentation
|
|
# structures into a system when it is necessary to connect the
|
|
# instrumentation after the full system has been constructed.
|
|
def splice(self, new_1, new_2):
|
|
if not self.peer or proxy.isproxy(self.peer):
|
|
fatal("Port %s not connected, cannot splice in new peers\n", self)
|
|
|
|
if not isinstance(new_1, PortRef) or not isinstance(new_2, PortRef):
|
|
raise TypeError(
|
|
f"Splicing non-port references '{new_1}','{new_2}' to port '{self}'"
|
|
)
|
|
|
|
old_peer = self.peer
|
|
|
|
if Port.is_compat(old_peer, new_1) and Port.is_compat(self, new_2):
|
|
old_peer.peer = new_1
|
|
new_1.peer = old_peer
|
|
self.peer = new_2
|
|
new_2.peer = self
|
|
elif Port.is_compat(old_peer, new_2) and Port.is_compat(self, new_1):
|
|
old_peer.peer = new_2
|
|
new_2.peer = old_peer
|
|
self.peer = new_1
|
|
new_1.peer = self
|
|
else:
|
|
fatal(
|
|
"Ports %s(%s) and %s(%s) can't be compatibly spliced with "
|
|
"%s(%s) and %s(%s)",
|
|
self,
|
|
self.role,
|
|
old_peer,
|
|
old_peer.role,
|
|
new_1,
|
|
new_1.role,
|
|
new_2,
|
|
new_2.role,
|
|
)
|
|
|
|
def clone(self, simobj, memo):
|
|
if self in memo:
|
|
return memo[self]
|
|
newRef = copy.copy(self)
|
|
memo[self] = newRef
|
|
newRef.simobj = simobj
|
|
assert isSimObject(newRef.simobj)
|
|
if self.peer and not proxy.isproxy(self.peer):
|
|
peerObj = self.peer.simobj(_memo=memo)
|
|
newRef.peer = self.peer.clone(peerObj, memo)
|
|
assert not isinstance(newRef.peer, VectorPortRef)
|
|
return newRef
|
|
|
|
def unproxy(self, simobj):
|
|
assert simobj is self.simobj
|
|
if proxy.isproxy(self.peer):
|
|
try:
|
|
realPeer = self.peer.unproxy(self.simobj)
|
|
except:
|
|
print(
|
|
f"Error in unproxying port '{self.name}' of {self.simobj.path()}"
|
|
)
|
|
raise
|
|
self.connect(realPeer)
|
|
|
|
# Call C++ to create corresponding port connection between C++ objects
|
|
def ccConnect(self):
|
|
if self.ccConnected: # already done this
|
|
return
|
|
|
|
peer = self.peer
|
|
if not self.peer: # nothing to connect to
|
|
return
|
|
|
|
port = self.simobj.getPort(self.name, self.index)
|
|
peer_port = peer.simobj.getPort(peer.name, peer.index)
|
|
port.bind(peer_port)
|
|
|
|
self.ccConnected = True
|
|
|
|
|
|
# A reference to an individual element of a VectorPort... much like a
|
|
# PortRef, but has an index.
|
|
class VectorPortElementRef(PortRef):
|
|
def __init__(self, simobj, name, role, is_source, index):
|
|
PortRef.__init__(self, simobj, name, role, is_source)
|
|
self.index = index
|
|
|
|
def __str__(self):
|
|
return "%s.%s[%d]" % (self.simobj, self.name, self.index)
|
|
|
|
|
|
# A reference to a complete vector-valued port (not just a single element).
|
|
# Can be indexed to retrieve individual VectorPortElementRef instances.
|
|
class VectorPortRef(object):
|
|
def __init__(self, simobj, name, role, is_source):
|
|
assert isSimObject(simobj) or isSimObjectClass(simobj)
|
|
self.simobj = simobj
|
|
self.name = name
|
|
self.role = role
|
|
self.is_source = is_source
|
|
self.elements = []
|
|
|
|
def __str__(self):
|
|
return f"{self.simobj}.{self.name}[:]"
|
|
|
|
def __len__(self):
|
|
# Return the number of connected peers, corresponding the the
|
|
# length of the elements.
|
|
return len(self.elements)
|
|
|
|
# for config.ini, print peer's name (not ours)
|
|
def ini_str(self):
|
|
return " ".join([el.ini_str() for el in self.elements])
|
|
|
|
# for config.json
|
|
def get_config_as_dict(self):
|
|
return {
|
|
"role": self.role,
|
|
"peer": [el.ini_str() for el in self.elements],
|
|
"is_source": str(self.is_source),
|
|
}
|
|
|
|
def __getitem__(self, key):
|
|
if not isinstance(key, int):
|
|
raise TypeError("VectorPort index must be integer")
|
|
if key >= len(self.elements):
|
|
# need to extend list
|
|
ext = [
|
|
VectorPortElementRef(
|
|
self.simobj, self.name, self.role, self.is_source, i
|
|
)
|
|
for i in range(len(self.elements), key + 1)
|
|
]
|
|
self.elements.extend(ext)
|
|
return self.elements[key]
|
|
|
|
def _get_next(self):
|
|
return self[len(self.elements)]
|
|
|
|
def __setitem__(self, key, value):
|
|
if not isinstance(key, int):
|
|
raise TypeError("VectorPort index must be integer")
|
|
self[key].connect(value)
|
|
|
|
def connect(self, other):
|
|
if isinstance(other, (list, tuple)):
|
|
# Assign list of port refs to vector port.
|
|
# For now, append them... not sure if that's the right semantics
|
|
# or if it should replace the current vector.
|
|
for ref in other:
|
|
self._get_next().connect(ref)
|
|
else:
|
|
# scalar assignment to plain VectorPort is implicit append
|
|
self._get_next().connect(other)
|
|
|
|
def clone(self, simobj, memo):
|
|
if self in memo:
|
|
return memo[self]
|
|
newRef = copy.copy(self)
|
|
memo[self] = newRef
|
|
newRef.simobj = simobj
|
|
assert isSimObject(newRef.simobj)
|
|
newRef.elements = [el.clone(simobj, memo) for el in self.elements]
|
|
return newRef
|
|
|
|
def unproxy(self, simobj):
|
|
[el.unproxy(simobj) for el in self.elements]
|
|
|
|
def ccConnect(self):
|
|
[el.ccConnect() for el in self.elements]
|
|
|
|
|
|
# Port description object. Like a ParamDesc object, this represents a
|
|
# logical port in the SimObject class, not a particular port on a
|
|
# SimObject instance. The latter are represented by PortRef objects.
|
|
class Port(object):
|
|
# Port("role", "description")
|
|
|
|
_compat_dict = {}
|
|
|
|
@classmethod
|
|
def compat(cls, role, peer):
|
|
cls._compat_dict.setdefault(role, set()).add(peer)
|
|
cls._compat_dict.setdefault(peer, set()).add(role)
|
|
|
|
@classmethod
|
|
def is_compat(cls, one, two):
|
|
for port in one, two:
|
|
if not port.role in Port._compat_dict:
|
|
fatal("Unrecognized role '%s' for port %s\n", port.role, port)
|
|
return one.role in Port._compat_dict[two.role]
|
|
|
|
def __init__(self, role, desc, is_source=False):
|
|
self.desc = desc
|
|
self.role = role
|
|
self.is_source = is_source
|
|
|
|
# Generate a PortRef for this port on the given SimObject with the
|
|
# given name
|
|
def makeRef(self, simobj):
|
|
return PortRef(simobj, self.name, self.role, self.is_source)
|
|
|
|
# Connect an instance of this port (on the given SimObject with
|
|
# the given name) with the port described by the supplied PortRef
|
|
def connect(self, simobj, ref):
|
|
self.makeRef(simobj).connect(ref)
|
|
|
|
# No need for any pre-declarations at the moment as we merely rely
|
|
# on an unsigned int.
|
|
def cxx_predecls(self, code):
|
|
pass
|
|
|
|
def pybind_predecls(self, code):
|
|
cls.cxx_predecls(self, code)
|
|
|
|
# Declare an unsigned int with the same name as the port, that
|
|
# will eventually hold the number of connected ports (and thus the
|
|
# number of elements for a VectorPort).
|
|
def cxx_decl(self, code):
|
|
code("unsigned int port_${{self.name}}_connection_count;")
|
|
|
|
|
|
Port.compat("GEM5 REQUESTOR", "GEM5 RESPONDER")
|
|
|
|
|
|
class RequestPort(Port):
|
|
# RequestPort("description")
|
|
def __init__(self, desc):
|
|
super().__init__("GEM5 REQUESTOR", desc, is_source=True)
|
|
|
|
|
|
class ResponsePort(Port):
|
|
# ResponsePort("description")
|
|
def __init__(self, desc):
|
|
super().__init__("GEM5 RESPONDER", desc)
|
|
|
|
|
|
# VectorPort description object. Like Port, but represents a vector
|
|
# of connections (e.g., as on a XBar).
|
|
class VectorPort(Port):
|
|
def makeRef(self, simobj):
|
|
return VectorPortRef(simobj, self.name, self.role, self.is_source)
|
|
|
|
|
|
class VectorRequestPort(VectorPort):
|
|
# VectorRequestPort("description")
|
|
def __init__(self, desc):
|
|
super().__init__("GEM5 REQUESTOR", desc, is_source=True)
|
|
|
|
|
|
class VectorResponsePort(VectorPort):
|
|
# VectorResponsePort("description")
|
|
def __init__(self, desc):
|
|
super().__init__("GEM5 RESPONDER", desc)
|
|
|
|
|
|
# Old names, maintained for compatibility.
|
|
MasterPort = RequestPort
|
|
SlavePort = ResponsePort
|
|
VectorMasterPort = VectorRequestPort
|
|
VectorSlavePort = VectorResponsePort
|
|
|
|
# 'Fake' ParamDesc for Port references to assign to the _pdesc slot of
|
|
# proxy objects (via set_param_desc()) so that proxy error messages
|
|
# make sense.
|
|
class PortParamDesc(object, metaclass=Singleton):
|
|
ptype_str = "Port"
|
|
ptype = Port
|
|
|
|
|
|
class DeprecatedParam(object):
|
|
"""A special type for deprecated parameter variable names.
|
|
|
|
There are times when we need to change the name of parameter, but this
|
|
breaks the external-facing python API used in configuration files. Using
|
|
this "type" for a parameter will warn users that they are using the old
|
|
name, but allow for backwards compatibility.
|
|
|
|
Usage example:
|
|
In the following example, the `time` parameter is changed to `delay`.
|
|
|
|
```
|
|
class SomeDevice(SimObject):
|
|
delay = Param.Latency('1ns', 'The time to wait before something')
|
|
time = DeprecatedParam(delay, '`time` is now called `delay`')
|
|
```
|
|
"""
|
|
|
|
def __init__(self, new_param, message=""):
|
|
"""new_param: the new parameter variable that users should be using
|
|
instead of this parameter variable.
|
|
message: an optional message to print when warning the user
|
|
"""
|
|
self.message = message
|
|
self.newParam = new_param
|
|
# Note: We won't know the string variable names until later in the
|
|
# SimObject initialization process. Note: we expect that the setters
|
|
# will be called when the SimObject type (class) is initialized so
|
|
# these variables should be filled in before the instance of the
|
|
# SimObject with this parameter is constructed
|
|
self._oldName = ""
|
|
self._newName = ""
|
|
|
|
@property
|
|
def oldName(self):
|
|
assert self._oldName != "" # should already be set
|
|
return self._oldName
|
|
|
|
@oldName.setter
|
|
def oldName(self, name):
|
|
assert self._oldName == "" # Cannot "re-set" this value
|
|
self._oldName = name
|
|
|
|
@property
|
|
def newName(self):
|
|
assert self._newName != "" # should already be set
|
|
return self._newName
|
|
|
|
@newName.setter
|
|
def newName(self, name):
|
|
assert self._newName == "" # Cannot "re-set" this value
|
|
self._newName = name
|
|
|
|
def printWarning(self, instance_name, simobj_name):
|
|
"""Issue a warning that this variable name should not be used.
|
|
|
|
instance_name: str, the name of the instance used in python
|
|
simobj_name: str, the name of the SimObject type
|
|
"""
|
|
if not self.message:
|
|
self.message = f"See {simobj_name} for more information"
|
|
warn(f"{instance_name}.{self._oldName} is deprecated. {self.message}")
|
|
|
|
|
|
baseEnums = allEnums.copy()
|
|
baseParams = allParams.copy()
|
|
|
|
|
|
def clear():
|
|
global allEnums, allParams
|
|
|
|
allEnums = baseEnums.copy()
|
|
allParams = baseParams.copy()
|
|
|
|
|
|
__all__ = [
|
|
"Param",
|
|
"VectorParam",
|
|
"Enum",
|
|
"ScopedEnum",
|
|
"Bool",
|
|
"String",
|
|
"Float",
|
|
"Int",
|
|
"Unsigned",
|
|
"Int8",
|
|
"UInt8",
|
|
"Int16",
|
|
"UInt16",
|
|
"Int32",
|
|
"UInt32",
|
|
"Int64",
|
|
"UInt64",
|
|
"Counter",
|
|
"Addr",
|
|
"Tick",
|
|
"Percent",
|
|
"TcpPort",
|
|
"UdpPort",
|
|
"EthernetAddr",
|
|
"IpAddress",
|
|
"IpNetmask",
|
|
"IpWithPort",
|
|
"MemorySize",
|
|
"MemorySize32",
|
|
"Latency",
|
|
"Frequency",
|
|
"Clock",
|
|
"Voltage",
|
|
"Current",
|
|
"Energy",
|
|
"Temperature",
|
|
"NetworkBandwidth",
|
|
"MemoryBandwidth",
|
|
"AddrRange",
|
|
"MaxAddr",
|
|
"MaxTick",
|
|
"AllMemory",
|
|
"Time",
|
|
"NextEthernetAddr",
|
|
"NULL",
|
|
"Port",
|
|
"RequestPort",
|
|
"ResponsePort",
|
|
"MasterPort",
|
|
"SlavePort",
|
|
"VectorPort",
|
|
"VectorRequestPort",
|
|
"VectorResponsePort",
|
|
"VectorMasterPort",
|
|
"VectorSlavePort",
|
|
"DeprecatedParam",
|
|
"PcCountPair",
|
|
]
|