Lines Matching refs:self
119 def ini_str(self):
120 return str(self)
125 def config_value(self):
126 return str(self)
142 def unproxy(self, base):
143 return self
146 def pretty_print(self, value):
151 def __init__(self, ptype_str, ptype, *args, **kwargs):
152 self.ptype_str = ptype_str
155 self.ptype = ptype
159 self.desc = args[0]
161 self.default = args[0]
162 self.desc = args[1]
167 assert(not hasattr(self, 'desc'))
168 self.desc = kwargs['desc']
172 assert(not hasattr(self, 'default'))
173 self.default = kwargs['default']
179 if not hasattr(self, 'desc'):
182 def __getattr__(self, attr):
185 ptype = SimObject.allClasses[self.ptype_str]
187 self.ptype = ptype
191 (type(self).__name__, attr))
193 def example_str(self):
194 if hasattr(self.ptype, "ex_str"):
195 return self.ptype.ex_str
197 return self.ptype_str
200 def isCmdLineSettable(self):
201 if hasattr(self.ptype, "cmd_line_settable"):
202 return self.ptype.cmd_line_settable
206 def convert(self, value):
208 value.set_param_desc(self)
210 if 'ptype' not in self.__dict__ and isNullPointer(value):
214 if isinstance(value, self.ptype):
216 if isNullPointer(value) and isSimObjectClass(self.ptype):
218 return self.ptype(value)
220 def pretty_print(self, value):
225 return self.ptype(value).pretty_print(value)
227 def cxx_predecls(self, code):
229 self.ptype.cxx_predecls(code)
231 def pybind_predecls(self, code):
232 self.ptype.pybind_predecls(code)
234 def cxx_decl(self, code):
235 code('${{self.ptype.cxx_type}} ${{self.name}};')
243 def __setattr__(self, attr, value):
245 (attr, type(self).__name__))
247 def config_value(self):
248 return [v.config_value() for v in self]
250 def ini_str(self):
251 return ' '.join([v.ini_str() for v in self])
253 def getValue(self):
254 return [ v.getValue() for v in self ]
256 def unproxy(self, base):
257 if len(self) == 1 and isinstance(self[0], proxy.BaseProxy):
260 return self[0].unproxy(base)
262 return [v.unproxy(base) for v in self]
266 def __call__(self, **kwargs):
267 return SimObjectVector([v(**kwargs) for v in self])
269 def clear_parent(self, old_parent):
270 for v in self:
273 def set_parent(self, parent, name):
274 if len(self) == 1:
275 self[0].set_parent(parent, name)
277 width = int(math.ceil(math.log(len(self))/math.log(10)))
278 for i,v in enumerate(self):
281 def has_parent(self):
282 return any([e.has_parent() for e in self if not isNullPointer(e)])
285 def get_name(self):
286 return ' '.join([v._name for v in self])
292 def descendants(self):
293 for v in self:
297 def get_config_as_dict(self):
299 for v in self:
308 def __setitem__(self, key, value):
309 val = self[key]
314 super(SimObjectVector, self).__setitem__(key, value)
319 def enumerateParams(self, flags_dict = {},
322 if hasattr(self, "_paramEnumed"):
326 for vals in self:
339 def convert(self, value):
342 tmp_list = [ ParamDesc.convert(self, v) for v in value ]
345 tmp_list = [ ParamDesc.convert(self, v) \
349 tmp_list = [ ParamDesc.convert(self, value) ]
359 def example_str(self):
360 s = super(VectorParamDesc, self).example_str()
365 def pretty_print(self, value):
367 tmp_list = [ ParamDesc.pretty_print(self, v) for v in value ]
369 tmp_list = [ ParamDesc.pretty_print(self, v) for v in value.split(',') ]
371 tmp_list = [ ParamDesc.pretty_print(self, value) ]
376 def __call__(self, value):
379 tmp_list = [ ParamDesc.convert(self, v) for v in value ]
382 tmp_list = [ ParamDesc.convert(self, v) \
386 tmp_list = [ ParamDesc.convert(self, value) ]
390 def cxx_predecls(self, code):
392 self.ptype.cxx_predecls(code)
394 def pybind_predecls(self, code):
396 self.ptype.pybind_predecls(code)
398 def cxx_decl(self, code):
399 code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
402 def __init__(self, param_desc_class, ptype_str = None):
403 self.param_desc_class = param_desc_class
404 self.ptype_str = ptype_str
406 def __getattr__(self, attr):
407 if self.ptype_str:
408 attr = self.ptype_str + '.' + attr
409 return ParamFactory(self.param_desc_class, attr)
412 def __call__(self, *args, **kwargs):
415 ptype = allParams[self.ptype_str]
420 return self.param_desc_class(self.ptype_str, ptype, *args, **kwargs)
445 def cxx_predecls(self, code):
448 def __call__(self, value):
449 self = value
453 def cxx_ini_parse(self, code, src, dest, ret):
457 def getValue(self):
458 return self
468 def __str__(self):
469 return str(self.value)
471 def __float__(self):
472 return float(self.value)
474 def __long__(self):
475 return long(self.value)
477 def __int__(self):
478 return int(self.value)
481 def _check(self):
484 def __mul__(self, other):
485 newobj = self.__class__(self)
492 def __truediv__(self, other):
493 newobj = self.__class__(self)
498 def __floordiv__(self, other):
499 newobj = self.__class__(self)
505 def __add__(self, other):
506 newobj = self.__class__(self)
511 def __sub__(self, other):
512 newobj = self.__class__(self)
517 def __iadd__(self, other):
518 self.value += NumericParamValue.unwrap(other)
519 self._check()
520 return self
522 def __isub__(self, other):
523 self.value -= NumericParamValue.unwrap(other)
524 self._check()
525 return self
527 def __imul__(self, other):
528 self.value *= NumericParamValue.unwrap(other)
529 self._check()
530 return self
532 def __itruediv__(self, other):
533 self.value /= NumericParamValue.unwrap(other)
534 self._check()
535 return self
537 def __ifloordiv__(self, other):
538 self.value //= NumericParamValue.unwrap(other)
539 self._check()
540 return self
542 def __lt__(self, other):
543 return self.value < NumericParamValue.unwrap(other)
550 def config_value(self):
551 return self.value
563 def cxx_ini_parse(self, code, src, dest, ret):
597 def _check(self):
598 if not self.min <= self.value <= self.max:
600 (self.min, self.value, self.max))
602 def __init__(self, value):
604 self.value = convert.toInteger(value)
606 self.value = long(value)
610 self._check()
612 def __call__(self, value):
613 self.__init__(value)
616 def __index__(self):
617 return int(self.value)
624 def getValue(self):
625 return long(self.value)
651 def getValue(self):
653 return Cycles(self.value)
673 def __init__(self, value):
675 self.value = float(value)
680 def __call__(self, value):
681 self.__init__(value)
684 def getValue(self):
685 return float(self.value)
687 def config_value(self):
688 return self
695 def cxx_ini_parse(self, code, src, dest, ret):
703 def __init__(self, value):
705 self.value = value.value
707 self.value = convert.toMemorySize(value)
708 self._check()
715 def __init__(self, value):
717 self.value = value.value
719 self.value = convert.toMemorySize(value)
720 self._check()
726 def __init__(self, value):
728 self.value = value.value
736 self.value = convert.toMemorySize(value)
740 self.value = long(str(value), base=0)
742 self._check()
743 def __add__(self, other):
745 return self.value + other.value
747 return self.value + other
748 def pretty_print(self, value):
758 def __init__(self, *args, **kwargs):
760 self.intlvBits = 0
761 self.intlvMatch = 0
762 self.masks = []
764 def handle_kwargs(self, kwargs):
769 self.end = Addr(kwargs.pop('end'))
771 self.end = self.start + Addr(kwargs.pop('size')) - 1
777 self.intlvMatch = int(kwargs.pop('intlvMatch'))
780 self.masks = [ long(x) for x in list(kwargs.pop('masks')) ]
781 self.intlvBits = len(self.masks)
784 self.intlvBits = int(kwargs.pop('intlvBits'))
785 self.masks = [0] * self.intlvBits
792 for i in range(0, self.intlvBits):
798 self.masks[self.intlvBits - i - 1] = mask
801 self.start = Addr(kwargs.pop('start'))
802 handle_kwargs(self, kwargs)
806 self.start = Addr(args[0])
807 handle_kwargs(self, kwargs)
809 self.start = Addr(args[0][0])
810 self.end = Addr(args[0][1])
812 self.start = Addr(0)
813 self.end = Addr(args[0]) - 1
816 self.start = Addr(args[0])
817 self.end = Addr(args[1])
824 def __str__(self):
825 if len(self.masks) == 0:
826 return '%s:%s' % (self.start, self.end)
828 return '%s:%s:%s:%s' % (self.start, self.end, self.intlvMatch,
829 ':'.join(str(m) for m in self.masks))
831 def size(self):
833 return (long(self.end) - long(self.start) + 1) >> self.intlvBits
879 def getValue(self):
883 return AddrRange(long(self.start), long(self.end),
884 self.masks, int(self.intlvMatch))
893 def __init__(self, value):
895 self.value = convert.toBool(value)
897 self.value = bool(value)
899 def __call__(self, value):
900 self.__init__(value)
903 def getValue(self):
904 return bool(self.value)
906 def __str__(self):
907 return str(self.value)
911 def __bool__(self):
912 return bool(self.value)
917 def ini_str(self):
918 if self.value:
922 def config_value(self):
923 return self.value
964 def __init__(self, value):
966 self.value = value
980 self.value = value
982 def __call__(self, value):
983 self.__init__(value)
986 def unproxy(self, base):
987 if self.value == NextEthernetAddr:
988 return EthernetAddr(self.value())
989 return self
991 def getValue(self):
993 return EthAddr(self.value)
995 def __str__(self):
996 return self.value
998 def ini_str(self):
999 return self.value
1002 def cxx_ini_parse(self, code, src, dest, ret):
1017 def __init__(self, value):
1019 self.ip = value.ip
1022 self.ip = convert.toIpAddress(value)
1024 self.ip = long(value)
1025 self.verifyIp()
1027 def __call__(self, value):
1028 self.__init__(value)
1031 def __str__(self):
1032 tup = [(self.ip >> i) & 0xff for i in (24, 16, 8, 0)]
1035 def __eq__(self, other):
1037 return self.ip == other.ip
1040 return self.ip == convert.toIpAddress(other)
1044 return self.ip == other
1046 def __ne__(self, other):
1047 return not (self == other)
1049 def verifyIp(self):
1050 if self.ip < 0 or self.ip >= (1 << 32):
1051 raise TypeError("invalid ip address %#08x" % self.ip)
1053 def getValue(self):
1055 return IpAddress(self.ip)
1069 def __init__(self, *args, **kwargs):
1070 def handle_kwarg(self, kwargs, key, elseVal = None):
1072 setattr(self, key, kwargs.pop(key))
1074 setattr(self, key, elseVal)
1079 handle_kwarg(self, kwargs, 'ip')
1080 handle_kwarg(self, kwargs, 'netmask')
1086 handle_kwarg(self, kwargs, 'ip', args[0])
1087 handle_kwarg(self, kwargs, 'netmask', args[0])
1089 self.ip = args[0].ip
1090 self.netmask = args[0].netmask
1092 (self.ip, self.netmask) = convert.toIpNetmask(args[0])
1095 self.ip = args[0]
1096 self.netmask = args[1]
1103 self.verify()
1105 def __call__(self, value):
1106 self.__init__(value)
1109 def __str__(self):
1110 return "%s/%d" % (super(IpNetmask, self).__str__(), self.netmask)
1112 def __eq__(self, other):
1114 return self.ip == other.ip and self.netmask == other.netmask
1117 return (self.ip, self.netmask) == convert.toIpNetmask(other)
1123 def verify(self):
1124 self.verifyIp()
1125 if self.netmask < 0 or self.netmask > 32:
1128 def getValue(self):
1130 return IpNetmask(self.ip, self.netmask)
1143 def __init__(self, *args, **kwargs):
1144 def handle_kwarg(self, kwargs, key, elseVal = None):
1146 setattr(self, key, kwargs.pop(key))
1148 setattr(self, key, elseVal)
1153 handle_kwarg(self, kwargs, 'ip')
1154 handle_kwarg(self, kwargs, 'port')
1160 handle_kwarg(self, kwargs, 'ip', args[0])
1161 handle_kwarg(self, kwargs, 'port', args[0])
1163 self.ip = args[0].ip
1164 self.port = args[0].port
1166 (self.ip, self.port) = convert.toIpWithPort(args[0])
1169 self.ip = args[0]
1170 self.port = args[1]
1177 self.verify()
1179 def __call__(self, value):
1180 self.__init__(value)
1183 def __str__(self):
1184 return "%s:%d" % (super(IpWithPort, self).__str__(), self.port)
1186 def __eq__(self, other):
1188 return self.ip == other.ip and self.port == other.port
1191 return (self.ip, self.port) == convert.toIpWithPort(other)
1197 def verify(self):
1198 self.verifyIp()
1199 if self.port < 0 or self.port > 0xffff:
1200 raise TypeError("invalid port %d" % self.port)
1202 def getValue(self):
1204 return IpWithPort(self.ip, self.port)
1251 def __init__(self, value):
1252 self.value = parse_time(value)
1254 def __call__(self, value):
1255 self.__init__(value)
1258 def getValue(self):
1262 return tm.gmtime(calendar.timegm(self.value))
1264 def __str__(self):
1265 return time.asctime(self.value)
1267 def ini_str(self):
1268 return str(self)
1270 def get_config_as_dict(self):
1272 return str(self)
1468 def __init__(self, value):
1469 if value not in self.map:
1471 % (value, self.vals))
1472 self.value = value
1474 def __call__(self, value):
1475 self.__init__(value)
1497 def getValue(self):
1499 e = getattr(m5.internal.params, "enum_%s" % self.__class__.__name__)
1500 return e(self.map[self.value])
1502 def __str__(self):
1503 return self.value
1535 def __call__(self, value):
1536 self.__init__(value)
1539 def getValue(self):
1540 return long(self.value)
1549 def cxx_ini_parse(self, code, src, dest, ret):
1555 def __init__(self, value):
1557 self.ticks = value.ticks
1558 self.value = value.value
1560 self.ticks = value.ticks
1561 self.value = 1.0 / value.value
1563 self.ticks = True
1564 self.value = int(value[:-1])
1566 self.ticks = False
1567 self.value = convert.toLatency(value)
1569 def __call__(self, value):
1570 self.__init__(value)
1573 def __getattr__(self, attr):
1575 return self
1577 return Frequency(self)
1580 def getValue(self):
1581 if self.ticks or self.value == 0:
1582 value = self.value
1584 value = ticks.fromSeconds(self.value)
1587 def config_value(self):
1588 return self.getValue()
1591 def ini_str(self):
1592 return '%d' % self.getValue()
1597 def __init__(self, value):
1600 self.value = 0
1602 self.value = 1.0 / value.value
1603 self.ticks = value.ticks
1605 self.value = value.value
1606 self.ticks = value.ticks
1608 self.ticks = False
1609 self.value = convert.toFrequency(value)
1611 def __call__(self, value):
1612 self.__init__(value)
1615 def __getattr__(self, attr):
1617 return self
1619 return Latency(self)
1623 def getValue(self):
1624 if self.ticks or self.value == 0:
1625 value = self.value
1627 value = ticks.fromSeconds(1.0 / self.value)
1630 def config_value(self):
1631 return self.getValue()
1633 def ini_str(self):
1634 return '%d' % self.getValue()
1639 def __init__(self, value):
1641 self.ticks = value.ticks
1642 self.value = value.value
1644 self.ticks = value.ticks
1645 self.value = 1.0 / value.value
1647 self.ticks = True
1648 self.value = int(value[:-1])
1650 self.ticks = False
1651 self.value = convert.anyToLatency(value)
1653 def __call__(self, value):
1654 self.__init__(value)
1657 def __str__(self):
1658 return "%s" % Latency(self)
1660 def __getattr__(self, attr):
1662 return Frequency(self)
1664 return Latency(self)
1667 def getValue(self):
1668 return self.period.getValue()
1670 def config_value(self):
1671 return self.period.config_value()
1673 def ini_str(self):
1674 return self.period.ini_str()
1683 def __init__(self, value):
1685 super(Voltage, self).__init__(value)
1694 def __init__(self, value):
1696 super(Current, self).__init__(value)
1705 def __init__(self, value):
1707 super(Energy, self).__init__(value)
1719 def __str__(self):
1720 return str(self.val)
1722 def __call__(self, value):
1724 self.__init__(val)
1727 def getValue(self):
1729 value = 8.0 / float(self)
1734 def ini_str(self):
1735 return '%f' % self.getValue()
1737 def config_value(self):
1738 return '%f' % self.getValue()
1745 def cxx_ini_parse(self, code, src, dest, ret):
1758 def __call__(self, value):
1760 self.__init__(val)
1763 def getValue(self):
1765 value = float(self)
1767 value = 1.0 / float(self)
1772 def ini_str(self):
1773 return '%f' % self.getValue()
1775 def config_value(self):
1776 return '%f' % self.getValue()
1783 def cxx_ini_parse(self, code, src, dest, ret):
1801 def _instantiate(self, parent = None, path = ''):
1804 def ini_str(self):
1807 def unproxy(self, base):
1808 return self
1810 def set_path(self, parent, name):
1813 def set_parent(self, parent, name):
1816 def clear_parent(self, old_parent):
1819 def descendants(self):
1823 def get_config_as_dict(self):
1826 def __str__(self):
1827 return self._name
1829 def config_value(self):
1832 def getValue(self):
1858 def __init__(self, simobj, name, role, is_source):
1860 self.simobj = simobj
1861 self.name = name
1862 self.role = role
1863 self.is_source = is_source
1864 self.peer = None # not associated with another port yet
1865 self.ccConnected = False # C++ port connection done?
1866 self.index = -1 # always -1 for non-vector ports
1868 def __str__(self):
1869 return '%s.%s' % (self.simobj, self.name)
1871 def __len__(self):
1874 return int(self.peer != None)
1877 def ini_str(self):
1878 return str(self.peer)
1881 def get_config_as_dict(self):
1882 return {'role' : self.role, 'peer' : str(self.peer),
1883 'is_source' : str(self.is_source)}
1885 def __getattr__(self, attr):
1888 return self.peer.simobj
1890 (self.__class__.__name__, attr))
1896 def connect(self, other):
1900 if self.peer and not proxy.isproxy(self.peer):
1902 self, self.peer, other);
1903 self.peer = other
1910 % (other, self))
1912 if not Port.is_compat(self, other):
1914 "are not compatible", self, other, self.role, other.role)
1916 if other.peer is not self:
1917 other.connect(self)
1923 def splice(self, new_1, new_2):
1924 if not self.peer or proxy.isproxy(self.peer):
1925 fatal("Port %s not connected, cannot splice in new peers\n", self)
1930 (new_1, new_2, self))
1932 old_peer = self.peer
1934 if Port.is_compat(old_peer, new_1) and Port.is_compat(self, new_2):
1937 self.peer = new_2
1938 new_2.peer = self
1939 elif Port.is_compat(old_peer, new_2) and Port.is_compat(self, new_1):
1942 self.peer = new_1
1943 new_1.peer = self
1946 "%s(%s) and %s(%s)", self, self.role,
1950 def clone(self, simobj, memo):
1951 if self in memo:
1952 return memo[self]
1953 newRef = copy.copy(self)
1954 memo[self] = newRef
1957 if self.peer and not proxy.isproxy(self.peer):
1958 peerObj = self.peer.simobj(_memo=memo)
1959 newRef.peer = self.peer.clone(peerObj, memo)
1963 def unproxy(self, simobj):
1964 assert(simobj is self.simobj)
1965 if proxy.isproxy(self.peer):
1967 realPeer = self.peer.unproxy(self.simobj)
1970 (self.name, self.simobj.path()))
1972 self.connect(realPeer)
1975 def ccConnect(self):
1976 if self.ccConnected: # already done this
1979 peer = self.peer
1980 if not self.peer: # nothing to connect to
1983 port = self.simobj.getPort(self.name, self.index)
1987 self.ccConnected = True
1992 def __init__(self, simobj, name, role, is_source, index):
1993 PortRef.__init__(self, simobj, name, role, is_source)
1994 self.index = index
1996 def __str__(self):
1997 return '%s.%s[%d]' % (self.simobj, self.name, self.index)
2002 def __init__(self, simobj, name, role, is_source):
2004 self.simobj = simobj
2005 self.name = name
2006 self.role = role
2007 self.is_source = is_source
2008 self.elements = []
2010 def __str__(self):
2011 return '%s.%s[:]' % (self.simobj, self.name)
2013 def __len__(self):
2016 return len(self.elements)
2019 def ini_str(self):
2020 return ' '.join([el.ini_str() for el in self.elements])
2023 def get_config_as_dict(self):
2024 return {'role' : self.role,
2025 'peer' : [el.ini_str() for el in self.elements],
2026 'is_source' : str(self.is_source)}
2028 def __getitem__(self, key):
2031 if key >= len(self.elements):
2034 self.simobj, self.name, self.role, self.is_source, i)
2035 for i in range(len(self.elements), key+1)]
2036 self.elements.extend(ext)
2037 return self.elements[key]
2039 def _get_next(self):
2040 return self[len(self.elements)]
2042 def __setitem__(self, key, value):
2045 self[key].connect(value)
2047 def connect(self, other):
2053 self._get_next().connect(ref)
2056 self._get_next().connect(other)
2058 def clone(self, simobj, memo):
2059 if self in memo:
2060 return memo[self]
2061 newRef = copy.copy(self)
2062 memo[self] = newRef
2065 newRef.elements = [el.clone(simobj, memo) for el in self.elements]
2068 def unproxy(self, simobj):
2069 [el.unproxy(simobj) for el in self.elements]
2071 def ccConnect(self):
2072 [el.ccConnect() for el in self.elements]
2094 def __init__(self, role, desc, is_source=False):
2095 self.desc = desc
2096 self.role = role
2097 self.is_source = is_source
2101 def makeRef(self, simobj):
2102 return PortRef(simobj, self.name, self.role, self.is_source)
2106 def connect(self, simobj, ref):
2107 self.makeRef(simobj).connect(ref)
2111 def cxx_predecls(self, code):
2114 def pybind_predecls(self, code):
2115 cls.cxx_predecls(self, code)
2120 def cxx_decl(self, code):
2121 code('unsigned int port_${{self.name}}_connection_count;')
2127 def __init__(self, desc):
2128 super(RequestPort, self).__init__(
2133 def __init__(self, desc):
2134 super(ResponsePort, self).__init__('GEM5 RESPONDER', desc)
2139 def makeRef(self, simobj):
2140 return VectorPortRef(simobj, self.name, self.role, self.is_source)
2144 def __init__(self, desc):
2145 super(VectorRequestPort, self).__init__(
2150 def __init__(self, desc):
2151 super(VectorResponsePort, self).__init__('GEM5 RESPONDER', desc)