1470765bbc1fef085a52e659267310cee2b95e07
1 # Copyright (c) 2012-2014, 2017, 2018 ARM Limited
4 # The license below extends only to copyright in the software and shall
5 # not be construed as granting a license to any other intellectual
6 # property including but not limited to intellectual property relating
7 # to a hardware implementation of the functionality of the software
8 # licensed hereunder. You may use the software subject to the license
9 # terms below provided that you ensure that this notice is replicated
10 # unmodified and in its entirety in all distributions of the software,
11 # modified or unmodified, in source code or in binary form.
13 # Copyright (c) 2004-2006 The Regents of The University of Michigan
14 # Copyright (c) 2010-2011 Advanced Micro Devices, Inc.
15 # All rights reserved.
17 # Redistribution and use in source and binary forms, with or without
18 # modification, are permitted provided that the following conditions are
19 # met: redistributions of source code must retain the above copyright
20 # notice, this list of conditions and the following disclaimer;
21 # redistributions in binary form must reproduce the above copyright
22 # notice, this list of conditions and the following disclaimer in the
23 # documentation and/or other materials provided with the distribution;
24 # neither the name of the copyright holders nor the names of its
25 # contributors may be used to endorse or promote products derived from
26 # this software without specific prior written permission.
28 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 # Authors: Steve Reinhardt
45 #####################################################################
47 # Parameter description classes
49 # The _params dictionary in each class maps parameter names to either
50 # a Param or a VectorParam object. These objects contain the
51 # parameter description string, the parameter type, and the default
52 # value (if any). The convert() method on these objects is used to
53 # force whatever value is assigned to the parameter to the appropriate
56 # Note that the default values are loaded into the class's attribute
57 # space when the parameter dictionary is initialized (in
58 # MetaSimObject._new_param()); after that point they aren't used.
60 #####################################################################
62 from __future__
import print_function
75 def isSimObject(*args
, **kwargs
):
76 return SimObject
.isSimObject(*args
, **kwargs
)
78 def isSimObjectSequence(*args
, **kwargs
):
79 return SimObject
.isSimObjectSequence(*args
, **kwargs
)
81 def isSimObjectClass(*args
, **kwargs
):
82 return SimObject
.isSimObjectClass(*args
, **kwargs
)
86 class MetaParamValue(type):
87 def __new__(mcls
, name
, bases
, dct
):
88 cls
= super(MetaParamValue
, mcls
).__new
__(mcls
, name
, bases
, dct
)
89 assert name
not in allParams
94 # Dummy base class to identify types that are legitimate for SimObject
96 class ParamValue(object):
97 __metaclass__
= MetaParamValue
98 cmd_line_settable
= False
100 # Generate the code needed as a prerequisite for declaring a C++
101 # object of this type. Typically generates one or more #include
102 # statements. Used when declaring parameters of this type.
104 def cxx_predecls(cls
, code
):
108 def pybind_predecls(cls
, code
):
109 cls
.cxx_predecls(code
)
111 # default for printing to .ini file is regular string conversion.
112 # will be overridden in some cases
116 # default for printing to .json file is regular string conversion.
117 # will be overridden in some cases, mostly to use native Python
118 # types where there are similar JSON types
119 def config_value(self
):
122 # Prerequisites for .ini parsing with cxx_ini_parse
124 def cxx_ini_predecls(cls
, code
):
127 # parse a .ini file entry for this param from string expression
128 # src into lvalue dest (of the param's C++ type)
130 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
131 code('// Unhandled param type: %s' % cls
.__name
__)
132 code('%s false;' % ret
)
134 # allows us to blithely call unproxy() on things without checking
135 # if they're really proxies or not
136 def unproxy(self
, base
):
139 # Produce a human readable version of the stored value
140 def pretty_print(self
, value
):
143 # Regular parameter description.
144 class ParamDesc(object):
145 def __init__(self
, ptype_str
, ptype
, *args
, **kwargs
):
146 self
.ptype_str
= ptype_str
147 # remember ptype only if it is provided
155 self
.default
= args
[0]
158 raise TypeError('too many arguments')
161 assert(not hasattr(self
, 'desc'))
162 self
.desc
= kwargs
['desc']
165 if 'default' in kwargs
:
166 assert(not hasattr(self
, 'default'))
167 self
.default
= kwargs
['default']
168 del kwargs
['default']
171 raise TypeError('extra unknown kwargs %s' % kwargs
)
173 if not hasattr(self
, 'desc'):
174 raise TypeError('desc attribute missing')
176 def __getattr__(self
, attr
):
178 ptype
= SimObject
.allClasses
[self
.ptype_str
]
179 assert isSimObjectClass(ptype
)
183 raise AttributeError("'%s' object has no attribute '%s'" % \
184 (type(self
).__name
__, attr
))
186 def example_str(self
):
187 if hasattr(self
.ptype
, "ex_str"):
188 return self
.ptype
.ex_str
190 return self
.ptype_str
192 # Is the param available to be exposed on the command line
193 def isCmdLineSettable(self
):
194 if hasattr(self
.ptype
, "cmd_line_settable"):
195 return self
.ptype
.cmd_line_settable
199 def convert(self
, value
):
200 if isinstance(value
, proxy
.BaseProxy
):
201 value
.set_param_desc(self
)
203 if 'ptype' not in self
.__dict
__ and isNullPointer(value
):
204 # deferred evaluation of SimObject; continue to defer if
205 # we're just assigning a null pointer
207 if isinstance(value
, self
.ptype
):
209 if isNullPointer(value
) and isSimObjectClass(self
.ptype
):
211 return self
.ptype(value
)
213 def pretty_print(self
, value
):
214 if isinstance(value
, proxy
.BaseProxy
):
216 if isNullPointer(value
):
218 return self
.ptype(value
).pretty_print(value
)
220 def cxx_predecls(self
, code
):
221 code('#include <cstddef>')
222 self
.ptype
.cxx_predecls(code
)
224 def pybind_predecls(self
, code
):
225 self
.ptype
.pybind_predecls(code
)
227 def cxx_decl(self
, code
):
228 code('${{self.ptype.cxx_type}} ${{self.name}};')
230 # Vector-valued parameter description. Just like ParamDesc, except
231 # that the value is a vector (list) of the specified type instead of a
234 class VectorParamValue(list):
235 __metaclass__
= MetaParamValue
236 def __setattr__(self
, attr
, value
):
237 raise AttributeError("Not allowed to set %s on '%s'" % \
238 (attr
, type(self
).__name
__))
240 def config_value(self
):
241 return [v
.config_value() for v
in self
]
244 return ' '.join([v
.ini_str() for v
in self
])
247 return [ v
.getValue() for v
in self
]
249 def unproxy(self
, base
):
250 if len(self
) == 1 and isinstance(self
[0], proxy
.BaseProxy
):
251 # The value is a proxy (e.g. Parent.any, Parent.all or
252 # Parent.x) therefore try resolve it
253 return self
[0].unproxy(base
)
255 return [v
.unproxy(base
) for v
in self
]
257 class SimObjectVector(VectorParamValue
):
258 # support clone operation
259 def __call__(self
, **kwargs
):
260 return SimObjectVector([v(**kwargs
) for v
in self
])
262 def clear_parent(self
, old_parent
):
264 v
.clear_parent(old_parent
)
266 def set_parent(self
, parent
, name
):
268 self
[0].set_parent(parent
, name
)
270 width
= int(math
.ceil(math
.log(len(self
))/math
.log(10)))
271 for i
,v
in enumerate(self
):
272 v
.set_parent(parent
, "%s%0*d" % (name
, width
, i
))
274 def has_parent(self
):
275 return any([e
.has_parent() for e
in self
if not isNullPointer(e
)])
277 # return 'cpu0 cpu1' etc. for print_ini()
279 return ' '.join([v
._name
for v
in self
])
281 # By iterating through the constituent members of the vector here
282 # we can nicely handle iterating over all a SimObject's children
283 # without having to provide lots of special functions on
284 # SimObjectVector directly.
285 def descendants(self
):
287 for obj
in v
.descendants():
290 def get_config_as_dict(self
):
293 a
.append(v
.get_config_as_dict())
296 # If we are replacing an item in the vector, make sure to set the
297 # parent reference of the new SimObject to be the same as the parent
298 # of the SimObject being replaced. Useful to have if we created
299 # a SimObjectVector of temporary objects that will be modified later in
300 # configuration scripts.
301 def __setitem__(self
, key
, value
):
303 if value
.has_parent():
304 warn("SimObject %s already has a parent" % value
.get_name() +\
305 " that is being overwritten by a SimObjectVector")
306 value
.set_parent(val
.get_parent(), val
._name
)
307 super(SimObjectVector
, self
).__setitem
__(key
, value
)
309 # Enumerate the params of each member of the SimObject vector. Creates
310 # strings that will allow indexing into the vector by the python code and
311 # allow it to be specified on the command line.
312 def enumerateParams(self
, flags_dict
= {},
315 if hasattr(self
, "_paramEnumed"):
316 print("Cycle detected enumerating params at %s?!" % (cmd_line_str
))
320 # Each entry in the SimObjectVector should be an
321 # instance of a SimObject
322 flags_dict
= vals
.enumerateParams(flags_dict
,
323 cmd_line_str
+ "%d." % x
,
324 access_str
+ "[%d]." % x
)
329 class VectorParamDesc(ParamDesc
):
330 # Convert assigned value to appropriate type. If the RHS is not a
331 # list or tuple, it generates a single-element list.
332 def convert(self
, value
):
333 if isinstance(value
, (list, tuple)):
334 # list: coerce each element into new list
335 tmp_list
= [ ParamDesc
.convert(self
, v
) for v
in value
]
336 elif isinstance(value
, str):
337 # If input is a csv string
338 tmp_list
= [ ParamDesc
.convert(self
, v
) \
339 for v
in value
.strip('[').strip(']').split(',') ]
341 # singleton: coerce to a single-element list
342 tmp_list
= [ ParamDesc
.convert(self
, value
) ]
344 if isSimObjectSequence(tmp_list
):
345 return SimObjectVector(tmp_list
)
347 return VectorParamValue(tmp_list
)
349 # Produce a human readable example string that describes
350 # how to set this vector parameter in the absence of a default
352 def example_str(self
):
353 s
= super(VectorParamDesc
, self
).example_str()
354 help_str
= "[" + s
+ "," + s
+ ", ...]"
357 # Produce a human readable representation of the value of this vector param.
358 def pretty_print(self
, value
):
359 if isinstance(value
, (list, tuple)):
360 tmp_list
= [ ParamDesc
.pretty_print(self
, v
) for v
in value
]
361 elif isinstance(value
, str):
362 tmp_list
= [ ParamDesc
.pretty_print(self
, v
) for v
in value
.split(',') ]
364 tmp_list
= [ ParamDesc
.pretty_print(self
, value
) ]
368 # This is a helper function for the new config system
369 def __call__(self
, value
):
370 if isinstance(value
, (list, tuple)):
371 # list: coerce each element into new list
372 tmp_list
= [ ParamDesc
.convert(self
, v
) for v
in value
]
373 elif isinstance(value
, str):
374 # If input is a csv string
375 tmp_list
= [ ParamDesc
.convert(self
, v
) \
376 for v
in value
.strip('[').strip(']').split(',') ]
378 # singleton: coerce to a single-element list
379 tmp_list
= [ ParamDesc
.convert(self
, value
) ]
381 return VectorParamValue(tmp_list
)
383 def cxx_predecls(self
, code
):
384 code('#include <vector>')
385 self
.ptype
.cxx_predecls(code
)
387 def pybind_predecls(self
, code
):
388 code('#include <vector>')
389 self
.ptype
.pybind_predecls(code
)
391 def cxx_decl(self
, code
):
392 code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
394 class ParamFactory(object):
395 def __init__(self
, param_desc_class
, ptype_str
= None):
396 self
.param_desc_class
= param_desc_class
397 self
.ptype_str
= ptype_str
399 def __getattr__(self
, attr
):
401 attr
= self
.ptype_str
+ '.' + attr
402 return ParamFactory(self
.param_desc_class
, attr
)
404 # E.g., Param.Int(5, "number of widgets")
405 def __call__(self
, *args
, **kwargs
):
408 ptype
= allParams
[self
.ptype_str
]
410 # if name isn't defined yet, assume it's a SimObject, and
411 # try to resolve it later
413 return self
.param_desc_class(self
.ptype_str
, ptype
, *args
, **kwargs
)
415 Param
= ParamFactory(ParamDesc
)
416 VectorParam
= ParamFactory(VectorParamDesc
)
418 #####################################################################
422 # Though native Python types could be used to specify parameter types
423 # (the 'ptype' field of the Param and VectorParam classes), it's more
424 # flexible to define our own set of types. This gives us more control
425 # over how Python expressions are converted to values (via the
426 # __init__() constructor) and how these values are printed out (via
427 # the __str__() conversion method).
429 #####################################################################
431 # String-valued parameter. Just mixin the ParamValue class with the
432 # built-in str class.
433 class String(ParamValue
,str):
434 cxx_type
= 'std::string'
435 cmd_line_settable
= True
438 def cxx_predecls(self
, code
):
439 code('#include <string>')
441 def __call__(self
, value
):
446 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
447 code('%s = %s;' % (dest
, src
))
448 code('%s true;' % ret
)
453 # superclass for "numeric" parameter values, to emulate math
454 # operations in a type-safe way. e.g., a Latency times an int returns
455 # a new Latency object.
456 class NumericParamValue(ParamValue
):
459 return v
.value
if isinstance(v
, NumericParamValue
) else v
462 return str(self
.value
)
465 return float(self
.value
)
468 return long(self
.value
)
471 return int(self
.value
)
473 # hook for bounds checking
477 def __mul__(self
, other
):
478 newobj
= self
.__class
__(self
)
479 newobj
.value
*= NumericParamValue
.unwrap(other
)
485 def __truediv__(self
, other
):
486 newobj
= self
.__class
__(self
)
487 newobj
.value
/= NumericParamValue
.unwrap(other
)
491 def __floordiv__(self
, other
):
492 newobj
= self
.__class
__(self
)
493 newobj
.value
//= NumericParamValue
.unwrap(other
)
498 def __add__(self
, other
):
499 newobj
= self
.__class
__(self
)
500 newobj
.value
+= NumericParamValue
.unwrap(other
)
504 def __sub__(self
, other
):
505 newobj
= self
.__class
__(self
)
506 newobj
.value
-= NumericParamValue
.unwrap(other
)
510 def __iadd__(self
, other
):
511 self
.value
+= NumericParamValue
.unwrap(other
)
515 def __isub__(self
, other
):
516 self
.value
-= NumericParamValue
.unwrap(other
)
520 def __imul__(self
, other
):
521 self
.value
*= NumericParamValue
.unwrap(other
)
525 def __itruediv__(self
, other
):
526 self
.value
/= NumericParamValue
.unwrap(other
)
530 def __ifloordiv__(self
, other
):
531 self
.value
//= NumericParamValue
.unwrap(other
)
535 def __lt__(self
, other
):
536 return self
.value
< NumericParamValue
.unwrap(other
)
538 # Python 2.7 pre __future__.division operators
539 # TODO: Remove these when after "import division from __future__"
540 __div__
= __truediv__
541 __idiv__
= __itruediv__
543 def config_value(self
):
547 def cxx_ini_predecls(cls
, code
):
548 # Assume that base/str.hh will be included anyway
549 # code('#include "base/str.hh"')
552 # The default for parsing PODs from an .ini entry is to extract from an
553 # istringstream and let overloading choose the right type according to
556 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
557 code('%s to_number(%s, %s);' % (ret
, src
, dest
))
559 # Metaclass for bounds-checked integer parameters. See CheckedInt.
560 class CheckedIntType(MetaParamValue
):
561 def __init__(cls
, name
, bases
, dict):
562 super(CheckedIntType
, cls
).__init
__(name
, bases
, dict)
564 # CheckedInt is an abstract base class, so we actually don't
565 # want to do any processing on it... the rest of this code is
566 # just for classes that derive from CheckedInt.
567 if name
== 'CheckedInt':
570 if not (hasattr(cls
, 'min') and hasattr(cls
, 'max')):
571 if not (hasattr(cls
, 'size') and hasattr(cls
, 'unsigned')):
572 panic("CheckedInt subclass %s must define either\n" \
573 " 'min' and 'max' or 'size' and 'unsigned'\n",
577 cls
.max = 2 ** cls
.size
- 1
579 cls
.min = -(2 ** (cls
.size
- 1))
580 cls
.max = (2 ** (cls
.size
- 1)) - 1
582 # Abstract superclass for bounds-checked integer parameters. This
583 # class is subclassed to generate parameter classes with specific
584 # bounds. Initialization of the min and max bounds is done in the
585 # metaclass CheckedIntType.__init__.
586 class CheckedInt(NumericParamValue
):
587 __metaclass__
= CheckedIntType
588 cmd_line_settable
= True
591 if not self
.min <= self
.value
<= self
.max:
592 raise TypeError('Integer param out of bounds %d < %d < %d' % \
593 (self
.min, self
.value
, self
.max))
595 def __init__(self
, value
):
596 if isinstance(value
, str):
597 self
.value
= convert
.toInteger(value
)
598 elif isinstance(value
, (int, long, float, NumericParamValue
)):
599 self
.value
= long(value
)
601 raise TypeError("Can't convert object of type %s to CheckedInt" \
602 % type(value
).__name
__)
605 def __call__(self
, value
):
610 return int(self
.value
)
613 def cxx_predecls(cls
, code
):
614 # most derived types require this, so we just do it here once
615 code('#include "base/types.hh"')
618 return long(self
.value
)
620 class Int(CheckedInt
): cxx_type
= 'int'; size
= 32; unsigned
= False
621 class Unsigned(CheckedInt
): cxx_type
= 'unsigned'; size
= 32; unsigned
= True
623 class Int8(CheckedInt
): cxx_type
= 'int8_t'; size
= 8; unsigned
= False
624 class UInt8(CheckedInt
): cxx_type
= 'uint8_t'; size
= 8; unsigned
= True
625 class Int16(CheckedInt
): cxx_type
= 'int16_t'; size
= 16; unsigned
= False
626 class UInt16(CheckedInt
): cxx_type
= 'uint16_t'; size
= 16; unsigned
= True
627 class Int32(CheckedInt
): cxx_type
= 'int32_t'; size
= 32; unsigned
= False
628 class UInt32(CheckedInt
): cxx_type
= 'uint32_t'; size
= 32; unsigned
= True
629 class Int64(CheckedInt
): cxx_type
= 'int64_t'; size
= 64; unsigned
= False
630 class UInt64(CheckedInt
): cxx_type
= 'uint64_t'; size
= 64; unsigned
= True
632 class Counter(CheckedInt
): cxx_type
= 'Counter'; size
= 64; unsigned
= True
633 class Tick(CheckedInt
): cxx_type
= 'Tick'; size
= 64; unsigned
= True
634 class TcpPort(CheckedInt
): cxx_type
= 'uint16_t'; size
= 16; unsigned
= True
635 class UdpPort(CheckedInt
): cxx_type
= 'uint16_t'; size
= 16; unsigned
= True
637 class Percent(CheckedInt
): cxx_type
= 'int'; min = 0; max = 100
639 class Cycles(CheckedInt
):
645 from _m5
.core
import Cycles
646 return Cycles(self
.value
)
649 def cxx_ini_predecls(cls
, code
):
650 # Assume that base/str.hh will be included anyway
651 # code('#include "base/str.hh"')
655 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
656 code('uint64_t _temp;')
657 code('bool _ret = to_number(%s, _temp);' % src
)
659 code(' %s = Cycles(_temp);' % dest
)
660 code('%s _ret;' % ret
)
662 class Float(ParamValue
, float):
664 cmd_line_settable
= True
666 def __init__(self
, value
):
667 if isinstance(value
, (int, long, float, NumericParamValue
, Float
, str)):
668 self
.value
= float(value
)
670 raise TypeError("Can't convert object of type %s to Float" \
671 % type(value
).__name
__)
673 def __call__(self
, value
):
678 return float(self
.value
)
680 def config_value(self
):
684 def cxx_ini_predecls(cls
, code
):
685 code('#include <sstream>')
688 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
689 code('%s (std::istringstream(%s) >> %s).eof();' % (ret
, src
, dest
))
691 class MemorySize(CheckedInt
):
692 cxx_type
= 'uint64_t'
696 def __init__(self
, value
):
697 if isinstance(value
, MemorySize
):
698 self
.value
= value
.value
700 self
.value
= convert
.toMemorySize(value
)
703 class MemorySize32(CheckedInt
):
704 cxx_type
= 'uint32_t'
708 def __init__(self
, value
):
709 if isinstance(value
, MemorySize
):
710 self
.value
= value
.value
712 self
.value
= convert
.toMemorySize(value
)
715 class Addr(CheckedInt
):
719 def __init__(self
, value
):
720 if isinstance(value
, Addr
):
721 self
.value
= value
.value
724 # Often addresses are referred to with sizes. Ex: A device
725 # base address is at "512MB". Use toMemorySize() to convert
726 # these into addresses. If the address is not specified with a
727 # "size", an exception will occur and numeric translation will
729 self
.value
= convert
.toMemorySize(value
)
730 except (TypeError, ValueError):
731 # Convert number to string and use long() to do automatic
732 # base conversion (requires base=0 for auto-conversion)
733 self
.value
= long(str(value
), base
=0)
736 def __add__(self
, other
):
737 if isinstance(other
, Addr
):
738 return self
.value
+ other
.value
740 return self
.value
+ other
741 def pretty_print(self
, value
):
743 val
= convert
.toMemorySize(value
)
746 return "0x%x" % long(val
)
748 class AddrRange(ParamValue
):
749 cxx_type
= 'AddrRange'
751 def __init__(self
, *args
, **kwargs
):
752 # Disable interleaving and hashing by default
753 self
.intlvHighBit
= 0
758 def handle_kwargs(self
, kwargs
):
759 # An address range needs to have an upper limit, specified
760 # either explicitly with an end, or as an offset using the
763 self
.end
= Addr(kwargs
.pop('end'))
764 elif 'size' in kwargs
:
765 self
.end
= self
.start
+ Addr(kwargs
.pop('size')) - 1
767 raise TypeError("Either end or size must be specified")
769 # Now on to the optional bit
770 if 'intlvHighBit' in kwargs
:
771 self
.intlvHighBit
= int(kwargs
.pop('intlvHighBit'))
772 if 'xorHighBit' in kwargs
:
773 self
.xorHighBit
= int(kwargs
.pop('xorHighBit'))
774 if 'intlvBits' in kwargs
:
775 self
.intlvBits
= int(kwargs
.pop('intlvBits'))
776 if 'intlvMatch' in kwargs
:
777 self
.intlvMatch
= int(kwargs
.pop('intlvMatch'))
780 self
.start
= Addr(kwargs
.pop('start'))
781 handle_kwargs(self
, kwargs
)
785 self
.start
= Addr(args
[0])
786 handle_kwargs(self
, kwargs
)
787 elif isinstance(args
[0], (list, tuple)):
788 self
.start
= Addr(args
[0][0])
789 self
.end
= Addr(args
[0][1])
792 self
.end
= Addr(args
[0]) - 1
795 self
.start
= Addr(args
[0])
796 self
.end
= Addr(args
[1])
798 raise TypeError("Too many arguments specified")
801 raise TypeError("Too many keywords: %s" % list(kwargs
.keys()))
804 return '%s:%s:%s:%s:%s:%s' \
805 % (self
.start
, self
.end
, self
.intlvHighBit
, self
.xorHighBit
,\
806 self
.intlvBits
, self
.intlvMatch
)
809 # Divide the size by the size of the interleaving slice
810 return (long(self
.end
) - long(self
.start
) + 1) >> self
.intlvBits
813 def cxx_predecls(cls
, code
):
814 Addr
.cxx_predecls(code
)
815 code('#include "base/addr_range.hh"')
818 def pybind_predecls(cls
, code
):
819 Addr
.pybind_predecls(code
)
820 code('#include "base/addr_range.hh"')
823 def cxx_ini_predecls(cls
, code
):
824 code('#include <sstream>')
827 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
828 code('uint64_t _start, _end, _intlvHighBit = 0, _xorHighBit = 0;')
829 code('uint64_t _intlvBits = 0, _intlvMatch = 0;')
831 code('std::istringstream _stream(${src});')
832 code('_stream >> _start;')
833 code('_stream.get(_sep);')
834 code('_stream >> _end;')
835 code('if (!_stream.fail() && !_stream.eof()) {')
836 code(' _stream.get(_sep);')
837 code(' _stream >> _intlvHighBit;')
838 code(' _stream.get(_sep);')
839 code(' _stream >> _xorHighBit;')
840 code(' _stream.get(_sep);')
841 code(' _stream >> _intlvBits;')
842 code(' _stream.get(_sep);')
843 code(' _stream >> _intlvMatch;')
845 code('bool _ret = !_stream.fail() &&'
846 '_stream.eof() && _sep == \':\';')
848 code(' ${dest} = AddrRange(_start, _end, _intlvHighBit, \
849 _xorHighBit, _intlvBits, _intlvMatch);')
853 # Go from the Python class to the wrapped C++ class
854 from _m5
.range import AddrRange
856 return AddrRange(long(self
.start
), long(self
.end
),
857 int(self
.intlvHighBit
), int(self
.xorHighBit
),
858 int(self
.intlvBits
), int(self
.intlvMatch
))
860 # Boolean parameter type. Python doesn't let you subclass bool, since
861 # it doesn't want to let you create multiple instances of True and
862 # False. Thus this is a little more complicated than String.
863 class Bool(ParamValue
):
865 cmd_line_settable
= True
867 def __init__(self
, value
):
869 self
.value
= convert
.toBool(value
)
871 self
.value
= bool(value
)
873 def __call__(self
, value
):
878 return bool(self
.value
)
881 return str(self
.value
)
883 # implement truth value testing for Bool parameters so that these params
884 # evaluate correctly during the python configuration phase
886 return bool(self
.value
)
888 # Python 2.7 uses __nonzero__ instead of __bool__
889 __nonzero__
= __bool__
896 def config_value(self
):
900 def cxx_ini_predecls(cls
, code
):
901 # Assume that base/str.hh will be included anyway
902 # code('#include "base/str.hh"')
906 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
907 code('%s to_bool(%s, %s);' % (ret
, src
, dest
))
909 def IncEthernetAddr(addr
, val
= 1):
910 bytes
= [ int(x
, 16) for x
in addr
.split(':') ]
912 for i
in (5, 4, 3, 2, 1):
913 val
,rem
= divmod(bytes
[i
], 256)
918 assert(bytes
[0] <= 255)
919 return ':'.join(map(lambda x
: '%02x' % x
, bytes
))
921 _NextEthernetAddr
= "00:90:00:00:00:01"
922 def NextEthernetAddr():
923 global _NextEthernetAddr
925 value
= _NextEthernetAddr
926 _NextEthernetAddr
= IncEthernetAddr(_NextEthernetAddr
, 1)
929 class EthernetAddr(ParamValue
):
930 cxx_type
= 'Net::EthAddr'
931 ex_str
= "00:90:00:00:00:01"
932 cmd_line_settable
= True
935 def cxx_predecls(cls
, code
):
936 code('#include "base/inet.hh"')
938 def __init__(self
, value
):
939 if value
== NextEthernetAddr
:
943 if not isinstance(value
, str):
944 raise TypeError("expected an ethernet address and didn't get one")
946 bytes
= value
.split(':')
948 raise TypeError('invalid ethernet address %s' % value
)
951 if not 0 <= int(byte
, base
=16) <= 0xff:
952 raise TypeError('invalid ethernet address %s' % value
)
956 def __call__(self
, value
):
960 def unproxy(self
, base
):
961 if self
.value
== NextEthernetAddr
:
962 return EthernetAddr(self
.value())
966 from _m5
.net
import EthAddr
967 return EthAddr(self
.value
)
976 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
977 code('%s = Net::EthAddr(%s);' % (dest
, src
))
978 code('%s true;' % ret
)
980 # When initializing an IpAddress, pass in an existing IpAddress, a string of
981 # the form "a.b.c.d", or an integer representing an IP.
982 class IpAddress(ParamValue
):
983 cxx_type
= 'Net::IpAddress'
985 cmd_line_settable
= True
988 def cxx_predecls(cls
, code
):
989 code('#include "base/inet.hh"')
991 def __init__(self
, value
):
992 if isinstance(value
, IpAddress
):
996 self
.ip
= convert
.toIpAddress(value
)
998 self
.ip
= long(value
)
1001 def __call__(self
, value
):
1002 self
.__init
__(value
)
1006 tup
= [(self
.ip
>> i
) & 0xff for i
in (24, 16, 8, 0)]
1007 return '%d.%d.%d.%d' % tuple(tup
)
1009 def __eq__(self
, other
):
1010 if isinstance(other
, IpAddress
):
1011 return self
.ip
== other
.ip
1012 elif isinstance(other
, str):
1014 return self
.ip
== convert
.toIpAddress(other
)
1018 return self
.ip
== other
1020 def __ne__(self
, other
):
1021 return not (self
== other
)
1024 if self
.ip
< 0 or self
.ip
>= (1 << 32):
1025 raise TypeError("invalid ip address %#08x" % self
.ip
)
1028 from _m5
.net
import IpAddress
1029 return IpAddress(self
.ip
)
1031 # When initializing an IpNetmask, pass in an existing IpNetmask, a string of
1032 # the form "a.b.c.d/n" or "a.b.c.d/e.f.g.h", or an ip and netmask as
1033 # positional or keyword arguments.
1034 class IpNetmask(IpAddress
):
1035 cxx_type
= 'Net::IpNetmask'
1036 ex_str
= "127.0.0.0/24"
1037 cmd_line_settable
= True
1040 def cxx_predecls(cls
, code
):
1041 code('#include "base/inet.hh"')
1043 def __init__(self
, *args
, **kwargs
):
1044 def handle_kwarg(self
, kwargs
, key
, elseVal
= None):
1046 setattr(self
, key
, kwargs
.pop(key
))
1048 setattr(self
, key
, elseVal
)
1050 raise TypeError("No value set for %s" % key
)
1053 handle_kwarg(self
, kwargs
, 'ip')
1054 handle_kwarg(self
, kwargs
, 'netmask')
1056 elif len(args
) == 1:
1058 if not 'ip' in kwargs
and not 'netmask' in kwargs
:
1059 raise TypeError("Invalid arguments")
1060 handle_kwarg(self
, kwargs
, 'ip', args
[0])
1061 handle_kwarg(self
, kwargs
, 'netmask', args
[0])
1062 elif isinstance(args
[0], IpNetmask
):
1063 self
.ip
= args
[0].ip
1064 self
.netmask
= args
[0].netmask
1066 (self
.ip
, self
.netmask
) = convert
.toIpNetmask(args
[0])
1068 elif len(args
) == 2:
1070 self
.netmask
= args
[1]
1072 raise TypeError("Too many arguments specified")
1075 raise TypeError("Too many keywords: %s" % list(kwargs
.keys()))
1079 def __call__(self
, value
):
1080 self
.__init
__(value
)
1084 return "%s/%d" % (super(IpNetmask
, self
).__str
__(), self
.netmask
)
1086 def __eq__(self
, other
):
1087 if isinstance(other
, IpNetmask
):
1088 return self
.ip
== other
.ip
and self
.netmask
== other
.netmask
1089 elif isinstance(other
, str):
1091 return (self
.ip
, self
.netmask
) == convert
.toIpNetmask(other
)
1099 if self
.netmask
< 0 or self
.netmask
> 32:
1100 raise TypeError("invalid netmask %d" % netmask
)
1103 from _m5
.net
import IpNetmask
1104 return IpNetmask(self
.ip
, self
.netmask
)
1106 # When initializing an IpWithPort, pass in an existing IpWithPort, a string of
1107 # the form "a.b.c.d:p", or an ip and port as positional or keyword arguments.
1108 class IpWithPort(IpAddress
):
1109 cxx_type
= 'Net::IpWithPort'
1110 ex_str
= "127.0.0.1:80"
1111 cmd_line_settable
= True
1114 def cxx_predecls(cls
, code
):
1115 code('#include "base/inet.hh"')
1117 def __init__(self
, *args
, **kwargs
):
1118 def handle_kwarg(self
, kwargs
, key
, elseVal
= None):
1120 setattr(self
, key
, kwargs
.pop(key
))
1122 setattr(self
, key
, elseVal
)
1124 raise TypeError("No value set for %s" % key
)
1127 handle_kwarg(self
, kwargs
, 'ip')
1128 handle_kwarg(self
, kwargs
, 'port')
1130 elif len(args
) == 1:
1132 if not 'ip' in kwargs
and not 'port' in kwargs
:
1133 raise TypeError("Invalid arguments")
1134 handle_kwarg(self
, kwargs
, 'ip', args
[0])
1135 handle_kwarg(self
, kwargs
, 'port', args
[0])
1136 elif isinstance(args
[0], IpWithPort
):
1137 self
.ip
= args
[0].ip
1138 self
.port
= args
[0].port
1140 (self
.ip
, self
.port
) = convert
.toIpWithPort(args
[0])
1142 elif len(args
) == 2:
1146 raise TypeError("Too many arguments specified")
1149 raise TypeError("Too many keywords: %s" % list(kwargs
.keys()))
1153 def __call__(self
, value
):
1154 self
.__init
__(value
)
1158 return "%s:%d" % (super(IpWithPort
, self
).__str
__(), self
.port
)
1160 def __eq__(self
, other
):
1161 if isinstance(other
, IpWithPort
):
1162 return self
.ip
== other
.ip
and self
.port
== other
.port
1163 elif isinstance(other
, str):
1165 return (self
.ip
, self
.port
) == convert
.toIpWithPort(other
)
1173 if self
.port
< 0 or self
.port
> 0xffff:
1174 raise TypeError("invalid port %d" % self
.port
)
1177 from _m5
.net
import IpWithPort
1178 return IpWithPort(self
.ip
, self
.port
)
1180 time_formats
= [ "%a %b %d %H:%M:%S %Z %Y",
1181 "%a %b %d %H:%M:%S %Y",
1182 "%Y/%m/%d %H:%M:%S",
1185 "%m/%d/%Y %H:%M:%S",
1188 "%m/%d/%y %H:%M:%S",
1193 def parse_time(value
):
1194 from time
import gmtime
, strptime
, struct_time
, time
1195 from datetime
import datetime
, date
1197 if isinstance(value
, struct_time
):
1200 if isinstance(value
, (int, long)):
1201 return gmtime(value
)
1203 if isinstance(value
, (datetime
, date
)):
1204 return value
.timetuple()
1206 if isinstance(value
, str):
1207 if value
in ('Now', 'Today'):
1208 return time
.gmtime(time
.time())
1210 for format
in time_formats
:
1212 return strptime(value
, format
)
1216 raise ValueError("Could not parse '%s' as a time" % value
)
1218 class Time(ParamValue
):
1222 def cxx_predecls(cls
, code
):
1223 code('#include <time.h>')
1225 def __init__(self
, value
):
1226 self
.value
= parse_time(value
)
1228 def __call__(self
, value
):
1229 self
.__init
__(value
)
1233 from _m5
.core
import tm
1236 return tm
.gmtime(calendar
.timegm(self
.value
))
1239 return time
.asctime(self
.value
)
1244 def get_config_as_dict(self
):
1249 def cxx_ini_predecls(cls
, code
):
1250 code('#include <time.h>')
1253 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
1254 code('char *_parse_ret = strptime((${src}).c_str(),')
1255 code(' "%a %b %d %H:%M:%S %Y", &(${dest}));')
1256 code('${ret} _parse_ret && *_parse_ret == \'\\0\';');
1258 # Enumerated types are a little more complex. The user specifies the
1259 # type as Enum(foo) where foo is either a list or dictionary of
1260 # alternatives (typically strings, but not necessarily so). (In the
1261 # long run, the integer value of the parameter will be the list index
1262 # or the corresponding dictionary value. For now, since we only check
1263 # that the alternative is valid and then spit it into a .ini file,
1264 # there's not much point in using the dictionary.)
1266 # What Enum() must do is generate a new type encapsulating the
1267 # provided list/dictionary so that specific values of the parameter
1268 # can be instances of that type. We define two hidden internal
1269 # classes (_ListEnum and _DictEnum) to serve as base classes, then
1270 # derive the new type from the appropriate base class on the fly.
1273 # Metaclass for Enum types
1274 class MetaEnum(MetaParamValue
):
1275 def __new__(mcls
, name
, bases
, dict):
1276 assert name
not in allEnums
1278 cls
= super(MetaEnum
, mcls
).__new
__(mcls
, name
, bases
, dict)
1279 allEnums
[name
] = cls
1282 def __init__(cls
, name
, bases
, init_dict
):
1283 if 'map' in init_dict
:
1284 if not isinstance(cls
.map, dict):
1285 raise TypeError("Enum-derived class attribute 'map' " \
1286 "must be of type dict")
1287 # build list of value strings from map
1288 cls
.vals
= list(cls
.map.keys())
1290 elif 'vals' in init_dict
:
1291 if not isinstance(cls
.vals
, list):
1292 raise TypeError("Enum-derived class attribute 'vals' " \
1293 "must be of type list")
1294 # build string->value map from vals sequence
1296 for idx
,val
in enumerate(cls
.vals
):
1299 raise TypeError("Enum-derived class must define "\
1300 "attribute 'map' or 'vals'")
1303 cls
.cxx_type
= '%s' % name
1305 cls
.cxx_type
= 'Enums::%s' % name
1307 super(MetaEnum
, cls
).__init
__(name
, bases
, init_dict
)
1309 # Generate C++ class declaration for this enum type.
1310 # Note that we wrap the enum in a class/struct to act as a namespace,
1311 # so that the enum strings can be brief w/o worrying about collisions.
1312 def cxx_decl(cls
, code
):
1313 wrapper_name
= cls
.wrapper_name
1314 wrapper
= 'struct' if cls
.wrapper_is_struct
else 'namespace'
1315 name
= cls
.__name
__ if cls
.enum_name
is None else cls
.enum_name
1316 idem_macro
= '__ENUM__%s__%s__' % (wrapper_name
, name
)
1329 $wrapper $wrapper_name {
1334 for val
in cls
.vals
:
1335 code('$val = ${{cls.map[val]}},')
1336 code('Num_$name = ${{len(cls.vals)}}')
1342 extern const char *${name}Strings[static_cast<int>(${name}::Num_${name})];
1344 elif cls
.wrapper_is_struct
:
1345 code('static const char *${name}Strings[Num_${name}];')
1347 code('extern const char *${name}Strings[Num_${name}];')
1349 if not cls
.is_class
:
1354 code('#endif // $idem_macro')
1356 def cxx_def(cls
, code
):
1357 wrapper_name
= cls
.wrapper_name
1358 file_name
= cls
.__name
__
1359 name
= cls
.__name
__ if cls
.enum_name
is None else cls
.enum_name
1361 code('#include "enums/$file_name.hh"')
1362 if cls
.wrapper_is_struct
:
1363 code('const char *${wrapper_name}::${name}Strings'
1368 const char *${name}Strings[static_cast<int>(${name}::Num_${name})] =
1371 code('namespace Enums {')
1373 code('const char *${name}Strings[Num_${name}] =')
1377 for val
in cls
.vals
:
1382 if not cls
.wrapper_is_struct
and not cls
.is_class
:
1384 code('} // namespace $wrapper_name')
1387 def pybind_def(cls
, code
):
1389 enum_name
= cls
.__name
__ if cls
.enum_name
is None else cls
.enum_name
1390 wrapper_name
= enum_name
if cls
.is_class
else cls
.wrapper_name
1392 code('''#include "pybind11/pybind11.h"
1393 #include "pybind11/stl.h"
1395 #include <sim/init.hh>
1397 namespace py = pybind11;
1400 module_init(py::module &m_internal)
1402 py::module m = m_internal.def_submodule("enum_${name}");
1406 code('py::enum_<${enum_name}>(m, "enum_${name}")')
1408 code('py::enum_<${wrapper_name}::${enum_name}>(m, "enum_${name}")')
1412 for val
in cls
.vals
:
1413 code('.value("${val}", ${wrapper_name}::${val})')
1414 code('.value("Num_${name}", ${wrapper_name}::Num_${enum_name})')
1415 code('.export_values()')
1422 code('static EmbeddedPyBind embed_enum("enum_${name}", module_init);')
1425 # Base class for enum types.
1426 class Enum(ParamValue
):
1427 __metaclass__
= MetaEnum
1429 cmd_line_settable
= True
1431 # The name of the wrapping namespace or struct
1432 wrapper_name
= 'Enums'
1434 # If true, the enum is wrapped in a struct rather than a namespace
1435 wrapper_is_struct
= False
1439 # If not None, use this as the enum name rather than this class name
1442 def __init__(self
, value
):
1443 if value
not in self
.map:
1444 raise TypeError("Enum param got bad value '%s' (not in %s)" \
1445 % (value
, self
.vals
))
1448 def __call__(self
, value
):
1449 self
.__init
__(value
)
1453 def cxx_predecls(cls
, code
):
1454 code('#include "enums/$0.hh"', cls
.__name
__)
1457 def cxx_ini_parse(cls
, code
, src
, dest
, ret
):
1458 code('if (false) {')
1459 for elem_name
in cls
.map.keys():
1460 code('} else if (%s == "%s") {' % (src
, elem_name
))
1462 code('%s = Enums::%s;' % (dest
, elem_name
))
1463 code('%s true;' % ret
)
1466 code(' %s false;' % ret
)
1470 import m5
.internal
.params
1471 e
= getattr(m5
.internal
.params
, "enum_%s" % self
.__class
__.__name
__)
1472 return e(self
.map[self
.value
])
1477 # This param will generate a scoped c++ enum and its python bindings.
1478 class ScopedEnum(Enum
):
1479 __metaclass__
= MetaEnum
1481 cmd_line_settable
= True
1483 # The name of the wrapping namespace or struct
1486 # If true, the enum is wrapped in a struct rather than a namespace
1487 wrapper_is_struct
= False
1489 # If true, the generated enum is a scoped enum
1492 # If not None, use this as the enum name rather than this class name
1495 # how big does a rounding error need to be before we warn about it?
1496 frequency_tolerance
= 0.001 # 0.1%
1498 class TickParamValue(NumericParamValue
):
1501 cmd_line_settable
= True
1504 def cxx_predecls(cls
, code
):
1505 code('#include "base/types.hh"')
1507 def __call__(self
, value
):
1508 self
.__init
__(value
)
1512 return long(self
.value
)
1515 def cxx_ini_predecls(cls
, code
):
1516 code('#include <sstream>')
1518 # Ticks are expressed in seconds in JSON files and in plain
1519 # Ticks in .ini files. Switch based on a config flag
1521 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
1522 code('${ret} to_number(${src}, ${dest});')
1524 class Latency(TickParamValue
):
1527 def __init__(self
, value
):
1528 if isinstance(value
, (Latency
, Clock
)):
1529 self
.ticks
= value
.ticks
1530 self
.value
= value
.value
1531 elif isinstance(value
, Frequency
):
1532 self
.ticks
= value
.ticks
1533 self
.value
= 1.0 / value
.value
1534 elif value
.endswith('t'):
1536 self
.value
= int(value
[:-1])
1539 self
.value
= convert
.toLatency(value
)
1541 def __call__(self
, value
):
1542 self
.__init
__(value
)
1545 def __getattr__(self
, attr
):
1546 if attr
in ('latency', 'period'):
1548 if attr
== 'frequency':
1549 return Frequency(self
)
1550 raise AttributeError("Latency object has no attribute '%s'" % attr
)
1553 if self
.ticks
or self
.value
== 0:
1556 value
= ticks
.fromSeconds(self
.value
)
1559 def config_value(self
):
1560 return self
.getValue()
1562 # convert latency to ticks
1564 return '%d' % self
.getValue()
1566 class Frequency(TickParamValue
):
1569 def __init__(self
, value
):
1570 if isinstance(value
, (Latency
, Clock
)):
1571 if value
.value
== 0:
1574 self
.value
= 1.0 / value
.value
1575 self
.ticks
= value
.ticks
1576 elif isinstance(value
, Frequency
):
1577 self
.value
= value
.value
1578 self
.ticks
= value
.ticks
1581 self
.value
= convert
.toFrequency(value
)
1583 def __call__(self
, value
):
1584 self
.__init
__(value
)
1587 def __getattr__(self
, attr
):
1588 if attr
== 'frequency':
1590 if attr
in ('latency', 'period'):
1591 return Latency(self
)
1592 raise AttributeError("Frequency object has no attribute '%s'" % attr
)
1594 # convert latency to ticks
1596 if self
.ticks
or self
.value
== 0:
1599 value
= ticks
.fromSeconds(1.0 / self
.value
)
1602 def config_value(self
):
1603 return self
.getValue()
1606 return '%d' % self
.getValue()
1608 # A generic Frequency and/or Latency value. Value is stored as a
1609 # latency, just like Latency and Frequency.
1610 class Clock(TickParamValue
):
1611 def __init__(self
, value
):
1612 if isinstance(value
, (Latency
, Clock
)):
1613 self
.ticks
= value
.ticks
1614 self
.value
= value
.value
1615 elif isinstance(value
, Frequency
):
1616 self
.ticks
= value
.ticks
1617 self
.value
= 1.0 / value
.value
1618 elif value
.endswith('t'):
1620 self
.value
= int(value
[:-1])
1623 self
.value
= convert
.anyToLatency(value
)
1625 def __call__(self
, value
):
1626 self
.__init
__(value
)
1630 return "%s" % Latency(self
)
1632 def __getattr__(self
, attr
):
1633 if attr
== 'frequency':
1634 return Frequency(self
)
1635 if attr
in ('latency', 'period'):
1636 return Latency(self
)
1637 raise AttributeError("Frequency object has no attribute '%s'" % attr
)
1640 return self
.period
.getValue()
1642 def config_value(self
):
1643 return self
.period
.config_value()
1646 return self
.period
.ini_str()
1648 class Voltage(Float
):
1651 def __new__(cls
, value
):
1652 value
= convert
.toVoltage(value
)
1653 return super(cls
, Voltage
).__new
__(cls
, value
)
1655 def __init__(self
, value
):
1656 value
= convert
.toVoltage(value
)
1657 super(Voltage
, self
).__init
__(value
)
1659 class Current(Float
):
1662 def __new__(cls
, value
):
1663 value
= convert
.toCurrent(value
)
1664 return super(cls
, Current
).__new
__(cls
, value
)
1666 def __init__(self
, value
):
1667 value
= convert
.toCurrent(value
)
1668 super(Current
, self
).__init
__(value
)
1670 class Energy(Float
):
1673 def __new__(cls
, value
):
1674 value
= convert
.toEnergy(value
)
1675 return super(cls
, Energy
).__new
__(cls
, value
)
1677 def __init__(self
, value
):
1678 value
= convert
.toEnergy(value
)
1679 super(Energy
, self
).__init
__(value
)
1681 class NetworkBandwidth(float,ParamValue
):
1684 cmd_line_settable
= True
1686 def __new__(cls
, value
):
1687 # convert to bits per second
1688 val
= convert
.toNetworkBandwidth(value
)
1689 return super(cls
, NetworkBandwidth
).__new
__(cls
, val
)
1692 return str(self
.val
)
1694 def __call__(self
, value
):
1695 val
= convert
.toNetworkBandwidth(value
)
1700 # convert to seconds per byte
1701 value
= 8.0 / float(self
)
1702 # convert to ticks per byte
1703 value
= ticks
.fromSeconds(value
)
1707 return '%f' % self
.getValue()
1709 def config_value(self
):
1710 return '%f' % self
.getValue()
1713 def cxx_ini_predecls(cls
, code
):
1714 code('#include <sstream>')
1717 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
1718 code('%s (std::istringstream(%s) >> %s).eof();' % (ret
, src
, dest
))
1720 class MemoryBandwidth(float,ParamValue
):
1723 cmd_line_settable
= True
1725 def __new__(cls
, value
):
1726 # convert to bytes per second
1727 val
= convert
.toMemoryBandwidth(value
)
1728 return super(cls
, MemoryBandwidth
).__new
__(cls
, val
)
1730 def __call__(self
, value
):
1731 val
= convert
.toMemoryBandwidth(value
)
1736 # convert to seconds per byte
1739 value
= 1.0 / float(self
)
1740 # convert to ticks per byte
1741 value
= ticks
.fromSeconds(value
)
1745 return '%f' % self
.getValue()
1747 def config_value(self
):
1748 return '%f' % self
.getValue()
1751 def cxx_ini_predecls(cls
, code
):
1752 code('#include <sstream>')
1755 def cxx_ini_parse(self
, code
, src
, dest
, ret
):
1756 code('%s (std::istringstream(%s) >> %s).eof();' % (ret
, src
, dest
))
1759 # "Constants"... handy aliases for various values.
1762 # Special class for NULL pointers. Note the special check in
1763 # make_param_value() above that lets these be assigned where a
1764 # SimObject is required.
1765 # only one copy of a particular node
1766 class NullSimObject(object):
1767 __metaclass__
= Singleton
1773 def _instantiate(self
, parent
= None, path
= ''):
1779 def unproxy(self
, base
):
1782 def set_path(self
, parent
, name
):
1785 def set_parent(self
, parent
, name
):
1788 def clear_parent(self
, old_parent
):
1791 def descendants(self
):
1795 def get_config_as_dict(self
):
1801 def config_value(self
):
1807 # The only instance you'll ever need...
1808 NULL
= NullSimObject()
1810 def isNullPointer(value
):
1811 return isinstance(value
, NullSimObject
)
1813 # Some memory range specifications use this as a default upper bound.
1816 AllMemory
= AddrRange(0, MaxAddr
)
1819 #####################################################################
1823 # Ports are used to interconnect objects in the memory system.
1825 #####################################################################
1827 # Port reference: encapsulates a reference to a particular port on a
1828 # particular SimObject.
1829 class PortRef(object):
1830 def __init__(self
, simobj
, name
, role
):
1831 assert(isSimObject(simobj
) or isSimObjectClass(simobj
))
1832 self
.simobj
= simobj
1835 self
.peer
= None # not associated with another port yet
1836 self
.ccConnected
= False # C++ port connection done?
1837 self
.index
= -1 # always -1 for non-vector ports
1840 return '%s.%s' % (self
.simobj
, self
.name
)
1843 # Return the number of connected ports, i.e. 0 is we have no
1844 # peer and 1 if we do.
1845 return int(self
.peer
!= None)
1847 # for config.ini, print peer's name (not ours)
1849 return str(self
.peer
)
1852 def get_config_as_dict(self
):
1853 return {'role' : self
.role
, 'peer' : str(self
.peer
)}
1855 def __getattr__(self
, attr
):
1856 if attr
== 'peerObj':
1857 # shorthand for proxies
1858 return self
.peer
.simobj
1859 raise AttributeError("'%s' object has no attribute '%s'" % \
1860 (self
.__class
__.__name
__, attr
))
1862 # Full connection is symmetric (both ways). Called via
1863 # SimObject.__setattr__ as a result of a port assignment, e.g.,
1864 # "obj1.portA = obj2.portB", or via VectorPortElementRef.__setitem__,
1865 # e.g., "obj1.portA[3] = obj2.portB".
1866 def connect(self
, other
):
1867 if isinstance(other
, VectorPortRef
):
1868 # reference to plain VectorPort is implicit append
1869 other
= other
._get
_next
()
1870 if self
.peer
and not proxy
.isproxy(self
.peer
):
1871 fatal("Port %s is already connected to %s, cannot connect %s\n",
1872 self
, self
.peer
, other
);
1874 if proxy
.isproxy(other
):
1875 other
.set_param_desc(PortParamDesc())
1876 elif isinstance(other
, PortRef
):
1877 if other
.peer
is not self
:
1880 raise TypeError("assigning non-port reference '%s' to port '%s'" \
1883 # Allow a master/slave port pair to be spliced between
1884 # a port and its connected peer. Useful operation for connecting
1885 # instrumentation structures into a system when it is necessary
1886 # to connect the instrumentation after the full system has been
1888 def splice(self
, new_master_peer
, new_slave_peer
):
1889 if not self
.peer
or proxy
.isproxy(self
.peer
):
1890 fatal("Port %s not connected, cannot splice in new peers\n", self
)
1892 if not isinstance(new_master_peer
, PortRef
) or \
1893 not isinstance(new_slave_peer
, PortRef
):
1895 "Splicing non-port references '%s','%s' to port '%s'" % \
1896 (new_master_peer
, new_slave_peer
, self
))
1898 old_peer
= self
.peer
1899 if self
.role
== 'SLAVE':
1900 self
.peer
= new_master_peer
1901 old_peer
.peer
= new_slave_peer
1902 new_master_peer
.connect(self
)
1903 new_slave_peer
.connect(old_peer
)
1904 elif self
.role
== 'MASTER':
1905 self
.peer
= new_slave_peer
1906 old_peer
.peer
= new_master_peer
1907 new_slave_peer
.connect(self
)
1908 new_master_peer
.connect(old_peer
)
1910 panic("Port %s has unknown role, "+\
1911 "cannot splice in new peers\n", self
)
1913 def clone(self
, simobj
, memo
):
1916 newRef
= copy
.copy(self
)
1918 newRef
.simobj
= simobj
1919 assert(isSimObject(newRef
.simobj
))
1920 if self
.peer
and not proxy
.isproxy(self
.peer
):
1921 peerObj
= self
.peer
.simobj(_memo
=memo
)
1922 newRef
.peer
= self
.peer
.clone(peerObj
, memo
)
1923 assert(not isinstance(newRef
.peer
, VectorPortRef
))
1926 def unproxy(self
, simobj
):
1927 assert(simobj
is self
.simobj
)
1928 if proxy
.isproxy(self
.peer
):
1930 realPeer
= self
.peer
.unproxy(self
.simobj
)
1932 print("Error in unproxying port '%s' of %s" %
1933 (self
.name
, self
.simobj
.path()))
1935 self
.connect(realPeer
)
1937 # Call C++ to create corresponding port connection between C++ objects
1938 def ccConnect(self
):
1939 from _m5
.pyobject
import connectPorts
1941 if self
.ccConnected
: # already done this
1945 if not self
.peer
: # nothing to connect to
1948 # check that we connect a master to a slave
1949 if self
.role
== peer
.role
:
1951 "cannot connect '%s' and '%s' due to identical role '%s'" % \
1952 (peer
, self
, self
.role
))
1954 if self
.role
== 'SLAVE':
1955 # do nothing and let the master take care of it
1959 # self is always the master and peer the slave
1960 connectPorts(self
.simobj
.getCCObject(), self
.name
, self
.index
,
1961 peer
.simobj
.getCCObject(), peer
.name
, peer
.index
)
1963 print("Error connecting port %s.%s to %s.%s" %
1964 (self
.simobj
.path(), self
.name
,
1965 peer
.simobj
.path(), peer
.name
))
1967 self
.ccConnected
= True
1968 peer
.ccConnected
= True
1970 # A reference to an individual element of a VectorPort... much like a
1971 # PortRef, but has an index.
1972 class VectorPortElementRef(PortRef
):
1973 def __init__(self
, simobj
, name
, role
, index
):
1974 PortRef
.__init
__(self
, simobj
, name
, role
)
1978 return '%s.%s[%d]' % (self
.simobj
, self
.name
, self
.index
)
1980 # A reference to a complete vector-valued port (not just a single element).
1981 # Can be indexed to retrieve individual VectorPortElementRef instances.
1982 class VectorPortRef(object):
1983 def __init__(self
, simobj
, name
, role
):
1984 assert(isSimObject(simobj
) or isSimObjectClass(simobj
))
1985 self
.simobj
= simobj
1991 return '%s.%s[:]' % (self
.simobj
, self
.name
)
1994 # Return the number of connected peers, corresponding the the
1995 # length of the elements.
1996 return len(self
.elements
)
1998 # for config.ini, print peer's name (not ours)
2000 return ' '.join([el
.ini_str() for el
in self
.elements
])
2003 def get_config_as_dict(self
):
2004 return {'role' : self
.role
,
2005 'peer' : [el
.ini_str() for el
in self
.elements
]}
2007 def __getitem__(self
, key
):
2008 if not isinstance(key
, int):
2009 raise TypeError("VectorPort index must be integer")
2010 if key
>= len(self
.elements
):
2011 # need to extend list
2012 ext
= [VectorPortElementRef(self
.simobj
, self
.name
, self
.role
, i
)
2013 for i
in range(len(self
.elements
), key
+1)]
2014 self
.elements
.extend(ext
)
2015 return self
.elements
[key
]
2017 def _get_next(self
):
2018 return self
[len(self
.elements
)]
2020 def __setitem__(self
, key
, value
):
2021 if not isinstance(key
, int):
2022 raise TypeError("VectorPort index must be integer")
2023 self
[key
].connect(value
)
2025 def connect(self
, other
):
2026 if isinstance(other
, (list, tuple)):
2027 # Assign list of port refs to vector port.
2028 # For now, append them... not sure if that's the right semantics
2029 # or if it should replace the current vector.
2031 self
._get
_next
().connect(ref
)
2033 # scalar assignment to plain VectorPort is implicit append
2034 self
._get
_next
().connect(other
)
2036 def clone(self
, simobj
, memo
):
2039 newRef
= copy
.copy(self
)
2041 newRef
.simobj
= simobj
2042 assert(isSimObject(newRef
.simobj
))
2043 newRef
.elements
= [el
.clone(simobj
, memo
) for el
in self
.elements
]
2046 def unproxy(self
, simobj
):
2047 [el
.unproxy(simobj
) for el
in self
.elements
]
2049 def ccConnect(self
):
2050 [el
.ccConnect() for el
in self
.elements
]
2052 # Port description object. Like a ParamDesc object, this represents a
2053 # logical port in the SimObject class, not a particular port on a
2054 # SimObject instance. The latter are represented by PortRef objects.
2056 # Generate a PortRef for this port on the given SimObject with the
2058 def makeRef(self
, simobj
):
2059 return PortRef(simobj
, self
.name
, self
.role
)
2061 # Connect an instance of this port (on the given SimObject with
2062 # the given name) with the port described by the supplied PortRef
2063 def connect(self
, simobj
, ref
):
2064 self
.makeRef(simobj
).connect(ref
)
2066 # No need for any pre-declarations at the moment as we merely rely
2067 # on an unsigned int.
2068 def cxx_predecls(self
, code
):
2071 def pybind_predecls(self
, code
):
2072 cls
.cxx_predecls(self
, code
)
2074 # Declare an unsigned int with the same name as the port, that
2075 # will eventually hold the number of connected ports (and thus the
2076 # number of elements for a VectorPort).
2077 def cxx_decl(self
, code
):
2078 code('unsigned int port_${{self.name}}_connection_count;')
2080 class MasterPort(Port
):
2081 # MasterPort("description")
2082 def __init__(self
, *args
):
2085 self
.role
= 'MASTER'
2087 raise TypeError('wrong number of arguments')
2089 class SlavePort(Port
):
2090 # SlavePort("description")
2091 def __init__(self
, *args
):
2096 raise TypeError('wrong number of arguments')
2098 # VectorPort description object. Like Port, but represents a vector
2099 # of connections (e.g., as on a XBar).
2100 class VectorPort(Port
):
2101 def __init__(self
, *args
):
2104 def makeRef(self
, simobj
):
2105 return VectorPortRef(simobj
, self
.name
, self
.role
)
2107 class VectorMasterPort(VectorPort
):
2108 # VectorMasterPort("description")
2109 def __init__(self
, *args
):
2112 self
.role
= 'MASTER'
2113 VectorPort
.__init
__(self
, *args
)
2115 raise TypeError('wrong number of arguments')
2117 class VectorSlavePort(VectorPort
):
2118 # VectorSlavePort("description")
2119 def __init__(self
, *args
):
2123 VectorPort
.__init
__(self
, *args
)
2125 raise TypeError('wrong number of arguments')
2127 # 'Fake' ParamDesc for Port references to assign to the _pdesc slot of
2128 # proxy objects (via set_param_desc()) so that proxy error messages
2130 class PortParamDesc(object):
2131 __metaclass__
= Singleton
2136 baseEnums
= allEnums
.copy()
2137 baseParams
= allParams
.copy()
2140 global allEnums
, allParams
2142 allEnums
= baseEnums
.copy()
2143 allParams
= baseParams
.copy()
2145 __all__
= ['Param', 'VectorParam',
2146 'Enum', 'ScopedEnum', 'Bool', 'String', 'Float',
2147 'Int', 'Unsigned', 'Int8', 'UInt8', 'Int16', 'UInt16',
2148 'Int32', 'UInt32', 'Int64', 'UInt64',
2149 'Counter', 'Addr', 'Tick', 'Percent',
2150 'TcpPort', 'UdpPort', 'EthernetAddr',
2151 'IpAddress', 'IpNetmask', 'IpWithPort',
2152 'MemorySize', 'MemorySize32',
2153 'Latency', 'Frequency', 'Clock', 'Voltage', 'Current', 'Energy',
2154 'NetworkBandwidth', 'MemoryBandwidth',
2156 'MaxAddr', 'MaxTick', 'AllMemory',
2158 'NextEthernetAddr', 'NULL',
2159 'MasterPort', 'SlavePort',
2160 'VectorMasterPort', 'VectorSlavePort']